Macro LIBVIR_CHECK_VERSION

#define LIBVIR_CHECK_VERSION(major, minor, micro);

Macro for developers to easily check what version of the library their code is compiling against. e.g. #if LIBVIR_CHECK_VERSION(1,1,3) // some code that only works in 1.1.3 and newer #endif

Macro LIBVIR_VERSION_NUMBER

#define LIBVIR_VERSION_NUMBER;

Macro providing the version of the library as version * 1,000,000 + minor * 1000 + micro

Macro VIR_COPY_CPUMAP

#define VIR_COPY_CPUMAP(cpumaps, maplen, vcpu, cpumap);

This macro is to be used in conjunction with virDomainGetVcpus() and virDomainPinVcpu() APIs. VIR_COPY_CPUMAP macro extracts the cpumap of the specified vcpu from cpumaps array and copies it into cpumap to be used later by virDomainPinVcpu() API.

Macro VIR_CPU_MAPLEN

#define VIR_CPU_MAPLEN(cpu);

This macro is to be used in conjunction with virDomainPinVcpu() API. It returns the length (in bytes) required to store the complete CPU map between a single virtual & all physical CPUs of a domain.

Macro VIR_CPU_USABLE

#define VIR_CPU_USABLE(cpumaps, maplen, vcpu, cpu);

This macro is to be used in conjunction with virDomainGetVcpus() API. VIR_CPU_USABLE macro returns a non-zero value (true) if the cpu is usable by the vcpu, and 0 otherwise.

Macro VIR_CPU_USED

#define VIR_CPU_USED(cpumap, cpu);

This macro can be used in conjunction with virNodeGetCPUMap() API. It returns non-zero if the bit of the related CPU is set.

Macro VIR_DOMAIN_BANDWIDTH_IN_AVERAGE

#define VIR_DOMAIN_BANDWIDTH_IN_AVERAGE;

Macro represents the inbound average of NIC bandwidth, as a uint.

Macro VIR_DOMAIN_BANDWIDTH_IN_BURST

#define VIR_DOMAIN_BANDWIDTH_IN_BURST;

Macro represents the inbound burst of NIC bandwidth, as a uint.

Macro VIR_DOMAIN_BANDWIDTH_IN_PEAK

#define VIR_DOMAIN_BANDWIDTH_IN_PEAK;

Macro represents the inbound peak of NIC bandwidth, as a uint.

Macro VIR_DOMAIN_BANDWIDTH_OUT_AVERAGE

#define VIR_DOMAIN_BANDWIDTH_OUT_AVERAGE;

Macro represents the outbound average of NIC bandwidth, as a uint.

Macro VIR_DOMAIN_BANDWIDTH_OUT_BURST

#define VIR_DOMAIN_BANDWIDTH_OUT_BURST;

Macro represents the outbound burst of NIC bandwidth, as a uint.

Macro VIR_DOMAIN_BANDWIDTH_OUT_PEAK

#define VIR_DOMAIN_BANDWIDTH_OUT_PEAK;

Macro represents the outbound peak of NIC bandwidth, as a uint.

Macro VIR_DOMAIN_BLKIO_DEVICE_READ_BPS

#define VIR_DOMAIN_BLKIO_DEVICE_READ_BPS;

Macro for the blkio tunable throttle.read_iops_device: it represents the bytes of reading the block device per second, as a string. The string is parsed as a series of /path/to/device, read_bps elements, separated by ','.

Macro VIR_DOMAIN_BLKIO_DEVICE_READ_IOPS

#define VIR_DOMAIN_BLKIO_DEVICE_READ_IOPS;

Macro for the blkio tunable throttle.read_iops_device: it represents the number of reading the block device per second, as a string. The string is parsed as a series of /path/to/device, read_iops elements, separated by ','.

Macro VIR_DOMAIN_BLKIO_DEVICE_WEIGHT

#define VIR_DOMAIN_BLKIO_DEVICE_WEIGHT;

Macro for the blkio tunable weight_device: it represents the per-device weight, as a string. The string is parsed as a series of /path/to/device,weight elements, separated by ','.

Macro VIR_DOMAIN_BLKIO_DEVICE_WRITE_BPS

#define VIR_DOMAIN_BLKIO_DEVICE_WRITE_BPS;

Macro for the blkio tunable throttle.read_iops_device: it represents the number of reading the block device per second, as a string. The string is parsed as a series of /path/to/device, write_bps elements, separated by ','.

Macro VIR_DOMAIN_BLKIO_DEVICE_WRITE_IOPS

#define VIR_DOMAIN_BLKIO_DEVICE_WRITE_IOPS;

Macro for the blkio tunable throttle.write_iops_device: it represents the number of writing the block device per second, as a string. The string is parsed as a series of /path/to/device, write_iops elements, separated by ','.

Macro VIR_DOMAIN_BLKIO_FIELD_LENGTH

#define VIR_DOMAIN_BLKIO_FIELD_LENGTH;

Macro providing the field length of virBlkioParameter. Provided for backwards compatibility; VIR_TYPED_PARAM_FIELD_LENGTH is the preferred value since 0.9.2.

Macro VIR_DOMAIN_BLKIO_WEIGHT

#define VIR_DOMAIN_BLKIO_WEIGHT;

Macro for the Blkio tunable weight: it represents the io weight the guest can use, as a uint.

Macro VIR_DOMAIN_BLOCK_COPY_BANDWIDTH

#define VIR_DOMAIN_BLOCK_COPY_BANDWIDTH;

Macro for the virDomainBlockCopy bandwidth tunable: it represents the maximum bandwidth in bytes/s, and is used while getting the copy operation into the mirrored phase, with a type of ullong. For compatibility with virDomainBlockJobSetSpeed(), values larger than 2^52 bytes/sec (a 32-bit MiB/s value) may be rejected on input due to overflow considerations (but do you really have an interface with that much bandwidth?), and values larger than 2^31 bytes/sec may cause overflow problems if queried in bytes/sec. Hypervisors may further restrict the set of valid values. Specifying 0 is the same as omitting this parameter, to request no bandwidth limiting. Some hypervisors may lack support for this parameter, while still allowing a subsequent change of bandwidth via virDomainBlockJobSetSpeed(). The actual speed can be determined with virDomainGetBlockJobInfo().

Macro VIR_DOMAIN_BLOCK_COPY_BUF_SIZE

#define VIR_DOMAIN_BLOCK_COPY_BUF_SIZE;

Macro for the virDomainBlockCopy buffer size tunable: it represents how much data in bytes can be in flight between source and destination, as an unsigned long long. Specifying 0 is the same as omitting this parameter, to request the hypervisor default.

Macro VIR_DOMAIN_BLOCK_COPY_GRANULARITY

#define VIR_DOMAIN_BLOCK_COPY_GRANULARITY;

Macro for the virDomainBlockCopy granularity tunable: it represents the granularity in bytes at which the copy operation recognizes dirty blocks that need copying, as an unsigned int. Hypervisors may restrict this to be a power of two or fall within a certain range. Specifying 0 is the same as omitting this parameter, to request the hypervisor default.

Macro VIR_DOMAIN_BLOCK_IOTUNE_READ_BYTES_SEC

#define VIR_DOMAIN_BLOCK_IOTUNE_READ_BYTES_SEC;

Macro for the BlockIoTune tunable weight: it represents the read bytes per second permitted through a block device, as a ullong.

Macro VIR_DOMAIN_BLOCK_IOTUNE_READ_IOPS_SEC

#define VIR_DOMAIN_BLOCK_IOTUNE_READ_IOPS_SEC;

Macro for the BlockIoTune tunable weight: it represents the read I/O operations per second permitted through a block device, as a ullong.

Macro VIR_DOMAIN_BLOCK_IOTUNE_TOTAL_BYTES_SEC

#define VIR_DOMAIN_BLOCK_IOTUNE_TOTAL_BYTES_SEC;

Macro for the BlockIoTune tunable weight: it represents the total bytes per second permitted through a block device, as a ullong.

Macro VIR_DOMAIN_BLOCK_IOTUNE_TOTAL_IOPS_SEC

#define VIR_DOMAIN_BLOCK_IOTUNE_TOTAL_IOPS_SEC;

Macro for the BlockIoTune tunable weight: it represents the total I/O operations per second permitted through a block device, as a ullong.

Macro VIR_DOMAIN_BLOCK_IOTUNE_WRITE_BYTES_SEC

#define VIR_DOMAIN_BLOCK_IOTUNE_WRITE_BYTES_SEC;

Macro for the BlockIoTune tunable weight: it represents the write bytes per second permitted through a block device, as a ullong.

Macro VIR_DOMAIN_BLOCK_IOTUNE_WRITE_IOPS_SEC

#define VIR_DOMAIN_BLOCK_IOTUNE_WRITE_IOPS_SEC;

Macro for the BlockIoTune tunable weight: it represents the write I/O operations per second permitted through a block device, as a ullong.

Macro VIR_DOMAIN_BLOCK_STATS_ERRS

#define VIR_DOMAIN_BLOCK_STATS_ERRS;

In Xen this returns the mysterious 'oo_req', as an llong.

Macro VIR_DOMAIN_BLOCK_STATS_FIELD_LENGTH

#define VIR_DOMAIN_BLOCK_STATS_FIELD_LENGTH;

Macro providing the field length of parameter names when using virDomainBlockStatsFlags().

Macro VIR_DOMAIN_BLOCK_STATS_FLUSH_REQ

#define VIR_DOMAIN_BLOCK_STATS_FLUSH_REQ;

Macro represents the total flush requests of the block device, as an llong.

Macro VIR_DOMAIN_BLOCK_STATS_FLUSH_TOTAL_TIMES

#define VIR_DOMAIN_BLOCK_STATS_FLUSH_TOTAL_TIMES;

Macro represents the total time spend on cache flushing in nano-seconds of the block device, as an llong.

Macro VIR_DOMAIN_BLOCK_STATS_READ_BYTES

#define VIR_DOMAIN_BLOCK_STATS_READ_BYTES;

Macro represents the total number of read bytes of the block device, as an llong.

Macro VIR_DOMAIN_BLOCK_STATS_READ_REQ

#define VIR_DOMAIN_BLOCK_STATS_READ_REQ;

Macro represents the total read requests of the block device, as an llong.

Macro VIR_DOMAIN_BLOCK_STATS_READ_TOTAL_TIMES

#define VIR_DOMAIN_BLOCK_STATS_READ_TOTAL_TIMES;

Macro represents the total time spend on cache reads in nano-seconds of the block device, as an llong.

Macro VIR_DOMAIN_BLOCK_STATS_WRITE_BYTES

#define VIR_DOMAIN_BLOCK_STATS_WRITE_BYTES;

Macro represents the total number of write bytes of the block device, as an llong.

Macro VIR_DOMAIN_BLOCK_STATS_WRITE_REQ

#define VIR_DOMAIN_BLOCK_STATS_WRITE_REQ;

Macro represents the total write requests of the block device, as an llong.

Macro VIR_DOMAIN_BLOCK_STATS_WRITE_TOTAL_TIMES

#define VIR_DOMAIN_BLOCK_STATS_WRITE_TOTAL_TIMES;

Macro represents the total time spend on cache writes in nano-seconds of the block device, as an llong.

Macro VIR_DOMAIN_CPU_STATS_CPUTIME

#define VIR_DOMAIN_CPU_STATS_CPUTIME;

cpu usage (sum of both vcpu and hypervisor usage) in nanoseconds, as a ullong

Macro VIR_DOMAIN_CPU_STATS_SYSTEMTIME

#define VIR_DOMAIN_CPU_STATS_SYSTEMTIME;

cpu time charged to system instructions in nanoseconds, as a ullong

Macro VIR_DOMAIN_CPU_STATS_USERTIME

#define VIR_DOMAIN_CPU_STATS_USERTIME;

cpu time charged to user instructions in nanoseconds, as a ullong

Macro VIR_DOMAIN_CPU_STATS_VCPUTIME

#define VIR_DOMAIN_CPU_STATS_VCPUTIME;

vcpu usage in nanoseconds (cpu_time excluding hypervisor time), as a ullong

Macro VIR_DOMAIN_EVENT_CALLBACK

#define VIR_DOMAIN_EVENT_CALLBACK;

Used to cast the event specific callback into the generic one for use for virConnectDomainEventRegisterAny()

Macro VIR_DOMAIN_JOB_COMPRESSION_BYTES

#define VIR_DOMAIN_JOB_COMPRESSION_BYTES;

virDomainGetJobStats field: number of compressed bytes transferred since the beginning of migration, as VIR_TYPED_PARAM_ULLONG.

Macro VIR_DOMAIN_JOB_COMPRESSION_CACHE

#define VIR_DOMAIN_JOB_COMPRESSION_CACHE;

virDomainGetJobStats field: size of the cache (in bytes) used for compressing repeatedly transferred memory pages during live migration, as VIR_TYPED_PARAM_ULLONG.

Macro VIR_DOMAIN_JOB_COMPRESSION_CACHE_MISSES

#define VIR_DOMAIN_JOB_COMPRESSION_CACHE_MISSES;

virDomainGetJobStats field: number of repeatedly changing pages that were not found in compression cache and thus could not be compressed, as VIR_TYPED_PARAM_ULLONG.

Macro VIR_DOMAIN_JOB_COMPRESSION_OVERFLOW

#define VIR_DOMAIN_JOB_COMPRESSION_OVERFLOW;

virDomainGetJobStats field: number of repeatedly changing pages that were found in compression cache but were sent uncompressed because the result of compression was larger than the original page as a whole, as VIR_TYPED_PARAM_ULLONG.

Macro VIR_DOMAIN_JOB_COMPRESSION_PAGES

#define VIR_DOMAIN_JOB_COMPRESSION_PAGES;

virDomainGetJobStats field: number of compressed pages transferred since the beginning of migration, as VIR_TYPED_PARAM_ULLONG.

Macro VIR_DOMAIN_JOB_DATA_PROCESSED

#define VIR_DOMAIN_JOB_DATA_PROCESSED;

virDomainGetJobStats field: number of bytes transferred from the beginning of the job, as VIR_TYPED_PARAM_ULLONG. This field corresponds to dataProcessed field in virDomainJobInfo.

Macro VIR_DOMAIN_JOB_DATA_REMAINING

#define VIR_DOMAIN_JOB_DATA_REMAINING;

virDomainGetJobStats field: number of bytes that still need to be transferred, as VIR_TYPED_PARAM_ULLONG. This field corresponds to dataRemaining field in virDomainJobInfo.

Macro VIR_DOMAIN_JOB_DATA_TOTAL

#define VIR_DOMAIN_JOB_DATA_TOTAL;

virDomainGetJobStats field: total number of bytes supposed to be transferred, as VIR_TYPED_PARAM_ULLONG. For VIR_DOMAIN_JOB_UNBOUNDED jobs, this may be less than the sum of VIR_DOMAIN_JOB_DATA_PROCESSED and VIR_DOMAIN_JOB_DATA_REMAINING in the event that the hypervisor has to repeat some data, e.g., due to dirtied pages during migration. For VIR_DOMAIN_JOB_BOUNDED jobs, VIR_DOMAIN_JOB_DATA_TOTAL shall always equal VIR_DOMAIN_JOB_DATA_PROCESSED + VIR_DOMAIN_JOB_DATA_REMAINING. This field corresponds to dataTotal field in virDomainJobInfo.

Macro VIR_DOMAIN_JOB_DISK_BPS

#define VIR_DOMAIN_JOB_DISK_BPS;

virDomainGetJobStats field: network throughput used while migrating disks in Bytes per second, as VIR_TYPED_PARAM_ULLONG.

Macro VIR_DOMAIN_JOB_DISK_PROCESSED

#define VIR_DOMAIN_JOB_DISK_PROCESSED;

virDomainGetJobStats field: as VIR_DOMAIN_JOB_DATA_PROCESSED but only tracking guest disk progress, as VIR_TYPED_PARAM_ULLONG. This field corresponds to fileProcessed field in virDomainJobInfo.

Macro VIR_DOMAIN_JOB_DISK_REMAINING

#define VIR_DOMAIN_JOB_DISK_REMAINING;

virDomainGetJobStats field: as VIR_DOMAIN_JOB_DATA_REMAINING but only tracking guest disk progress, as VIR_TYPED_PARAM_ULLONG. This field corresponds to fileRemaining field in virDomainJobInfo.

Macro VIR_DOMAIN_JOB_DISK_TOTAL

#define VIR_DOMAIN_JOB_DISK_TOTAL;

virDomainGetJobStats field: as VIR_DOMAIN_JOB_DATA_TOTAL but only tracking guest disk progress, as VIR_TYPED_PARAM_ULLONG. This field corresponds to fileTotal field in virDomainJobInfo.

Macro VIR_DOMAIN_JOB_DOWNTIME

#define VIR_DOMAIN_JOB_DOWNTIME;

virDomainGetJobStats field: downtime (ms) that is expected to happen during migration, as VIR_TYPED_PARAM_ULLONG.

Macro VIR_DOMAIN_JOB_MEMORY_BPS

#define VIR_DOMAIN_JOB_MEMORY_BPS;

virDomainGetJobStats field: network throughput used while migrating memory in Bytes per second, as VIR_TYPED_PARAM_ULLONG.

Macro VIR_DOMAIN_JOB_MEMORY_CONSTANT

#define VIR_DOMAIN_JOB_MEMORY_CONSTANT;

virDomainGetJobStats field: number of pages filled with a constant byte (all bytes in a single page are identical) transferred since the beginning of the migration job, as VIR_TYPED_PARAM_ULLONG. The most common example of such pages are zero pages, i.e., pages filled with zero bytes.

Macro VIR_DOMAIN_JOB_MEMORY_NORMAL

#define VIR_DOMAIN_JOB_MEMORY_NORMAL;

virDomainGetJobStats field: number of pages that were transferred without any kind of compression (i.e., pages which were not filled with a constant byte and which could not be compressed) transferred since the beginning of the migration job, as VIR_TYPED_PARAM_ULLONG.

Macro VIR_DOMAIN_JOB_MEMORY_NORMAL_BYTES

#define VIR_DOMAIN_JOB_MEMORY_NORMAL_BYTES;

virDomainGetJobStats field: number of bytes transferred as normal pages, as VIR_TYPED_PARAM_ULLONG. See VIR_DOMAIN_JOB_MEMORY_NORMAL for more details.

Macro VIR_DOMAIN_JOB_MEMORY_PROCESSED

#define VIR_DOMAIN_JOB_MEMORY_PROCESSED;

virDomainGetJobStats field: as VIR_DOMAIN_JOB_DATA_PROCESSED but only tracking guest memory progress, as VIR_TYPED_PARAM_ULLONG. This field corresponds to memProcessed field in virDomainJobInfo.

Macro VIR_DOMAIN_JOB_MEMORY_REMAINING

#define VIR_DOMAIN_JOB_MEMORY_REMAINING;

virDomainGetJobStats field: as VIR_DOMAIN_JOB_DATA_REMAINING but only tracking guest memory progress, as VIR_TYPED_PARAM_ULLONG. This field corresponds to memRemaining field in virDomainJobInfo.

Macro VIR_DOMAIN_JOB_MEMORY_TOTAL

#define VIR_DOMAIN_JOB_MEMORY_TOTAL;

virDomainGetJobStats field: as VIR_DOMAIN_JOB_DATA_TOTAL but only tracking guest memory progress, as VIR_TYPED_PARAM_ULLONG. This field corresponds to memTotal field in virDomainJobInfo.

Macro VIR_DOMAIN_JOB_SETUP_TIME

#define VIR_DOMAIN_JOB_SETUP_TIME;

virDomainGetJobStats field: total time in milliseconds spent preparing the migration in the 'setup' phase before the iterations begin, as VIR_TYPED_PARAM_ULLONG.

Macro VIR_DOMAIN_JOB_TIME_ELAPSED

#define VIR_DOMAIN_JOB_TIME_ELAPSED;

virDomainGetJobStats field: time (ms) since the beginning of the job, as VIR_TYPED_PARAM_ULLONG. This field corresponds to timeElapsed field in virDomainJobInfo.

Macro VIR_DOMAIN_JOB_TIME_REMAINING

#define VIR_DOMAIN_JOB_TIME_REMAINING;

virDomainGetJobStats field: remaining time (ms) for VIR_DOMAIN_JOB_BOUNDED jobs, as VIR_TYPED_PARAM_ULLONG. This field corresponds to timeRemaining field in virDomainJobInfo.

Macro VIR_DOMAIN_MEMORY_FIELD_LENGTH

#define VIR_DOMAIN_MEMORY_FIELD_LENGTH;

Macro providing the field length of virMemoryParameter. Provided for backwards compatibility; VIR_TYPED_PARAM_FIELD_LENGTH is the preferred value since 0.9.2.

Macro VIR_DOMAIN_MEMORY_HARD_LIMIT

#define VIR_DOMAIN_MEMORY_HARD_LIMIT;

Macro for the memory tunable hard_limit: it represents the maximum memory the guest can use, as a ullong.

Macro VIR_DOMAIN_MEMORY_MIN_GUARANTEE

#define VIR_DOMAIN_MEMORY_MIN_GUARANTEE;

Macro for the memory tunable min_guarantee: it represents the minimum memory guaranteed to be reserved for the guest, as a ullong.

Macro VIR_DOMAIN_MEMORY_PARAM_UNLIMITED

#define VIR_DOMAIN_MEMORY_PARAM_UNLIMITED;

Macro providing the virMemoryParameter value that indicates "unlimited"

Macro VIR_DOMAIN_MEMORY_SOFT_LIMIT

#define VIR_DOMAIN_MEMORY_SOFT_LIMIT;

Macro for the memory tunable soft_limit: it represents the memory upper limit enforced during memory contention, as a ullong.

Macro VIR_DOMAIN_MEMORY_SWAP_HARD_LIMIT

#define VIR_DOMAIN_MEMORY_SWAP_HARD_LIMIT;

Macro for the swap tunable swap_hard_limit: it represents the maximum swap plus memory the guest can use, as a ullong. This limit has to be more than VIR_DOMAIN_MEMORY_HARD_LIMIT.

Macro VIR_DOMAIN_NUMA_MODE

#define VIR_DOMAIN_NUMA_MODE;

Macro for typed parameter name that lists the numa mode of a domain, as an int containing a virDomainNumatuneMemMode value.

Macro VIR_DOMAIN_NUMA_NODESET

#define VIR_DOMAIN_NUMA_NODESET;

Macro for typed parameter name that lists the numa nodeset of a domain, as a string.

Macro VIR_DOMAIN_SCHEDULER_CAP

#define VIR_DOMAIN_SCHEDULER_CAP;

Macro represents the maximum scheduler cap, when using the credit scheduler, as a uint.

Macro VIR_DOMAIN_SCHEDULER_CPU_SHARES

#define VIR_DOMAIN_SCHEDULER_CPU_SHARES;

Macro represents proportional weight of the scheduler used on the host cpu, when using the posix scheduler, as a ullong.

Macro VIR_DOMAIN_SCHEDULER_EMULATOR_PERIOD

#define VIR_DOMAIN_SCHEDULER_EMULATOR_PERIOD;

Macro represents the enforcement period for a quota in microseconds, when using the posix scheduler, for all emulator activity not tied to vcpus, as a ullong.

Macro VIR_DOMAIN_SCHEDULER_EMULATOR_QUOTA

#define VIR_DOMAIN_SCHEDULER_EMULATOR_QUOTA;

Macro represents the maximum bandwidth to be used within a period for all emulator activity not tied to vcpus, when using the posix scheduler, as an llong.

Macro VIR_DOMAIN_SCHEDULER_LIMIT

#define VIR_DOMAIN_SCHEDULER_LIMIT;

Macro represents the scheduler limit value, when using the allocation scheduler, as an llong.

Macro VIR_DOMAIN_SCHEDULER_RESERVATION

#define VIR_DOMAIN_SCHEDULER_RESERVATION;

Macro represents the scheduler reservation value, when using the allocation scheduler, as an llong.

Macro VIR_DOMAIN_SCHEDULER_SHARES

#define VIR_DOMAIN_SCHEDULER_SHARES;

Macro represents the scheduler shares value, when using the allocation scheduler, as an int.

Macro VIR_DOMAIN_SCHEDULER_VCPU_PERIOD

#define VIR_DOMAIN_SCHEDULER_VCPU_PERIOD;

Macro represents the enforcement period for a quota, in microseconds, for vcpus only, when using the posix scheduler, as a ullong.

Macro VIR_DOMAIN_SCHEDULER_VCPU_QUOTA

#define VIR_DOMAIN_SCHEDULER_VCPU_QUOTA;

Macro represents the maximum bandwidth to be used within a period for vcpus only, when using the posix scheduler, as an llong.

Macro VIR_DOMAIN_SCHEDULER_WEIGHT

#define VIR_DOMAIN_SCHEDULER_WEIGHT;

Macro represents the relative weight, when using the credit scheduler, as a uint.

Macro VIR_DOMAIN_SCHED_FIELD_LENGTH

#define VIR_DOMAIN_SCHED_FIELD_LENGTH;

Macro providing the field length of virSchedParameter. Provided for backwards compatibility; VIR_TYPED_PARAM_FIELD_LENGTH is the preferred value since 0.9.2.

Macro VIR_DOMAIN_SEND_KEY_MAX_KEYS

#define VIR_DOMAIN_SEND_KEY_MAX_KEYS;

Maximum number of keycodes that can be sent in one virDomainSendKey() call.

Macro VIR_DOMAIN_TUNABLE_BLKDEV_DISK

#define VIR_DOMAIN_TUNABLE_BLKDEV_DISK;

Macro represents the name of guest disk for which the values are updated, as VIR_TYPED_PARAM_STRING.

Macro VIR_DOMAIN_TUNABLE_BLKDEV_READ_BYTES_SEC

#define VIR_DOMAIN_TUNABLE_BLKDEV_READ_BYTES_SEC;

Marco represents the read throughput limit in bytes per second, as VIR_TYPED_PARAM_ULLONG.

Macro VIR_DOMAIN_TUNABLE_BLKDEV_READ_IOPS_SEC

#define VIR_DOMAIN_TUNABLE_BLKDEV_READ_IOPS_SEC;

Macro represents the read I/O operations per second, as VIR_TYPED_PARAM_ULLONG.

Macro VIR_DOMAIN_TUNABLE_BLKDEV_TOTAL_BYTES_SEC

#define VIR_DOMAIN_TUNABLE_BLKDEV_TOTAL_BYTES_SEC;

Marco represents the total throughput limit in bytes per second, as VIR_TYPED_PARAM_ULLONG.

Macro VIR_DOMAIN_TUNABLE_BLKDEV_TOTAL_IOPS_SEC

#define VIR_DOMAIN_TUNABLE_BLKDEV_TOTAL_IOPS_SEC;

Macro represents the total I/O operations per second, as VIR_TYPED_PARAM_ULLONG.

Macro VIR_DOMAIN_TUNABLE_BLKDEV_WRITE_BYTES_SEC

#define VIR_DOMAIN_TUNABLE_BLKDEV_WRITE_BYTES_SEC;

Macro represents the write throughput limit in bytes per second, as VIR_TYPED_PARAM_ULLONG.

Macro VIR_DOMAIN_TUNABLE_BLKDEV_WRITE_IOPS_SEC

#define VIR_DOMAIN_TUNABLE_BLKDEV_WRITE_IOPS_SEC;

Macro represents the write I/O operations per second, as VIR_TYPED_PARAM_ULLONG.

Macro VIR_DOMAIN_TUNABLE_CPU_CPU_SHARES

#define VIR_DOMAIN_TUNABLE_CPU_CPU_SHARES;

Macro represents proportional weight of the scheduler used on the host cpu, when using the posix scheduler, as VIR_TYPED_PARAM_ULLONG.

Macro VIR_DOMAIN_TUNABLE_CPU_EMULATORPIN

#define VIR_DOMAIN_TUNABLE_CPU_EMULATORPIN;

Macro represents formatted pinning for emulator process, as VIR_TYPED_PARAM_STRING.

Macro VIR_DOMAIN_TUNABLE_CPU_EMULATOR_PERIOD

#define VIR_DOMAIN_TUNABLE_CPU_EMULATOR_PERIOD;

Macro represents the enforcement period for a quota in microseconds, when using the posix scheduler, for all emulator activity not tied to vcpus, as VIR_TYPED_PARAM_ULLONG.

Macro VIR_DOMAIN_TUNABLE_CPU_EMULATOR_QUOTA

#define VIR_DOMAIN_TUNABLE_CPU_EMULATOR_QUOTA;

Macro represents the maximum bandwidth to be used within a period for all emulator activity not tied to vcpus, when using the posix scheduler, as an VIR_TYPED_PARAM_LLONG.

Macro VIR_DOMAIN_TUNABLE_CPU_VCPUPIN

#define VIR_DOMAIN_TUNABLE_CPU_VCPUPIN;

Macro represents formatted pinning for one vcpu specified by id which is appended to the parameter name, for example "cputune.vcpupin1", as VIR_TYPED_PARAM_STRING.

Macro VIR_DOMAIN_TUNABLE_CPU_VCPU_PERIOD

#define VIR_DOMAIN_TUNABLE_CPU_VCPU_PERIOD;

Macro represents the enforcement period for a quota, in microseconds, for vcpus only, when using the posix scheduler, as VIR_TYPED_PARAM_ULLONG.

Macro VIR_DOMAIN_TUNABLE_CPU_VCPU_QUOTA

#define VIR_DOMAIN_TUNABLE_CPU_VCPU_QUOTA;

Macro represents the maximum bandwidth to be used within a period for vcpus only, when using the posix scheduler, as VIR_TYPED_PARAM_LLONG.

Macro VIR_GET_CPUMAP

#define VIR_GET_CPUMAP(cpumaps, maplen, vcpu);

This macro is to be used in conjunction with virDomainGetVcpus() and virDomainPinVcpu() APIs. VIR_GET_CPUMAP macro returns a pointer to the cpumap of the specified vcpu from cpumaps array.

Macro VIR_MIGRATE_PARAM_BANDWIDTH

#define VIR_MIGRATE_PARAM_BANDWIDTH;

virDomainMigrate* params field: the maximum bandwidth (in MiB/s) that will be used for migration as VIR_TYPED_PARAM_ULLONG. If set to 0 or omitted, libvirt will choose a suitable default. Some hypervisors do not support this feature and will return an error if this field is used and is not 0.

Macro VIR_MIGRATE_PARAM_DEST_NAME

#define VIR_MIGRATE_PARAM_DEST_NAME;

virDomainMigrate* params field: the name to be used for the domain on the destination host as VIR_TYPED_PARAM_STRING. Omitting this parameter keeps the domain name the same. This field is only allowed to be used with hypervisors that support domain renaming during migration.

Macro VIR_MIGRATE_PARAM_DEST_XML

#define VIR_MIGRATE_PARAM_DEST_XML;

virDomainMigrate* params field: the new configuration to be used for the domain on the destination host as VIR_TYPED_PARAM_STRING. The configuration must include an identical set of virtual devices, to ensure a stable guest ABI across migration. Only parameters related to host side configuration can be changed in the XML. Hypervisors which support this field will forbid migration if the provided XML would cause a change in the guest ABI. This field cannot be used to rename the domain during migration (use VIR_MIGRATE_PARAM_DEST_NAME field for that purpose). Domain name in the destination XML must match the original domain name. Omitting this parameter keeps the original domain configuration. Using this field with hypervisors that do not support changing domain configuration during migration will result in a failure.

Macro VIR_MIGRATE_PARAM_GRAPHICS_URI

#define VIR_MIGRATE_PARAM_GRAPHICS_URI;

virDomainMigrate* params field: URI to use for migrating client's connection to domain's graphical console as VIR_TYPED_PARAM_STRING. If specified, the client will be asked to automatically reconnect using these parameters instead of the automatically computed ones. This can be useful if, e.g., the client does not have a direct access to the network virtualization hosts are connected to and needs to connect through a proxy. The URI is formed as follows: protocol://hostname[:port]/[?parameters] where protocol is either "spice" or "vnc" and parameters is a list of protocol specific parameters separated by '&'. Currently recognized parameters are "tlsPort" and "tlsSubject". For example, spice://target.host.com:1234/?tlsPort=4567

Macro VIR_MIGRATE_PARAM_LISTEN_ADDRESS

#define VIR_MIGRATE_PARAM_LISTEN_ADDRESS;

virDomainMigrate* params field: The listen address that hypervisor on the destination side should bind to for incoming migration. Both IPv4 and IPv6 addresses are accepted as well as hostnames (the resolving is done on destination). Some hypervisors do not support this feature and will return an error if this field is used.

Macro VIR_MIGRATE_PARAM_URI

#define VIR_MIGRATE_PARAM_URI;

virDomainMigrate* params field: URI to use for initiating domain migration as VIR_TYPED_PARAM_STRING. It takes a hypervisor specific format. The uri_transports element of the hypervisor capabilities XML includes details of the supported URI schemes. When omitted libvirt will auto-generate suitable default URI. It is typically only necessary to specify this URI if the destination host has multiple interfaces and a specific interface is required to transmit migration data. This filed may not be used when VIR_MIGRATE_TUNNELLED flag is set.

Macro VIR_NETWORK_EVENT_CALLBACK

#define VIR_NETWORK_EVENT_CALLBACK;

Used to cast the event specific callback into the generic one for use for virConnectNetworkEventRegisterAny()

Macro VIR_NODEINFO_MAXCPUS

#define VIR_NODEINFO_MAXCPUS(nodeinfo);

This macro is to calculate the total number of CPUs supported but not necessary active in the host.

Macro VIR_NODE_CPU_STATS_FIELD_LENGTH

#define VIR_NODE_CPU_STATS_FIELD_LENGTH;

Macro providing the field length of virNodeCPUStats

Macro VIR_NODE_CPU_STATS_IDLE

#define VIR_NODE_CPU_STATS_IDLE;

The cumulative idle CPU time, since the node booting up (in nanoseconds).

Macro VIR_NODE_CPU_STATS_INTR

#define VIR_NODE_CPU_STATS_INTR;

The cumulative interrupt CPU time, since the node booting up (in nanoseconds).

Macro VIR_NODE_CPU_STATS_IOWAIT

#define VIR_NODE_CPU_STATS_IOWAIT;

The cumulative I/O wait CPU time, since the node booting up (in nanoseconds).

Macro VIR_NODE_CPU_STATS_KERNEL

#define VIR_NODE_CPU_STATS_KERNEL;

Macro for the cumulative CPU time which was spent by the kernel, since the node booting up (in nanoseconds).

Macro VIR_NODE_CPU_STATS_USER

#define VIR_NODE_CPU_STATS_USER;

The cumulative CPU time which was spent by user processes, since the node booting up (in nanoseconds).

Macro VIR_NODE_CPU_STATS_UTILIZATION

#define VIR_NODE_CPU_STATS_UTILIZATION;

The CPU utilization of a node. The usage value is in percent and 100% represents all CPUs of the node.

Macro VIR_NODE_MEMORY_STATS_BUFFERS

#define VIR_NODE_MEMORY_STATS_BUFFERS;

Macro for the buffer memory: On Linux, it is only returned in case of VIR_NODE_MEMORY_STATS_ALL_CELLS.

Macro VIR_NODE_MEMORY_STATS_CACHED

#define VIR_NODE_MEMORY_STATS_CACHED;

Macro for the cached memory: On Linux, it is only returned in case of VIR_NODE_MEMORY_STATS_ALL_CELLS.

Macro VIR_NODE_MEMORY_STATS_FIELD_LENGTH

#define VIR_NODE_MEMORY_STATS_FIELD_LENGTH;

Macro providing the field length of virNodeMemoryStats

Macro VIR_NODE_MEMORY_STATS_FREE

#define VIR_NODE_MEMORY_STATS_FREE;

Macro for the free memory of specified cell: On Linux, it includes buffer and cached memory, in case of VIR_NODE_MEMORY_STATS_ALL_CELLS.

Macro VIR_NODE_MEMORY_STATS_TOTAL

#define VIR_NODE_MEMORY_STATS_TOTAL;

Macro for the total memory of specified cell: it represents the maximum memory.

Macro VIR_SECURITY_DOI_BUFLEN

#define VIR_SECURITY_DOI_BUFLEN;

Macro providing the maximum length of the virSecurityModel doi string.

Macro VIR_SECURITY_LABEL_BUFLEN

#define VIR_SECURITY_LABEL_BUFLEN;

Macro providing the maximum length of the virSecurityLabel label string. Note that this value is based on that used by Labeled NFS.

Macro VIR_SECURITY_MODEL_BUFLEN

#define VIR_SECURITY_MODEL_BUFLEN;

Macro providing the maximum length of the virSecurityModel model string.

Macro VIR_TYPED_PARAM_FIELD_LENGTH

#define VIR_TYPED_PARAM_FIELD_LENGTH;

Macro providing the field length of virTypedParameter name

Macro VIR_UNUSE_CPU

#define VIR_UNUSE_CPU(cpumap, cpu);

This macro is to be used in conjunction with virDomainPinVcpu() API. It resets the bit (CPU not usable) of the related cpu in cpumap.

Macro VIR_USE_CPU

#define VIR_USE_CPU(cpumap, cpu);

This macro is to be used in conjunction with virDomainPinVcpu() API. It sets the bit (CPU usable) of the related cpu in cpumap.

Macro VIR_UUID_BUFLEN

#define VIR_UUID_BUFLEN;

This macro provides the length of the buffer required for virDomainGetUUID()

Macro VIR_UUID_STRING_BUFLEN

#define VIR_UUID_STRING_BUFLEN;

This macro provides the length of the buffer required for virDomainGetUUIDString()

Macro _virBlkioParameter

#define _virBlkioParameter;

Macro _virMemoryParameter

#define _virMemoryParameter;

Macro _virSchedParameter

#define _virSchedParameter;

Structure virBlkioParameter

struct _virTypedParameter {
    char field[VIR_TYPED_PARAM_FIELD_LENGTH]	field	: parameter name
    int	type	: parameter type, virTypedParameterType
    union	value	: parameter value
} virBlkioParameter;

Typedef virBlkioParameterPtr

virBlkioParameter * virBlkioParameterPtr;

a virBlkioParameterPtr is a pointer to a virBlkioParameter structure. Provided for backwards compatibility; virTypedParameterPtr is the preferred alias since 0.9.2.

Enum virBlkioParameterType

enum virBlkioParameterType {
    VIR_DOMAIN_BLKIO_PARAM_BOOLEAN = VIR_TYPED_PARAM_BOOLEAN
    VIR_DOMAIN_BLKIO_PARAM_DOUBLE = VIR_TYPED_PARAM_DOUBLE
    VIR_DOMAIN_BLKIO_PARAM_INT = VIR_TYPED_PARAM_INT
    VIR_DOMAIN_BLKIO_PARAM_LLONG = VIR_TYPED_PARAM_LLONG
    VIR_DOMAIN_BLKIO_PARAM_UINT = VIR_TYPED_PARAM_UINT
    VIR_DOMAIN_BLKIO_PARAM_ULLONG = VIR_TYPED_PARAM_ULLONG
};

Enum virCPUCompareResult

enum virCPUCompareResult {
    VIR_CPU_COMPARE_ERROR = -1
    VIR_CPU_COMPARE_INCOMPATIBLE = 0
    VIR_CPU_COMPARE_IDENTICAL = 1
    VIR_CPU_COMPARE_SUPERSET = 2
    VIR_CPU_COMPARE_LAST = 3
};

Structure virConnect

struct _virConnect {
The content of this structure is not made public by the API.
} virConnect;

Structure virConnectAuth

struct _virConnectAuth {
    int *	credtype	: List of supported virConnectCredentialType values
    unsigned int	ncredtype
    virConnectAuthCallbackPtr	cb	: Callback used to collect credentials
    void *	cbdata
} virConnectAuth;

Typedef virConnectAuthPtr

virConnectAuth * virConnectAuthPtr;

Enum virConnectBaselineCPUFlags

enum virConnectBaselineCPUFlags {
    VIR_CONNECT_BASELINE_CPU_EXPAND_FEATURES = 1 /* show all features */
};

Enum virConnectCloseReason

enum virConnectCloseReason {
    VIR_CONNECT_CLOSE_REASON_ERROR = 0 /* Misc I/O error */
    VIR_CONNECT_CLOSE_REASON_EOF = 1 /* End-of-file from server */
    VIR_CONNECT_CLOSE_REASON_KEEPALIVE = 2 /* Keepalive timer triggered */
    VIR_CONNECT_CLOSE_REASON_CLIENT = 3 /* Client requested it */
    VIR_CONNECT_CLOSE_REASON_LAST = 4
};

Enum virConnectCompareCPUFlags

enum virConnectCompareCPUFlags {
    VIR_CONNECT_COMPARE_CPU_FAIL_INCOMPATIBLE = 1 /* treat incompatible CPUs as failure */
};

Structure virConnectCredential

struct _virConnectCredential {
    int	type	: One of virConnectCredentialType constants
    const char *	prompt	: Prompt to show to user
    const char *	challenge	: Additional challenge to show
    const char *	defresult	: Optional default result
    char *	result	: Result to be filled with user response (or defresult)
    unsigned int	resultlen	: Length of the result
} virConnectCredential;

Typedef virConnectCredentialPtr

virConnectCredential * virConnectCredentialPtr;

Enum virConnectCredentialType

enum virConnectCredentialType {
    VIR_CRED_USERNAME = 1 /* Identity to act as */
    VIR_CRED_AUTHNAME = 2 /* Identify to authorize as */
    VIR_CRED_LANGUAGE = 3 /* RFC 1766 languages, comma separated */
    VIR_CRED_CNONCE = 4 /* client supplies a nonce */
    VIR_CRED_PASSPHRASE = 5 /* Passphrase secret */
    VIR_CRED_ECHOPROMPT = 6 /* Challenge response */
    VIR_CRED_NOECHOPROMPT = 7 /* Challenge response */
    VIR_CRED_REALM = 8 /* Authentication realm */
    VIR_CRED_EXTERNAL = 9 /* Externally managed credential */
    VIR_CRED_LAST = 10 /* More may be added - expect the unexpected */
};

Enum virConnectDomainEventBlockJobStatus

enum virConnectDomainEventBlockJobStatus {
    VIR_DOMAIN_BLOCK_JOB_COMPLETED = 0
    VIR_DOMAIN_BLOCK_JOB_FAILED = 1
    VIR_DOMAIN_BLOCK_JOB_CANCELED = 2
    VIR_DOMAIN_BLOCK_JOB_READY = 3
    VIR_DOMAIN_BLOCK_JOB_LAST = 4
};

Enum virConnectDomainEventDiskChangeReason

enum virConnectDomainEventDiskChangeReason {
    VIR_DOMAIN_EVENT_DISK_CHANGE_MISSING_ON_START = 0 /* oldSrcPath is set */
    VIR_DOMAIN_EVENT_DISK_DROP_MISSING_ON_START = 1
    VIR_DOMAIN_EVENT_DISK_CHANGE_LAST = 2
};

Enum virConnectFlags

enum virConnectFlags {
    VIR_CONNECT_RO = 1 /* A readonly connection */
    VIR_CONNECT_NO_ALIASES = 2 /* Don't try to resolve URI aliases */
};

Enum virConnectGetAllDomainStatsFlags

enum virConnectGetAllDomainStatsFlags {
    VIR_CONNECT_GET_ALL_DOMAINS_STATS_ACTIVE = VIR_CONNECT_LIST_DOMAINS_ACTIVE
    VIR_CONNECT_GET_ALL_DOMAINS_STATS_INACTIVE = VIR_CONNECT_LIST_DOMAINS_INACTIVE
    VIR_CONNECT_GET_ALL_DOMAINS_STATS_OTHER = VIR_CONNECT_LIST_DOMAINS_OTHER
    VIR_CONNECT_GET_ALL_DOMAINS_STATS_PAUSED = VIR_CONNECT_LIST_DOMAINS_PAUSED
    VIR_CONNECT_GET_ALL_DOMAINS_STATS_PERSISTENT = VIR_CONNECT_LIST_DOMAINS_PERSISTENT
    VIR_CONNECT_GET_ALL_DOMAINS_STATS_RUNNING = VIR_CONNECT_LIST_DOMAINS_RUNNING
    VIR_CONNECT_GET_ALL_DOMAINS_STATS_SHUTOFF = VIR_CONNECT_LIST_DOMAINS_SHUTOFF
    VIR_CONNECT_GET_ALL_DOMAINS_STATS_TRANSIENT = VIR_CONNECT_LIST_DOMAINS_TRANSIENT
    VIR_CONNECT_GET_ALL_DOMAINS_STATS_ENFORCE_STATS = 2147483648 /* enforce requested stats */
};

Enum virConnectListAllDomainsFlags

enum virConnectListAllDomainsFlags {
    VIR_CONNECT_LIST_DOMAINS_ACTIVE = 1
    VIR_CONNECT_LIST_DOMAINS_INACTIVE = 2
    VIR_CONNECT_LIST_DOMAINS_PERSISTENT = 4
    VIR_CONNECT_LIST_DOMAINS_TRANSIENT = 8
    VIR_CONNECT_LIST_DOMAINS_RUNNING = 16
    VIR_CONNECT_LIST_DOMAINS_PAUSED = 32
    VIR_CONNECT_LIST_DOMAINS_SHUTOFF = 64
    VIR_CONNECT_LIST_DOMAINS_OTHER = 128
    VIR_CONNECT_LIST_DOMAINS_MANAGEDSAVE = 256
    VIR_CONNECT_LIST_DOMAINS_NO_MANAGEDSAVE = 512
    VIR_CONNECT_LIST_DOMAINS_AUTOSTART = 1024
    VIR_CONNECT_LIST_DOMAINS_NO_AUTOSTART = 2048
    VIR_CONNECT_LIST_DOMAINS_HAS_SNAPSHOT = 4096
    VIR_CONNECT_LIST_DOMAINS_NO_SNAPSHOT = 8192
};

Enum virConnectListAllInterfacesFlags

enum virConnectListAllInterfacesFlags {
    VIR_CONNECT_LIST_INTERFACES_INACTIVE = 1
    VIR_CONNECT_LIST_INTERFACES_ACTIVE = 2
};

Enum virConnectListAllNetworksFlags

enum virConnectListAllNetworksFlags {
    VIR_CONNECT_LIST_NETWORKS_INACTIVE = 1
    VIR_CONNECT_LIST_NETWORKS_ACTIVE = 2
    VIR_CONNECT_LIST_NETWORKS_PERSISTENT = 4
    VIR_CONNECT_LIST_NETWORKS_TRANSIENT = 8
    VIR_CONNECT_LIST_NETWORKS_AUTOSTART = 16
    VIR_CONNECT_LIST_NETWORKS_NO_AUTOSTART = 32
};

Enum virConnectListAllNodeDeviceFlags

enum virConnectListAllNodeDeviceFlags {
    VIR_CONNECT_LIST_NODE_DEVICES_CAP_SYSTEM = 1 /* System capability */
    VIR_CONNECT_LIST_NODE_DEVICES_CAP_PCI_DEV = 2 /* PCI device */
    VIR_CONNECT_LIST_NODE_DEVICES_CAP_USB_DEV = 4 /* USB device */
    VIR_CONNECT_LIST_NODE_DEVICES_CAP_USB_INTERFACE = 8 /* USB interface */
    VIR_CONNECT_LIST_NODE_DEVICES_CAP_NET = 16 /* Network device */
    VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI_HOST = 32 /* SCSI Host Bus Adapter */
    VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI_TARGET = 64 /* SCSI Target */
    VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI = 128 /* SCSI device */
    VIR_CONNECT_LIST_NODE_DEVICES_CAP_STORAGE = 256 /* Storage device */
    VIR_CONNECT_LIST_NODE_DEVICES_CAP_FC_HOST = 512 /* FC Host Bus Adapter */
    VIR_CONNECT_LIST_NODE_DEVICES_CAP_VPORTS = 1024 /* Capable of vport */
    VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI_GENERIC = 2048 /* Capable of scsi_generic */
};

Enum virConnectListAllSecretsFlags

enum virConnectListAllSecretsFlags {
    VIR_CONNECT_LIST_SECRETS_EPHEMERAL = 1 /* kept in memory, never stored persistently */
    VIR_CONNECT_LIST_SECRETS_NO_EPHEMERAL = 2
    VIR_CONNECT_LIST_SECRETS_PRIVATE = 4 /* not revealed to any caller of libvirt, nor to any other node */
    VIR_CONNECT_LIST_SECRETS_NO_PRIVATE = 8
};

Enum virConnectListAllStoragePoolsFlags

enum virConnectListAllStoragePoolsFlags {
    VIR_CONNECT_LIST_STORAGE_POOLS_INACTIVE = 1
    VIR_CONNECT_LIST_STORAGE_POOLS_ACTIVE = 2
    VIR_CONNECT_LIST_STORAGE_POOLS_PERSISTENT = 4
    VIR_CONNECT_LIST_STORAGE_POOLS_TRANSIENT = 8
    VIR_CONNECT_LIST_STORAGE_POOLS_AUTOSTART = 16
    VIR_CONNECT_LIST_STORAGE_POOLS_NO_AUTOSTART = 32 /* List pools by type */
    VIR_CONNECT_LIST_STORAGE_POOLS_DIR = 64
    VIR_CONNECT_LIST_STORAGE_POOLS_FS = 128
    VIR_CONNECT_LIST_STORAGE_POOLS_NETFS = 256
    VIR_CONNECT_LIST_STORAGE_POOLS_LOGICAL = 512
    VIR_CONNECT_LIST_STORAGE_POOLS_DISK = 1024
    VIR_CONNECT_LIST_STORAGE_POOLS_ISCSI = 2048
    VIR_CONNECT_LIST_STORAGE_POOLS_SCSI = 4096
    VIR_CONNECT_LIST_STORAGE_POOLS_MPATH = 8192
    VIR_CONNECT_LIST_STORAGE_POOLS_RBD = 16384
    VIR_CONNECT_LIST_STORAGE_POOLS_SHEEPDOG = 32768
    VIR_CONNECT_LIST_STORAGE_POOLS_GLUSTER = 65536
    VIR_CONNECT_LIST_STORAGE_POOLS_ZFS = 131072
};

Typedef virConnectPtr

virConnect * virConnectPtr;

a virConnectPtr is pointer to a virConnect private structure, this is the type used to reference a connection to the Hypervisor in the API.

Structure virDomain

struct _virDomain {
The content of this structure is not made public by the API.
} virDomain;

Enum virDomainBlockCommitFlags

enum virDomainBlockCommitFlags {
    VIR_DOMAIN_BLOCK_COMMIT_SHALLOW = 1 /* NULL base means next backing file, not whole chain */
    VIR_DOMAIN_BLOCK_COMMIT_DELETE = 2 /* Delete any files that are now invalid after their contents have been committed */
    VIR_DOMAIN_BLOCK_COMMIT_ACTIVE = 4 /* Allow a two-phase commit when top is the active layer */
    VIR_DOMAIN_BLOCK_COMMIT_RELATIVE = 8 /* keep the backing chain referenced using relative names */
    VIR_DOMAIN_BLOCK_COMMIT_BANDWIDTH_BYTES = 16 /* bandwidth in bytes/s instead of MiB/s */
};

Enum virDomainBlockCopyFlags

enum virDomainBlockCopyFlags {
    VIR_DOMAIN_BLOCK_COPY_SHALLOW = 1 /* Limit copy to top of source backing chain */
    VIR_DOMAIN_BLOCK_COPY_REUSE_EXT = 2 /* Reuse existing external file for a copy */
};

Structure virDomainBlockInfo

struct _virDomainBlockInfo {
    unsigned long long	capacity	: logical size in bytes of the block device backing image
    unsigned long long	allocation	: highest allocated extent in bytes of the block device backing image
    unsigned long long	physical	: physical size in bytes of the container of the backing image
} virDomainBlockInfo;

Typedef virDomainBlockInfoPtr

virDomainBlockInfo * virDomainBlockInfoPtr;

Enum virDomainBlockJobAbortFlags

enum virDomainBlockJobAbortFlags {
    VIR_DOMAIN_BLOCK_JOB_ABORT_ASYNC = 1
    VIR_DOMAIN_BLOCK_JOB_ABORT_PIVOT = 2
};

Typedef virDomainBlockJobCursor

unsigned long long virDomainBlockJobCursor;

Structure virDomainBlockJobInfo

struct _virDomainBlockJobInfo {
    int	type	: virDomainBlockJobType
    unsigned long	bandwidth	: The following fields provide an indication of block job progress. @cu
    virDomainBlockJobCursor	cur
    virDomainBlockJobCursor	end
} virDomainBlockJobInfo;

Enum virDomainBlockJobInfoFlags

enum virDomainBlockJobInfoFlags {
    VIR_DOMAIN_BLOCK_JOB_INFO_BANDWIDTH_BYTES = 1 /* bandwidth in bytes/s instead of MiB/s */
};

Typedef virDomainBlockJobInfoPtr

virDomainBlockJobInfo * virDomainBlockJobInfoPtr;

Enum virDomainBlockJobSetSpeedFlags

enum virDomainBlockJobSetSpeedFlags {
    VIR_DOMAIN_BLOCK_JOB_SPEED_BANDWIDTH_BYTES = 1 /* bandwidth in bytes/s instead of MiB/s */
};

Enum virDomainBlockJobType

enum virDomainBlockJobType {
    VIR_DOMAIN_BLOCK_JOB_TYPE_UNKNOWN = 0 /* Placeholder */
    VIR_DOMAIN_BLOCK_JOB_TYPE_PULL = 1 /* Block Pull (virDomainBlockPull, or virDomainBlockRebase without  flags), job ends on completion */
    VIR_DOMAIN_BLOCK_JOB_TYPE_COPY = 2 /* Block Copy (virDomainBlockCopy, or virDomainBlockRebase with  flags), job exists as long as mirroring is active */
    VIR_DOMAIN_BLOCK_JOB_TYPE_COMMIT = 3 /* Block Commit (virDomainBlockCommit without flags), job ends on  completion */
    VIR_DOMAIN_BLOCK_JOB_TYPE_ACTIVE_COMMIT = 4 /* Active Block Commit (virDomainBlockCommit with flags), job  exists as long as sync is active */
    VIR_DOMAIN_BLOCK_JOB_TYPE_LAST = 5
};

Enum virDomainBlockPullFlags

enum virDomainBlockPullFlags {
    VIR_DOMAIN_BLOCK_PULL_BANDWIDTH_BYTES = 64 /* bandwidth in bytes/s instead of MiB/s */
};

Enum virDomainBlockRebaseFlags

enum virDomainBlockRebaseFlags {
    VIR_DOMAIN_BLOCK_REBASE_SHALLOW = 1 /* Limit copy to top of source backing chain */
    VIR_DOMAIN_BLOCK_REBASE_REUSE_EXT = 2 /* Reuse existing external file for a copy */
    VIR_DOMAIN_BLOCK_REBASE_COPY_RAW = 4 /* Make destination file raw */
    VIR_DOMAIN_BLOCK_REBASE_COPY = 8 /* Start a copy job */
    VIR_DOMAIN_BLOCK_REBASE_RELATIVE = 16 /* Keep backing chain referenced using relative names */
    VIR_DOMAIN_BLOCK_REBASE_COPY_DEV = 32 /* Treat destination as block device instead of file */
    VIR_DOMAIN_BLOCK_REBASE_BANDWIDTH_BYTES = 64 /* bandwidth in bytes/s instead of MiB/s */
};

Enum virDomainBlockResizeFlags

enum virDomainBlockResizeFlags {
    VIR_DOMAIN_BLOCK_RESIZE_BYTES = 1 /* size in bytes instead of KiB */
};

Typedef virDomainBlockStatsPtr

virDomainBlockStatsStruct * virDomainBlockStatsPtr;

A pointer to a virDomainBlockStats structure

Structure virDomainBlockStatsStruct

struct _virDomainBlockStats {
    long long	rd_req	: number of read requests
    long long	rd_bytes	: number of read bytes
    long long	wr_req	: number of write requests
    long long	wr_bytes	: number of written bytes
    long long	errs	: In Xen this returns the mysterious 'oo_req'.
} virDomainBlockStatsStruct;

Enum virDomainBlockedReason

enum virDomainBlockedReason {
    VIR_DOMAIN_BLOCKED_UNKNOWN = 0 /* the reason is unknown */
    VIR_DOMAIN_BLOCKED_LAST = 1
};

Enum virDomainChannelFlags

enum virDomainChannelFlags {
    VIR_DOMAIN_CHANNEL_FORCE = 1 /* abort a (possibly) active channel connection to force a new connection */
};

Enum virDomainConsoleFlags

enum virDomainConsoleFlags {
    VIR_DOMAIN_CONSOLE_FORCE = 1 /* abort a (possibly) active console connection to force a new connection */
    VIR_DOMAIN_CONSOLE_SAFE = 2 /* check if the console driver supports safe console operations */
};

Structure virDomainControlInfo

struct _virDomainControlInfo {
    unsigned int	state	: control state, one of virDomainControlState
    unsigned int	details	: state details, currently 0
    unsigned long long	stateTime	: for how long (in msec) control interface has been in current state (ex
} virDomainControlInfo;

Typedef virDomainControlInfoPtr

virDomainControlInfo * virDomainControlInfoPtr;

Pointer to virDomainControlInfo structure.

Enum virDomainControlState

enum virDomainControlState {
    VIR_DOMAIN_CONTROL_OK = 0 /* operational, ready to accept commands */
    VIR_DOMAIN_CONTROL_JOB = 1 /* background job is running (can be monitored by virDomainGetJobInfo); only limited set of commands may be allowed */
    VIR_DOMAIN_CONTROL_OCCUPIED = 2 /* occupied by a running command */
    VIR_DOMAIN_CONTROL_ERROR = 3 /* unusable, domain cannot be fully operated */
    VIR_DOMAIN_CONTROL_LAST = 4
};

Enum virDomainCoreDumpFlags

enum virDomainCoreDumpFlags {
    VIR_DUMP_CRASH = 1 /* crash after dump */
    VIR_DUMP_LIVE = 2 /* live dump */
    VIR_DUMP_BYPASS_CACHE = 4 /* avoid file system cache pollution */
    VIR_DUMP_RESET = 8 /* reset domain after dump finishes */
    VIR_DUMP_MEMORY_ONLY = 16 /* use dump-guest-memory */
};

Enum virDomainCoreDumpFormat

enum virDomainCoreDumpFormat {
    VIR_DOMAIN_CORE_DUMP_FORMAT_RAW = 0 /* dump guest memory in raw format */
    VIR_DOMAIN_CORE_DUMP_FORMAT_KDUMP_ZLIB = 1 /* kdump-compressed format, with  zlib compression */
    VIR_DOMAIN_CORE_DUMP_FORMAT_KDUMP_LZO = 2 /* kdump-compressed format, with  lzo compression */
    VIR_DOMAIN_CORE_DUMP_FORMAT_KDUMP_SNAPPY = 3 /* kdump-compressed format, with  snappy compression */
    VIR_DOMAIN_CORE_DUMP_FORMAT_LAST = 4 /* NB: this enum value will increase over time as new events are  added to the libvirt API. It reflects the last state supported  by this version of the libvirt API. */
};

Enum virDomainCrashedReason

enum virDomainCrashedReason {
    VIR_DOMAIN_CRASHED_UNKNOWN = 0 /* crashed for unknown reason */
    VIR_DOMAIN_CRASHED_PANICKED = 1 /* domain panicked */
    VIR_DOMAIN_CRASHED_LAST = 2
};

Enum virDomainCreateFlags

enum virDomainCreateFlags {
    VIR_DOMAIN_NONE = 0 /* Default behavior */
    VIR_DOMAIN_START_PAUSED = 1 /* Launch guest in paused state */
    VIR_DOMAIN_START_AUTODESTROY = 2 /* Automatically kill guest when virConnectPtr is closed */
    VIR_DOMAIN_START_BYPASS_CACHE = 4 /* Avoid file system cache pollution */
    VIR_DOMAIN_START_FORCE_BOOT = 8 /* Boot, discarding any managed save */
};

Enum virDomainDestroyFlagsValues

enum virDomainDestroyFlagsValues {
    VIR_DOMAIN_DESTROY_DEFAULT = 0 /* Default behavior - could lead to data loss!! */
    VIR_DOMAIN_DESTROY_GRACEFUL = 1 /* only SIGTERM, no SIGKILL */
};

Enum virDomainDeviceModifyFlags

enum virDomainDeviceModifyFlags {
    VIR_DOMAIN_DEVICE_MODIFY_CONFIG = VIR_DOMAIN_AFFECT_CONFIG /* Additionally, these flags may be bitwise-OR'd in. */
    VIR_DOMAIN_DEVICE_MODIFY_CURRENT = VIR_DOMAIN_AFFECT_CURRENT
    VIR_DOMAIN_DEVICE_MODIFY_LIVE = VIR_DOMAIN_AFFECT_LIVE
    VIR_DOMAIN_DEVICE_MODIFY_FORCE = 4 /* Forcibly modify device (ex. force eject a cdrom) */
};

Structure virDomainDiskError

struct _virDomainDiskError {
    char *	disk	: disk target
    int	error	: virDomainDiskErrorCode
} virDomainDiskError;

Enum virDomainDiskErrorCode

enum virDomainDiskErrorCode {
    VIR_DOMAIN_DISK_ERROR_NONE = 0 /* no error */
    VIR_DOMAIN_DISK_ERROR_UNSPEC = 1 /* unspecified I/O error */
    VIR_DOMAIN_DISK_ERROR_NO_SPACE = 2 /* no space left on the device */
    VIR_DOMAIN_DISK_ERROR_LAST = 3
};

Typedef virDomainDiskErrorPtr

virDomainDiskError * virDomainDiskErrorPtr;

Enum virDomainEventCrashedDetailType

enum virDomainEventCrashedDetailType {
    VIR_DOMAIN_EVENT_CRASHED_PANICKED = 0 /* Guest was panicked */
    VIR_DOMAIN_EVENT_CRASHED_LAST = 1
};

Enum virDomainEventDefinedDetailType

enum virDomainEventDefinedDetailType {
    VIR_DOMAIN_EVENT_DEFINED_ADDED = 0 /* Newly created config file */
    VIR_DOMAIN_EVENT_DEFINED_UPDATED = 1 /* Changed config file */
    VIR_DOMAIN_EVENT_DEFINED_LAST = 2
};

Structure virDomainEventGraphicsAddress

struct _virDomainEventGraphicsAddress {
    int	family	: Address family, virDomainEventGraphicsAddressType
    char *	node	: Address of node (eg IP address, or UNIX path)
    char *	service	: Service name/number (eg TCP port, or NULL)
} virDomainEventGraphicsAddress;

Typedef virDomainEventGraphicsAddressPtr

virDomainEventGraphicsAddress * virDomainEventGraphicsAddressPtr;

Enum virDomainEventGraphicsAddressType

enum virDomainEventGraphicsAddressType {
    VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_IPV4 = 0 /* IPv4 address */
    VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_IPV6 = 1 /* IPv6 address */
    VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_UNIX = 2 /* UNIX socket path */
    VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_LAST = 3
};

Enum virDomainEventGraphicsPhase

enum virDomainEventGraphicsPhase {
    VIR_DOMAIN_EVENT_GRAPHICS_CONNECT = 0 /* Initial socket connection established */
    VIR_DOMAIN_EVENT_GRAPHICS_INITIALIZE = 1 /* Authentication & setup completed */
    VIR_DOMAIN_EVENT_GRAPHICS_DISCONNECT = 2 /* Final socket disconnection */
    VIR_DOMAIN_EVENT_GRAPHICS_LAST = 3
};

Structure virDomainEventGraphicsSubject

struct _virDomainEventGraphicsSubject {
    int	nidentity	: Number of identities in arra
    virDomainEventGraphicsSubjectIdentityPtr	identities	: Array of identities for subject
} virDomainEventGraphicsSubject;

Structure virDomainEventGraphicsSubjectIdentity

struct _virDomainEventGraphicsSubjectIdentity {
    char *	type	: Type of identity
    char *	name	: Identity value
} virDomainEventGraphicsSubjectIdentity;

Typedef virDomainEventGraphicsSubjectIdentityPtr

virDomainEventGraphicsSubjectIdentity * virDomainEventGraphicsSubjectIdentityPtr;

Typedef virDomainEventGraphicsSubjectPtr

virDomainEventGraphicsSubject * virDomainEventGraphicsSubjectPtr;

Enum virDomainEventID

enum virDomainEventID {
    VIR_DOMAIN_EVENT_ID_LIFECYCLE = 0 /* virConnectDomainEventCallback */
    VIR_DOMAIN_EVENT_ID_REBOOT = 1 /* virConnectDomainEventGenericCallback */
    VIR_DOMAIN_EVENT_ID_RTC_CHANGE = 2 /* virConnectDomainEventRTCChangeCallback */
    VIR_DOMAIN_EVENT_ID_WATCHDOG = 3 /* virConnectDomainEventWatchdogCallback */
    VIR_DOMAIN_EVENT_ID_IO_ERROR = 4 /* virConnectDomainEventIOErrorCallback */
    VIR_DOMAIN_EVENT_ID_GRAPHICS = 5 /* virConnectDomainEventGraphicsCallback */
    VIR_DOMAIN_EVENT_ID_IO_ERROR_REASON = 6 /* virConnectDomainEventIOErrorReasonCallback */
    VIR_DOMAIN_EVENT_ID_CONTROL_ERROR = 7 /* virConnectDomainEventGenericCallback */
    VIR_DOMAIN_EVENT_ID_BLOCK_JOB = 8 /* virConnectDomainEventBlockJobCallback */
    VIR_DOMAIN_EVENT_ID_DISK_CHANGE = 9 /* virConnectDomainEventDiskChangeCallback */
    VIR_DOMAIN_EVENT_ID_TRAY_CHANGE = 10 /* virConnectDomainEventTrayChangeCallback */
    VIR_DOMAIN_EVENT_ID_PMWAKEUP = 11 /* virConnectDomainEventPMWakeupCallback */
    VIR_DOMAIN_EVENT_ID_PMSUSPEND = 12 /* virConnectDomainEventPMSuspendCallback */
    VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE = 13 /* virConnectDomainEventBalloonChangeCallback */
    VIR_DOMAIN_EVENT_ID_PMSUSPEND_DISK = 14 /* virConnectDomainEventPMSuspendDiskCallback */
    VIR_DOMAIN_EVENT_ID_DEVICE_REMOVED = 15 /* virConnectDomainEventDeviceRemovedCallback */
    VIR_DOMAIN_EVENT_ID_BLOCK_JOB_2 = 16 /* virConnectDomainEventBlockJobCallback */
    VIR_DOMAIN_EVENT_ID_TUNABLE = 17 /* virConnectDomainEventTunableCallback */
    VIR_DOMAIN_EVENT_ID_LAST = 18 /* NB: this enum value will increase over time as new events are  added to the libvirt API. It reflects the last event ID supported  by this version of the libvirt API. */
};

Enum virDomainEventIOErrorAction

enum virDomainEventIOErrorAction {
    VIR_DOMAIN_EVENT_IO_ERROR_NONE = 0 /* No action, IO error ignored */
    VIR_DOMAIN_EVENT_IO_ERROR_PAUSE = 1 /* Guest CPUs are paused */
    VIR_DOMAIN_EVENT_IO_ERROR_REPORT = 2 /* IO error reported to guest OS */
    VIR_DOMAIN_EVENT_IO_ERROR_LAST = 3
};

Enum virDomainEventPMSuspendedDetailType

enum virDomainEventPMSuspendedDetailType {
    VIR_DOMAIN_EVENT_PMSUSPENDED_MEMORY = 0 /* Guest was PM suspended to memory */
    VIR_DOMAIN_EVENT_PMSUSPENDED_DISK = 1 /* Guest was PM suspended to disk */
    VIR_DOMAIN_EVENT_PMSUSPENDED_LAST = 2
};

Enum virDomainEventResumedDetailType

enum virDomainEventResumedDetailType {
    VIR_DOMAIN_EVENT_RESUMED_UNPAUSED = 0 /* Normal resume due to admin unpause */
    VIR_DOMAIN_EVENT_RESUMED_MIGRATED = 1 /* Resumed for completion of migration */
    VIR_DOMAIN_EVENT_RESUMED_FROM_SNAPSHOT = 2 /* Resumed from snapshot */
    VIR_DOMAIN_EVENT_RESUMED_LAST = 3
};

Enum virDomainEventShutdownDetailType

enum virDomainEventShutdownDetailType {
    VIR_DOMAIN_EVENT_SHUTDOWN_FINISHED = 0 /* Guest finished shutdown sequence */
    VIR_DOMAIN_EVENT_SHUTDOWN_LAST = 1
};

Enum virDomainEventStartedDetailType

enum virDomainEventStartedDetailType {
    VIR_DOMAIN_EVENT_STARTED_BOOTED = 0 /* Normal startup from boot */
    VIR_DOMAIN_EVENT_STARTED_MIGRATED = 1 /* Incoming migration from another host */
    VIR_DOMAIN_EVENT_STARTED_RESTORED = 2 /* Restored from a state file */
    VIR_DOMAIN_EVENT_STARTED_FROM_SNAPSHOT = 3 /* Restored from snapshot */
    VIR_DOMAIN_EVENT_STARTED_WAKEUP = 4 /* Started due to wakeup event */
    VIR_DOMAIN_EVENT_STARTED_LAST = 5
};

Enum virDomainEventStoppedDetailType

enum virDomainEventStoppedDetailType {
    VIR_DOMAIN_EVENT_STOPPED_SHUTDOWN = 0 /* Normal shutdown */
    VIR_DOMAIN_EVENT_STOPPED_DESTROYED = 1 /* Forced poweroff from host */
    VIR_DOMAIN_EVENT_STOPPED_CRASHED = 2 /* Guest crashed */
    VIR_DOMAIN_EVENT_STOPPED_MIGRATED = 3 /* Migrated off to another host */
    VIR_DOMAIN_EVENT_STOPPED_SAVED = 4 /* Saved to a state file */
    VIR_DOMAIN_EVENT_STOPPED_FAILED = 5 /* Host emulator/mgmt failed */
    VIR_DOMAIN_EVENT_STOPPED_FROM_SNAPSHOT = 6 /* offline snapshot loaded */
    VIR_DOMAIN_EVENT_STOPPED_LAST = 7
};

Enum virDomainEventSuspendedDetailType

enum virDomainEventSuspendedDetailType {
    VIR_DOMAIN_EVENT_SUSPENDED_PAUSED = 0 /* Normal suspend due to admin pause */
    VIR_DOMAIN_EVENT_SUSPENDED_MIGRATED = 1 /* Suspended for offline migration */
    VIR_DOMAIN_EVENT_SUSPENDED_IOERROR = 2 /* Suspended due to a disk I/O error */
    VIR_DOMAIN_EVENT_SUSPENDED_WATCHDOG = 3 /* Suspended due to a watchdog firing */
    VIR_DOMAIN_EVENT_SUSPENDED_RESTORED = 4 /* Restored from paused state file */
    VIR_DOMAIN_EVENT_SUSPENDED_FROM_SNAPSHOT = 5 /* Restored from paused snapshot */
    VIR_DOMAIN_EVENT_SUSPENDED_API_ERROR = 6 /* suspended after failure during libvirt API call */
    VIR_DOMAIN_EVENT_SUSPENDED_LAST = 7
};

Enum virDomainEventTrayChangeReason

enum virDomainEventTrayChangeReason {
    VIR_DOMAIN_EVENT_TRAY_CHANGE_OPEN = 0
    VIR_DOMAIN_EVENT_TRAY_CHANGE_CLOSE = 1
    VIR_DOMAIN_EVENT_TRAY_CHANGE_LAST = 2
};

Enum virDomainEventType

enum virDomainEventType {
    VIR_DOMAIN_EVENT_DEFINED = 0
    VIR_DOMAIN_EVENT_UNDEFINED = 1
    VIR_DOMAIN_EVENT_STARTED = 2
    VIR_DOMAIN_EVENT_SUSPENDED = 3
    VIR_DOMAIN_EVENT_RESUMED = 4
    VIR_DOMAIN_EVENT_STOPPED = 5
    VIR_DOMAIN_EVENT_SHUTDOWN = 6
    VIR_DOMAIN_EVENT_PMSUSPENDED = 7
    VIR_DOMAIN_EVENT_CRASHED = 8
    VIR_DOMAIN_EVENT_LAST = 9
};

Enum virDomainEventUndefinedDetailType

enum virDomainEventUndefinedDetailType {
    VIR_DOMAIN_EVENT_UNDEFINED_REMOVED = 0 /* Deleted the config file */
    VIR_DOMAIN_EVENT_UNDEFINED_LAST = 1
};

Enum virDomainEventWatchdogAction

enum virDomainEventWatchdogAction {
    VIR_DOMAIN_EVENT_WATCHDOG_NONE = 0 /* No action, watchdog ignored */
    VIR_DOMAIN_EVENT_WATCHDOG_PAUSE = 1 /* Guest CPUs are paused */
    VIR_DOMAIN_EVENT_WATCHDOG_RESET = 2 /* Guest CPUs are reset */
    VIR_DOMAIN_EVENT_WATCHDOG_POWEROFF = 3 /* Guest is forcibly powered off */
    VIR_DOMAIN_EVENT_WATCHDOG_SHUTDOWN = 4 /* Guest is requested to gracefully shutdown */
    VIR_DOMAIN_EVENT_WATCHDOG_DEBUG = 5 /* No action, a debug message logged */
    VIR_DOMAIN_EVENT_WATCHDOG_LAST = 6
};

Enum virDomainGetJobStatsFlags

enum virDomainGetJobStatsFlags {
    VIR_DOMAIN_JOB_STATS_COMPLETED = 1 /* return stats of a recently  completed job */
};

Structure virDomainInfo

struct _virDomainInfo {
    unsigned char	state	: the running state, one of virDomainState
    unsigned long	maxMem	: the maximum memory in KBytes allowed
    unsigned long	memory	: the memory in KBytes used by the domain
    unsigned short	nrVirtCpu	: the number of virtual CPUs for the domain
    unsigned long long	cpuTime	: the CPU time used in nanoseconds
} virDomainInfo;

Typedef virDomainInfoPtr

virDomainInfo * virDomainInfoPtr;

a virDomainInfoPtr is a pointer to a virDomainInfo structure.

Typedef virDomainInterfaceStatsPtr

virDomainInterfaceStatsStruct * virDomainInterfaceStatsPtr;

A pointer to a virDomainInterfaceStats structure

Structure virDomainInterfaceStatsStruct

struct _virDomainInterfaceStats {
    long long	rx_bytes
    long long	rx_packets
    long long	rx_errs
    long long	rx_drop
    long long	tx_bytes
    long long	tx_packets
    long long	tx_errs
    long long	tx_drop
} virDomainInterfaceStatsStruct;

Structure virDomainJobInfo

struct _virDomainJobInfo {
    int	type	: Time is measured in milliseconds
    unsigned long long	timeElapsed	: Always set
    unsigned long long	timeRemaining	: Only for VIR_DOMAIN_JOB_BOUNDED Data is measured in bytes unless other
    unsigned long long	dataTotal
    unsigned long long	dataProcessed
    unsigned long long	dataRemaining	: As above, but only tracking guest memory progress
    unsigned long long	memTotal
    unsigned long long	memProcessed
    unsigned long long	memRemaining	: As above, but only tracking guest disk file progress
    unsigned long long	fileTotal
    unsigned long long	fileProcessed
    unsigned long long	fileRemaining
} virDomainJobInfo;

Typedef virDomainJobInfoPtr

virDomainJobInfo * virDomainJobInfoPtr;

Enum virDomainJobType

enum virDomainJobType {
    VIR_DOMAIN_JOB_NONE = 0 /* No job is active */
    VIR_DOMAIN_JOB_BOUNDED = 1 /* Job with a finite completion time */
    VIR_DOMAIN_JOB_UNBOUNDED = 2 /* Job without a finite completion time */
    VIR_DOMAIN_JOB_COMPLETED = 3 /* Job has finished, but isn't cleaned up */
    VIR_DOMAIN_JOB_FAILED = 4 /* Job hit error, but isn't cleaned up */
    VIR_DOMAIN_JOB_CANCELLED = 5 /* Job was aborted, but isn't cleaned up */
    VIR_DOMAIN_JOB_LAST = 6
};

Enum virDomainMemoryFlags

enum virDomainMemoryFlags {
    VIR_MEMORY_VIRTUAL = 1 /* addresses are virtual addresses */
    VIR_MEMORY_PHYSICAL = 2 /* addresses are physical addresses */
};

Enum virDomainMemoryModFlags

enum virDomainMemoryModFlags {
    VIR_DOMAIN_MEM_CONFIG = VIR_DOMAIN_AFFECT_CONFIG /* Additionally, these flags may be bitwise-OR'd in. */
    VIR_DOMAIN_MEM_CURRENT = VIR_DOMAIN_AFFECT_CURRENT
    VIR_DOMAIN_MEM_LIVE = VIR_DOMAIN_AFFECT_LIVE
    VIR_DOMAIN_MEM_MAXIMUM = 4 /* affect Max rather than current */
};

Typedef virDomainMemoryStatPtr

virDomainMemoryStatStruct * virDomainMemoryStatPtr;

Structure virDomainMemoryStatStruct

struct _virDomainMemoryStat {
    int	tag
    unsigned long long	val
} virDomainMemoryStatStruct;

Enum virDomainMemoryStatTags

enum virDomainMemoryStatTags {
    VIR_DOMAIN_MEMORY_STAT_LAST = VIR_DOMAIN_MEMORY_STAT_NR
    VIR_DOMAIN_MEMORY_STAT_SWAP_IN = 0 /* The total amount of memory written out to swap space (in kB). */
    VIR_DOMAIN_MEMORY_STAT_SWAP_OUT = 1 /* Page faults occur when a process makes a valid access to virtual memory  that is not available.  When servicing the page fault, if disk IO is  required, it is considered a major fault.  If not, it is a minor fault.  These are expressed as the number of faults that have occurred. */
    VIR_DOMAIN_MEMORY_STAT_MAJOR_FAULT = 2
    VIR_DOMAIN_MEMORY_STAT_MINOR_FAULT = 3 /* The amount of memory left completely unused by the system.  Memory that  is available but used for reclaimable caches should NOT be reported as  free.  This value is expressed in kB. */
    VIR_DOMAIN_MEMORY_STAT_UNUSED = 4 /* The total amount of usable memory as seen by the domain.  This value  may be less than the amount of memory assigned to the domain if a  balloon driver is in use or if the guest OS does not initialize all  assigned pages.  This value is expressed in kB. */
    VIR_DOMAIN_MEMORY_STAT_AVAILABLE = 5 /* Current balloon value (in KB). */
    VIR_DOMAIN_MEMORY_STAT_ACTUAL_BALLOON = 6 /* Resident Set Size of the process running the domain. This value  is in kB */
    VIR_DOMAIN_MEMORY_STAT_RSS = 7 /* The number of statistics supported by this version of the interface.  To add new statistics, add them to the enum and increase this value. */
    VIR_DOMAIN_MEMORY_STAT_NR = 8
};

Enum virDomainMetadataType

enum virDomainMetadataType {
    VIR_DOMAIN_METADATA_DESCRIPTION = 0 /* Operate on <description> */
    VIR_DOMAIN_METADATA_TITLE = 1 /* Operate on <title> */
    VIR_DOMAIN_METADATA_ELEMENT = 2 /* Operate on <metadata> */
    VIR_DOMAIN_METADATA_LAST = 3
};

Enum virDomainMigrateFlags

enum virDomainMigrateFlags {
    VIR_MIGRATE_LIVE = 1 /* live migration */
    VIR_MIGRATE_PEER2PEER = 2 /* direct source -> dest host control channel Note the less-common spelling that we're stuck with: VIR_MIGRATE_TUNNELLED should be VIR_MIGRATE_TUNNELED */
    VIR_MIGRATE_TUNNELLED = 4 /* tunnel migration data over libvirtd connection */
    VIR_MIGRATE_PERSIST_DEST = 8 /* persist the VM on the destination */
    VIR_MIGRATE_UNDEFINE_SOURCE = 16 /* undefine the VM on the source */
    VIR_MIGRATE_PAUSED = 32 /* pause on remote side */
    VIR_MIGRATE_NON_SHARED_DISK = 64 /* migration with non-shared storage with full disk copy */
    VIR_MIGRATE_NON_SHARED_INC = 128 /* migration with non-shared storage with incremental copy (same base image shared between source and destination) */
    VIR_MIGRATE_CHANGE_PROTECTION = 256 /* protect for changing domain configuration through the  whole migration process; this will be used automatically  when supported */
    VIR_MIGRATE_UNSAFE = 512 /* force migration even if it is considered unsafe */
    VIR_MIGRATE_OFFLINE = 1024 /* offline migrate */
    VIR_MIGRATE_COMPRESSED = 2048 /* compress data during migration */
    VIR_MIGRATE_ABORT_ON_ERROR = 4096 /* abort migration on I/O errors happened during migration */
    VIR_MIGRATE_AUTO_CONVERGE = 8192 /* force convergence */
    VIR_MIGRATE_RDMA_PIN_ALL = 16384 /* RDMA memory pinning */
};

Enum virDomainModificationImpact

enum virDomainModificationImpact {
    VIR_DOMAIN_AFFECT_CURRENT = 0 /* Affect current domain state. */
    VIR_DOMAIN_AFFECT_LIVE = 1 /* Affect running domain state. */
    VIR_DOMAIN_AFFECT_CONFIG = 2 /* Affect persistent domain state.  1 << 2 is reserved for virTypedParameterFlags */
};

Enum virDomainNostateReason

enum virDomainNostateReason {
    VIR_DOMAIN_NOSTATE_UNKNOWN = 0
    VIR_DOMAIN_NOSTATE_LAST = 1
};

Enum virDomainNumatuneMemMode

enum virDomainNumatuneMemMode {
    VIR_DOMAIN_NUMATUNE_MEM_STRICT = 0
    VIR_DOMAIN_NUMATUNE_MEM_PREFERRED = 1
    VIR_DOMAIN_NUMATUNE_MEM_INTERLEAVE = 2
    VIR_DOMAIN_NUMATUNE_MEM_LAST = 3 /* This constant is subject to change */
};

Enum virDomainOpenGraphicsFlags

enum virDomainOpenGraphicsFlags {
    VIR_DOMAIN_OPEN_GRAPHICS_SKIPAUTH = 1
};

Enum virDomainPMSuspendedDiskReason

enum virDomainPMSuspendedDiskReason {
    VIR_DOMAIN_PMSUSPENDED_DISK_UNKNOWN = 0
    VIR_DOMAIN_PMSUSPENDED_DISK_LAST = 1
};

Enum virDomainPMSuspendedReason

enum virDomainPMSuspendedReason {
    VIR_DOMAIN_PMSUSPENDED_UNKNOWN = 0
    VIR_DOMAIN_PMSUSPENDED_LAST = 1
};

Enum virDomainPausedReason

enum virDomainPausedReason {
    VIR_DOMAIN_PAUSED_UNKNOWN = 0 /* the reason is unknown */
    VIR_DOMAIN_PAUSED_USER = 1 /* paused on user request */
    VIR_DOMAIN_PAUSED_MIGRATION = 2 /* paused for offline migration */
    VIR_DOMAIN_PAUSED_SAVE = 3 /* paused for save */
    VIR_DOMAIN_PAUSED_DUMP = 4 /* paused for offline core dump */
    VIR_DOMAIN_PAUSED_IOERROR = 5 /* paused due to a disk I/O error */
    VIR_DOMAIN_PAUSED_WATCHDOG = 6 /* paused due to a watchdog event */
    VIR_DOMAIN_PAUSED_FROM_SNAPSHOT = 7 /* paused after restoring from snapshot */
    VIR_DOMAIN_PAUSED_SHUTTING_DOWN = 8 /* paused during shutdown process */
    VIR_DOMAIN_PAUSED_SNAPSHOT = 9 /* paused while creating a snapshot */
    VIR_DOMAIN_PAUSED_CRASHED = 10 /* paused due to a guest crash */
    VIR_DOMAIN_PAUSED_LAST = 11
};

Enum virDomainProcessSignal

enum virDomainProcessSignal {
    VIR_DOMAIN_PROCESS_SIGNAL_NOP = 0 /* No constant in POSIX/Linux */
    VIR_DOMAIN_PROCESS_SIGNAL_HUP = 1 /* SIGHUP */
    VIR_DOMAIN_PROCESS_SIGNAL_INT = 2 /* SIGINT */
    VIR_DOMAIN_PROCESS_SIGNAL_QUIT = 3 /* SIGQUIT */
    VIR_DOMAIN_PROCESS_SIGNAL_ILL = 4 /* SIGILL */
    VIR_DOMAIN_PROCESS_SIGNAL_TRAP = 5 /* SIGTRAP */
    VIR_DOMAIN_PROCESS_SIGNAL_ABRT = 6 /* SIGABRT */
    VIR_DOMAIN_PROCESS_SIGNAL_BUS = 7 /* SIGBUS */
    VIR_DOMAIN_PROCESS_SIGNAL_FPE = 8 /* SIGFPE */
    VIR_DOMAIN_PROCESS_SIGNAL_KILL = 9 /* SIGKILL */
    VIR_DOMAIN_PROCESS_SIGNAL_USR1 = 10 /* SIGUSR1 */
    VIR_DOMAIN_PROCESS_SIGNAL_SEGV = 11 /* SIGSEGV */
    VIR_DOMAIN_PROCESS_SIGNAL_USR2 = 12 /* SIGUSR2 */
    VIR_DOMAIN_PROCESS_SIGNAL_PIPE = 13 /* SIGPIPE */
    VIR_DOMAIN_PROCESS_SIGNAL_ALRM = 14 /* SIGALRM */
    VIR_DOMAIN_PROCESS_SIGNAL_TERM = 15 /* SIGTERM */
    VIR_DOMAIN_PROCESS_SIGNAL_STKFLT = 16 /* Not in POSIX (SIGSTKFLT on Linux */
    VIR_DOMAIN_PROCESS_SIGNAL_CHLD = 17 /* SIGCHLD */
    VIR_DOMAIN_PROCESS_SIGNAL_CONT = 18 /* SIGCONT */
    VIR_DOMAIN_PROCESS_SIGNAL_STOP = 19 /* SIGSTOP */
    VIR_DOMAIN_PROCESS_SIGNAL_TSTP = 20 /* SIGTSTP */
    VIR_DOMAIN_PROCESS_SIGNAL_TTIN = 21 /* SIGTTIN */
    VIR_DOMAIN_PROCESS_SIGNAL_TTOU = 22 /* SIGTTOU */
    VIR_DOMAIN_PROCESS_SIGNAL_URG = 23 /* SIGURG */
    VIR_DOMAIN_PROCESS_SIGNAL_XCPU = 24 /* SIGXCPU */
    VIR_DOMAIN_PROCESS_SIGNAL_XFSZ = 25 /* SIGXFSZ */
    VIR_DOMAIN_PROCESS_SIGNAL_VTALRM = 26 /* SIGVTALRM */
    VIR_DOMAIN_PROCESS_SIGNAL_PROF = 27 /* SIGPROF */
    VIR_DOMAIN_PROCESS_SIGNAL_WINCH = 28 /* Not in POSIX (SIGWINCH on Linux) */
    VIR_DOMAIN_PROCESS_SIGNAL_POLL = 29 /* SIGPOLL (also known as SIGIO on Linux) */
    VIR_DOMAIN_PROCESS_SIGNAL_PWR = 30 /* Not in POSIX (SIGPWR on Linux) */
    VIR_DOMAIN_PROCESS_SIGNAL_SYS = 31 /* SIGSYS (also known as SIGUNUSED on Linux) */
    VIR_DOMAIN_PROCESS_SIGNAL_RT0 = 32 /* SIGRTMIN */
    VIR_DOMAIN_PROCESS_SIGNAL_RT1 = 33 /* SIGRTMIN + 1 */
    VIR_DOMAIN_PROCESS_SIGNAL_RT2 = 34 /* SIGRTMIN + 2 */
    VIR_DOMAIN_PROCESS_SIGNAL_RT3 = 35 /* SIGRTMIN + 3 */
    VIR_DOMAIN_PROCESS_SIGNAL_RT4 = 36 /* SIGRTMIN + 4 */
    VIR_DOMAIN_PROCESS_SIGNAL_RT5 = 37 /* SIGRTMIN + 5 */
    VIR_DOMAIN_PROCESS_SIGNAL_RT6 = 38 /* SIGRTMIN + 6 */
    VIR_DOMAIN_PROCESS_SIGNAL_RT7 = 39 /* SIGRTMIN + 7 */
    VIR_DOMAIN_PROCESS_SIGNAL_RT8 = 40 /* SIGRTMIN + 8 */
    VIR_DOMAIN_PROCESS_SIGNAL_RT9 = 41 /* SIGRTMIN + 9 */
    VIR_DOMAIN_PROCESS_SIGNAL_RT10 = 42 /* SIGRTMIN + 10 */
    VIR_DOMAIN_PROCESS_SIGNAL_RT11 = 43 /* SIGRTMIN + 11 */
    VIR_DOMAIN_PROCESS_SIGNAL_RT12 = 44 /* SIGRTMIN + 12 */
    VIR_DOMAIN_PROCESS_SIGNAL_RT13 = 45 /* SIGRTMIN + 13 */
    VIR_DOMAIN_PROCESS_SIGNAL_RT14 = 46 /* SIGRTMIN + 14 */
    VIR_DOMAIN_PROCESS_SIGNAL_RT15 = 47 /* SIGRTMIN + 15 */
    VIR_DOMAIN_PROCESS_SIGNAL_RT16 = 48 /* SIGRTMIN + 16 */
    VIR_DOMAIN_PROCESS_SIGNAL_RT17 = 49 /* SIGRTMIN + 17 */
    VIR_DOMAIN_PROCESS_SIGNAL_RT18 = 50 /* SIGRTMIN + 18 */
    VIR_DOMAIN_PROCESS_SIGNAL_RT19 = 51 /* SIGRTMIN + 19 */
    VIR_DOMAIN_PROCESS_SIGNAL_RT20 = 52 /* SIGRTMIN + 20 */
    VIR_DOMAIN_PROCESS_SIGNAL_RT21 = 53 /* SIGRTMIN + 21 */
    VIR_DOMAIN_PROCESS_SIGNAL_RT22 = 54 /* SIGRTMIN + 22 */
    VIR_DOMAIN_PROCESS_SIGNAL_RT23 = 55 /* SIGRTMIN + 23 */
    VIR_DOMAIN_PROCESS_SIGNAL_RT24 = 56 /* SIGRTMIN + 24 */
    VIR_DOMAIN_PROCESS_SIGNAL_RT25 = 57 /* SIGRTMIN + 25 */
    VIR_DOMAIN_PROCESS_SIGNAL_RT26 = 58 /* SIGRTMIN + 26 */
    VIR_DOMAIN_PROCESS_SIGNAL_RT27 = 59 /* SIGRTMIN + 27 */
    VIR_DOMAIN_PROCESS_SIGNAL_RT28 = 60 /* SIGRTMIN + 28 */
    VIR_DOMAIN_PROCESS_SIGNAL_RT29 = 61 /* SIGRTMIN + 29 */
    VIR_DOMAIN_PROCESS_SIGNAL_RT30 = 62 /* SIGRTMIN + 30 */
    VIR_DOMAIN_PROCESS_SIGNAL_RT31 = 63 /* SIGRTMIN + 31 */
    VIR_DOMAIN_PROCESS_SIGNAL_RT32 = 64 /* SIGRTMIN + 32 / SIGRTMAX */
    VIR_DOMAIN_PROCESS_SIGNAL_LAST = 65
};

Typedef virDomainPtr

virDomain * virDomainPtr;

a virDomainPtr is pointer to a virDomain private structure, this is the type used to reference a domain in the API.

Enum virDomainRebootFlagValues

enum virDomainRebootFlagValues {
    VIR_DOMAIN_REBOOT_DEFAULT = 0 /* hypervisor choice */
    VIR_DOMAIN_REBOOT_ACPI_POWER_BTN = 1 /* Send ACPI event */
    VIR_DOMAIN_REBOOT_GUEST_AGENT = 2 /* Use guest agent */
    VIR_DOMAIN_REBOOT_INITCTL = 4 /* Use initctl */
    VIR_DOMAIN_REBOOT_SIGNAL = 8 /* Send a signal */
    VIR_DOMAIN_REBOOT_PARAVIRT = 16 /* Use paravirt guest control */
};

Enum virDomainRunningReason

enum virDomainRunningReason {
    VIR_DOMAIN_RUNNING_UNKNOWN = 0
    VIR_DOMAIN_RUNNING_BOOTED = 1 /* normal startup from boot */
    VIR_DOMAIN_RUNNING_MIGRATED = 2 /* migrated from another host */
    VIR_DOMAIN_RUNNING_RESTORED = 3 /* restored from a state file */
    VIR_DOMAIN_RUNNING_FROM_SNAPSHOT = 4 /* restored from snapshot */
    VIR_DOMAIN_RUNNING_UNPAUSED = 5 /* returned from paused state */
    VIR_DOMAIN_RUNNING_MIGRATION_CANCELED = 6 /* returned from migration */
    VIR_DOMAIN_RUNNING_SAVE_CANCELED = 7 /* returned from failed save process */
    VIR_DOMAIN_RUNNING_WAKEUP = 8 /* returned from pmsuspended due to wakeup event */
    VIR_DOMAIN_RUNNING_CRASHED = 9 /* resumed from crashed */
    VIR_DOMAIN_RUNNING_LAST = 10
};

Enum virDomainSaveRestoreFlags

enum virDomainSaveRestoreFlags {
    VIR_DOMAIN_SAVE_BYPASS_CACHE = 1 /* Avoid file system cache pollution */
    VIR_DOMAIN_SAVE_RUNNING = 2 /* Favor running over paused */
    VIR_DOMAIN_SAVE_PAUSED = 4 /* Favor paused over running */
};

Enum virDomainSetTimeFlags

enum virDomainSetTimeFlags {
    VIR_DOMAIN_TIME_SYNC = 1 /* Re-sync domain time from domain's RTC */
};

Enum virDomainShutdownFlagValues

enum virDomainShutdownFlagValues {
    VIR_DOMAIN_SHUTDOWN_DEFAULT = 0 /* hypervisor choice */
    VIR_DOMAIN_SHUTDOWN_ACPI_POWER_BTN = 1 /* Send ACPI event */
    VIR_DOMAIN_SHUTDOWN_GUEST_AGENT = 2 /* Use guest agent */
    VIR_DOMAIN_SHUTDOWN_INITCTL = 4 /* Use initctl */
    VIR_DOMAIN_SHUTDOWN_SIGNAL = 8 /* Send a signal */
    VIR_DOMAIN_SHUTDOWN_PARAVIRT = 16 /* Use paravirt guest control */
};

Enum virDomainShutdownReason

enum virDomainShutdownReason {
    VIR_DOMAIN_SHUTDOWN_UNKNOWN = 0 /* the reason is unknown */
    VIR_DOMAIN_SHUTDOWN_USER = 1 /* shutting down on user request */
    VIR_DOMAIN_SHUTDOWN_LAST = 2
};

Enum virDomainShutoffReason

enum virDomainShutoffReason {
    VIR_DOMAIN_SHUTOFF_UNKNOWN = 0 /* the reason is unknown */
    VIR_DOMAIN_SHUTOFF_SHUTDOWN = 1 /* normal shutdown */
    VIR_DOMAIN_SHUTOFF_DESTROYED = 2 /* forced poweroff */
    VIR_DOMAIN_SHUTOFF_CRASHED = 3 /* domain crashed */
    VIR_DOMAIN_SHUTOFF_MIGRATED = 4 /* migrated to another host */
    VIR_DOMAIN_SHUTOFF_SAVED = 5 /* saved to a file */
    VIR_DOMAIN_SHUTOFF_FAILED = 6 /* domain failed to start */
    VIR_DOMAIN_SHUTOFF_FROM_SNAPSHOT = 7 /* restored from a snapshot which was  taken while domain was shutoff */
    VIR_DOMAIN_SHUTOFF_LAST = 8
};

Structure virDomainSnapshot

struct _virDomainSnapshot {
The content of this structure is not made public by the API.
} virDomainSnapshot;

Enum virDomainSnapshotCreateFlags

enum virDomainSnapshotCreateFlags {
    VIR_DOMAIN_SNAPSHOT_CREATE_REDEFINE = 1 /* Restore or alter metadata */
    VIR_DOMAIN_SNAPSHOT_CREATE_CURRENT = 2 /* With redefine, make snapshot current */
    VIR_DOMAIN_SNAPSHOT_CREATE_NO_METADATA = 4 /* Make snapshot without remembering it */
    VIR_DOMAIN_SNAPSHOT_CREATE_HALT = 8 /* Stop running guest after snapshot */
    VIR_DOMAIN_SNAPSHOT_CREATE_DISK_ONLY = 16 /* disk snapshot, not system checkpoint */
    VIR_DOMAIN_SNAPSHOT_CREATE_REUSE_EXT = 32 /* reuse any existing external files */
    VIR_DOMAIN_SNAPSHOT_CREATE_QUIESCE = 64 /* use guest agent to quiesce all mounted file systems within the domain */
    VIR_DOMAIN_SNAPSHOT_CREATE_ATOMIC = 128 /* atomically avoid partial changes */
    VIR_DOMAIN_SNAPSHOT_CREATE_LIVE = 256 /* create the snapshot while the guest is running */
};

Enum virDomainSnapshotDeleteFlags

enum virDomainSnapshotDeleteFlags {
    VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN = 1 /* Also delete children */
    VIR_DOMAIN_SNAPSHOT_DELETE_METADATA_ONLY = 2 /* Delete just metadata */
    VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN_ONLY = 4 /* Delete just children */
};

Enum virDomainSnapshotListFlags

enum virDomainSnapshotListFlags {
    VIR_DOMAIN_SNAPSHOT_LIST_DESCENDANTS = 1 /* List all descendants, not just children, when listing a snapshot For historical reasons, groups do not use contiguous bits. */
    VIR_DOMAIN_SNAPSHOT_LIST_ROOTS = 1 /* Filter by snapshots with no parents, when listing a domain */
    VIR_DOMAIN_SNAPSHOT_LIST_METADATA = 2 /* Filter by snapshots which have metadata */
    VIR_DOMAIN_SNAPSHOT_LIST_LEAVES = 4 /* Filter by snapshots with no children */
    VIR_DOMAIN_SNAPSHOT_LIST_NO_LEAVES = 8 /* Filter by snapshots that have children */
    VIR_DOMAIN_SNAPSHOT_LIST_NO_METADATA = 16 /* Filter by snapshots with no metadata */
    VIR_DOMAIN_SNAPSHOT_LIST_INACTIVE = 32 /* Filter by snapshots taken while guest was shut off */
    VIR_DOMAIN_SNAPSHOT_LIST_ACTIVE = 64 /* Filter by snapshots taken while guest was active, and with memory state */
    VIR_DOMAIN_SNAPSHOT_LIST_DISK_ONLY = 128 /* Filter by snapshots taken while guest was active, but without memory state */
    VIR_DOMAIN_SNAPSHOT_LIST_INTERNAL = 256 /* Filter by snapshots stored internal to disk images */
    VIR_DOMAIN_SNAPSHOT_LIST_EXTERNAL = 512 /* Filter by snapshots that use files external to disk images */
};

Typedef virDomainSnapshotPtr

virDomainSnapshot * virDomainSnapshotPtr;

a virDomainSnapshotPtr is pointer to a virDomainSnapshot private structure, and is the type used to reference a domain snapshot in the API.

Enum virDomainSnapshotRevertFlags

enum virDomainSnapshotRevertFlags {
    VIR_DOMAIN_SNAPSHOT_REVERT_RUNNING = 1 /* Run after revert */
    VIR_DOMAIN_SNAPSHOT_REVERT_PAUSED = 2 /* Pause after revert */
    VIR_DOMAIN_SNAPSHOT_REVERT_FORCE = 4 /* Allow risky reverts */
};

Enum virDomainState

enum virDomainState {
    VIR_DOMAIN_NOSTATE = 0 /* no state */
    VIR_DOMAIN_RUNNING = 1 /* the domain is running */
    VIR_DOMAIN_BLOCKED = 2 /* the domain is blocked on resource */
    VIR_DOMAIN_PAUSED = 3 /* the domain is paused by user */
    VIR_DOMAIN_SHUTDOWN = 4 /* the domain is being shut down */
    VIR_DOMAIN_SHUTOFF = 5 /* the domain is shut off */
    VIR_DOMAIN_CRASHED = 6 /* the domain is crashed */
    VIR_DOMAIN_PMSUSPENDED = 7 /* the domain is suspended by guest power management */
    VIR_DOMAIN_LAST = 8 /* NB: this enum value will increase over time as new events are  added to the libvirt API. It reflects the last state supported  by this version of the libvirt API. */
};

Structure virDomainStatsRecord

struct _virDomainStatsRecord {
    virDomainPtr	dom
    virTypedParameterPtr	params
    int	nparams
} virDomainStatsRecord;

Typedef virDomainStatsRecordPtr

virDomainStatsRecord * virDomainStatsRecordPtr;

Enum virDomainStatsTypes

enum virDomainStatsTypes {
    VIR_DOMAIN_STATS_STATE = 1 /* return domain state */
    VIR_DOMAIN_STATS_CPU_TOTAL = 2 /* return domain CPU info */
    VIR_DOMAIN_STATS_BALLOON = 4 /* return domain balloon info */
    VIR_DOMAIN_STATS_VCPU = 8 /* return domain virtual CPU info */
    VIR_DOMAIN_STATS_INTERFACE = 16 /* return domain interfaces info */
    VIR_DOMAIN_STATS_BLOCK = 32 /* return domain block info */
};

Enum virDomainUndefineFlagsValues

enum virDomainUndefineFlagsValues {
    VIR_DOMAIN_UNDEFINE_MANAGED_SAVE = 1 /* Also remove any managed save */
    VIR_DOMAIN_UNDEFINE_SNAPSHOTS_METADATA = 2 /* If last use of domain, then also remove any snapshot metadata */
    VIR_DOMAIN_UNDEFINE_NVRAM = 4 /* Also remove any nvram file Future undefine control flags should come here. */
};

Enum virDomainVcpuFlags

enum virDomainVcpuFlags {
    VIR_DOMAIN_VCPU_CONFIG = VIR_DOMAIN_AFFECT_CONFIG /* Additionally, these flags may be bitwise-OR'd in. */
    VIR_DOMAIN_VCPU_CURRENT = VIR_DOMAIN_AFFECT_CURRENT
    VIR_DOMAIN_VCPU_LIVE = VIR_DOMAIN_AFFECT_LIVE
    VIR_DOMAIN_VCPU_MAXIMUM = 4 /* Max rather than current count */
    VIR_DOMAIN_VCPU_GUEST = 8 /* Modify state of the cpu in the guest */
};

Enum virDomainXMLFlags

enum virDomainXMLFlags {
    VIR_DOMAIN_XML_SECURE = 1 /* dump security sensitive information too */
    VIR_DOMAIN_XML_INACTIVE = 2 /* dump inactive domain information */
    VIR_DOMAIN_XML_UPDATE_CPU = 4 /* update guest CPU requirements according to host CPU */
    VIR_DOMAIN_XML_MIGRATABLE = 8 /* dump XML suitable for migration */
};

Enum virEventHandleType

enum virEventHandleType {
    VIR_EVENT_HANDLE_READABLE = 1
    VIR_EVENT_HANDLE_WRITABLE = 2
    VIR_EVENT_HANDLE_ERROR = 4
    VIR_EVENT_HANDLE_HANGUP = 8
};

Enum virIPAddrType

enum virIPAddrType {
    VIR_IP_ADDR_TYPE_IPV4 = 0
    VIR_IP_ADDR_TYPE_IPV6 = 1
    VIR_IP_ADDR_TYPE_LAST = 2
};

Structure virInterface

struct _virInterface {
The content of this structure is not made public by the API.
} virInterface;

Typedef virInterfacePtr

virInterface * virInterfacePtr;

a virInterfacePtr is pointer to a virInterface private structure, this is the type used to reference a virtual interface in the API.

Enum virInterfaceXMLFlags

enum virInterfaceXMLFlags {
    VIR_INTERFACE_XML_INACTIVE = 1 /* dump inactive interface information */
};

Enum virKeycodeSet

enum virKeycodeSet {
    VIR_KEYCODE_SET_LINUX = 0
    VIR_KEYCODE_SET_XT = 1
    VIR_KEYCODE_SET_ATSET1 = 2
    VIR_KEYCODE_SET_ATSET2 = 3
    VIR_KEYCODE_SET_ATSET3 = 4
    VIR_KEYCODE_SET_OSX = 5
    VIR_KEYCODE_SET_XT_KBD = 6
    VIR_KEYCODE_SET_USB = 7
    VIR_KEYCODE_SET_WIN32 = 8
    VIR_KEYCODE_SET_RFB = 9
    VIR_KEYCODE_SET_LAST = 10 /* NB: this enum value will increase over time as new events are  added to the libvirt API. It reflects the last keycode set supported  by this version of the libvirt API. */
};

Structure virMemoryParameter

struct _virTypedParameter {
    char field[VIR_TYPED_PARAM_FIELD_LENGTH]	field	: parameter name
    int	type	: parameter type, virTypedParameterType
    union	value	: parameter value
} virMemoryParameter;

Typedef virMemoryParameterPtr

virMemoryParameter * virMemoryParameterPtr;

a virMemoryParameterPtr is a pointer to a virMemoryParameter structure. Provided for backwards compatibility; virTypedParameterPtr is the preferred alias since 0.9.2.

Enum virMemoryParameterType

enum virMemoryParameterType {
    VIR_DOMAIN_MEMORY_PARAM_BOOLEAN = VIR_TYPED_PARAM_BOOLEAN
    VIR_DOMAIN_MEMORY_PARAM_DOUBLE = VIR_TYPED_PARAM_DOUBLE
    VIR_DOMAIN_MEMORY_PARAM_INT = VIR_TYPED_PARAM_INT
    VIR_DOMAIN_MEMORY_PARAM_LLONG = VIR_TYPED_PARAM_LLONG
    VIR_DOMAIN_MEMORY_PARAM_UINT = VIR_TYPED_PARAM_UINT
    VIR_DOMAIN_MEMORY_PARAM_ULLONG = VIR_TYPED_PARAM_ULLONG
};

Structure virNWFilter

struct _virNWFilter {
The content of this structure is not made public by the API.
} virNWFilter;

Typedef virNWFilterPtr

virNWFilter * virNWFilterPtr;

a virNWFilterPtr is pointer to a virNWFilter private structure, this is the type used to reference a network filter in the API.

Structure virNetwork

struct _virNetwork {
The content of this structure is not made public by the API.
} virNetwork;

Structure virNetworkDHCPLease

struct _virNetworkDHCPLease {
    char *	iface	: Network interface name
    long long	expirytime	: Seconds since epoch
    int	type	: virIPAddrType
    char *	mac	: MAC address
    char *	iaid	: IAID
    char *	ipaddr	: IP address
    unsigned int	prefix	: IP address prefix
    char *	hostname	: Hostname
    char *	clientid	: Client ID or DUID
} virNetworkDHCPLease;

Typedef virNetworkDHCPLeasePtr

virNetworkDHCPLease * virNetworkDHCPLeasePtr;

Enum virNetworkEventID

enum virNetworkEventID {
    VIR_NETWORK_EVENT_ID_LIFECYCLE = 0 /* virConnectNetworkEventLifecycleCallback */
    VIR_NETWORK_EVENT_ID_LAST = 1 /* NB: this enum value will increase over time as new events are  added to the libvirt API. It reflects the last event ID supported  by this version of the libvirt API. */
};

Enum virNetworkEventLifecycleType

enum virNetworkEventLifecycleType {
    VIR_NETWORK_EVENT_DEFINED = 0
    VIR_NETWORK_EVENT_UNDEFINED = 1
    VIR_NETWORK_EVENT_STARTED = 2
    VIR_NETWORK_EVENT_STOPPED = 3
    VIR_NETWORK_EVENT_LAST = 4
};

Typedef virNetworkPtr

virNetwork * virNetworkPtr;

a virNetworkPtr is pointer to a virNetwork private structure, this is the type used to reference a virtual network in the API.

Enum virNetworkUpdateCommand

enum virNetworkUpdateCommand {
    VIR_NETWORK_UPDATE_COMMAND_NONE = 0 /* (invalid) */
    VIR_NETWORK_UPDATE_COMMAND_MODIFY = 1 /* modify an existing element */
    VIR_NETWORK_UPDATE_COMMAND_DELETE = 2 /* delete an existing element */
    VIR_NETWORK_UPDATE_COMMAND_ADD_LAST = 3 /* add an element at end of list */
    VIR_NETWORK_UPDATE_COMMAND_ADD_FIRST = 4 /* add an element at start of list */
    VIR_NETWORK_UPDATE_COMMAND_LAST = 5
};

Enum virNetworkUpdateFlags

enum virNetworkUpdateFlags {
    VIR_NETWORK_UPDATE_AFFECT_CURRENT = 0 /* affect live if network is active, config if it's not active */
    VIR_NETWORK_UPDATE_AFFECT_LIVE = 1 /* affect live state of network only */
    VIR_NETWORK_UPDATE_AFFECT_CONFIG = 2 /* affect persistent config only */
};

Enum virNetworkUpdateSection

enum virNetworkUpdateSection {
    VIR_NETWORK_SECTION_NONE = 0 /* (invalid) */
    VIR_NETWORK_SECTION_BRIDGE = 1 /* <bridge> */
    VIR_NETWORK_SECTION_DOMAIN = 2 /* <domain> */
    VIR_NETWORK_SECTION_IP = 3 /* <ip> */
    VIR_NETWORK_SECTION_IP_DHCP_HOST = 4 /* <ip>/<dhcp>/<host> */
    VIR_NETWORK_SECTION_IP_DHCP_RANGE = 5 /* <ip>/<dhcp>/<range> */
    VIR_NETWORK_SECTION_FORWARD = 6 /* <forward> */
    VIR_NETWORK_SECTION_FORWARD_INTERFACE = 7 /* <forward>/<interface> */
    VIR_NETWORK_SECTION_FORWARD_PF = 8 /* <forward>/<pf> */
    VIR_NETWORK_SECTION_PORTGROUP = 9 /* <portgroup> */
    VIR_NETWORK_SECTION_DNS_HOST = 10 /* <dns>/<host> */
    VIR_NETWORK_SECTION_DNS_TXT = 11 /* <dns>/<txt> */
    VIR_NETWORK_SECTION_DNS_SRV = 12 /* <dns>/<srv> */
    VIR_NETWORK_SECTION_LAST = 13
};

Enum virNetworkXMLFlags

enum virNetworkXMLFlags {
    VIR_NETWORK_XML_INACTIVE = 1 /* dump inactive network information */
};

Enum virNodeAllocPagesFlags

enum virNodeAllocPagesFlags {
    VIR_NODE_ALLOC_PAGES_ADD = 0 /* Add @pageCounts to the pages pool. This can be used only to size up the pool. */
    VIR_NODE_ALLOC_PAGES_SET = 1 /* Don't add @pageCounts, instead set passed number of pages. This can be used to free allocated pages. */
};

Structure virNodeCPUStats

struct _virNodeCPUStats {
    char field[VIR_NODE_CPU_STATS_FIELD_LENGTH]	field
    unsigned long long	value
} virNodeCPUStats;

Typedef virNodeCPUStatsPtr

virNodeCPUStats * virNodeCPUStatsPtr;

a virNodeCPUStatsPtr is a pointer to a virNodeCPUStats structure.

Structure virNodeDevice

struct _virNodeDevice {
The content of this structure is not made public by the API.
} virNodeDevice;

Typedef virNodeDevicePtr

virNodeDevice * virNodeDevicePtr;

A virNodeDevicePtr is a pointer to a virNodeDevice structure. Get one via virNodeDeviceLookupByName, or virNodeDeviceCreate. Be sure to call virNodeDeviceFree when done using a virNodeDevicePtr obtained from any of the above functions to avoid leaking memory.

Enum virNodeGetCPUStatsAllCPUs

enum virNodeGetCPUStatsAllCPUs {
    VIR_NODE_CPU_STATS_ALL_CPUS = -1
};

Enum virNodeGetMemoryStatsAllCells

enum virNodeGetMemoryStatsAllCells {
    VIR_NODE_MEMORY_STATS_ALL_CELLS = -1
};

Structure virNodeInfo

struct _virNodeInfo {
    char model[32]	model	: string indicating the CPU model
    unsigned long	memory	: memory size in kilobytes
    unsigned int	cpus	: the number of active CPUs
    unsigned int	mhz	: expected CPU frequency
    unsigned int	nodes	: the number of NUMA cell, 1 for unusual NUMA topologies or uniform memo
    unsigned int	sockets	: number of CPU sockets per node if nodes > 1, 1 in case of unusual NUMA
    unsigned int	cores	: number of cores per socket, total number of processors in case of unus
    unsigned int	threads	: number of threads per core, 1 in case of unusual numa topology
} virNodeInfo;

Typedef virNodeInfoPtr

virNodeInfo * virNodeInfoPtr;

a virNodeInfoPtr is a pointer to a virNodeInfo structure.

Structure virNodeMemoryStats

struct _virNodeMemoryStats {
    char field[VIR_NODE_MEMORY_STATS_FIELD_LENGTH]	field
    unsigned long long	value
} virNodeMemoryStats;

Typedef virNodeMemoryStatsPtr

virNodeMemoryStats * virNodeMemoryStatsPtr;

a virNodeMemoryStatsPtr is a pointer to a virNodeMemoryStats structure.

Enum virNodeSuspendTarget

enum virNodeSuspendTarget {
    VIR_NODE_SUSPEND_TARGET_MEM = 0
    VIR_NODE_SUSPEND_TARGET_DISK = 1
    VIR_NODE_SUSPEND_TARGET_HYBRID = 2
    VIR_NODE_SUSPEND_TARGET_LAST = 3 /* This constant is subject to change */
};

Structure virSchedParameter

struct _virTypedParameter {
    char field[VIR_TYPED_PARAM_FIELD_LENGTH]	field	: parameter name
    int	type	: parameter type, virTypedParameterType
    union	value	: parameter value
} virSchedParameter;

Typedef virSchedParameterPtr

virSchedParameter * virSchedParameterPtr;

a virSchedParameterPtr is a pointer to a virSchedParameter structure. Provided for backwards compatibility; virTypedParameterPtr is the preferred alias since 0.9.2.

Enum virSchedParameterType

enum virSchedParameterType {
    VIR_DOMAIN_SCHED_FIELD_BOOLEAN = VIR_TYPED_PARAM_BOOLEAN
    VIR_DOMAIN_SCHED_FIELD_DOUBLE = VIR_TYPED_PARAM_DOUBLE
    VIR_DOMAIN_SCHED_FIELD_INT = VIR_TYPED_PARAM_INT
    VIR_DOMAIN_SCHED_FIELD_LLONG = VIR_TYPED_PARAM_LLONG
    VIR_DOMAIN_SCHED_FIELD_UINT = VIR_TYPED_PARAM_UINT
    VIR_DOMAIN_SCHED_FIELD_ULLONG = VIR_TYPED_PARAM_ULLONG
};

Structure virSecret

struct _virSecret {
The content of this structure is not made public by the API.
} virSecret;

Typedef virSecretPtr

virSecret * virSecretPtr;

Enum virSecretUsageType

enum virSecretUsageType {
    VIR_SECRET_USAGE_TYPE_NONE = 0
    VIR_SECRET_USAGE_TYPE_VOLUME = 1
    VIR_SECRET_USAGE_TYPE_CEPH = 2
    VIR_SECRET_USAGE_TYPE_ISCSI = 3
    VIR_SECRET_USAGE_TYPE_LAST = 4 /* NB: this enum value will increase over time as new events are  added to the libvirt API. It reflects the last secret owner ID  supported by this version of the libvirt API. */
};

Structure virSecurityLabel

struct _virSecurityLabel {
The content of this structure is not made public by the API.
} virSecurityLabel;

Typedef virSecurityLabelPtr

virSecurityLabel * virSecurityLabelPtr;

a virSecurityLabelPtr is a pointer to a virSecurityLabel.

Structure virSecurityModel

struct _virSecurityModel {
The content of this structure is not made public by the API.
} virSecurityModel;

Typedef virSecurityModelPtr

virSecurityModel * virSecurityModelPtr;

a virSecurityModelPtr is a pointer to a virSecurityModel.

Structure virStoragePool

struct _virStoragePool {
The content of this structure is not made public by the API.
} virStoragePool;

Enum virStoragePoolBuildFlags

enum virStoragePoolBuildFlags {
    VIR_STORAGE_POOL_BUILD_NEW = 0 /* Regular build from scratch */
    VIR_STORAGE_POOL_BUILD_REPAIR = 1 /* Repair / reinitialize */
    VIR_STORAGE_POOL_BUILD_RESIZE = 2 /* Extend existing pool */
    VIR_STORAGE_POOL_BUILD_NO_OVERWRITE = 4 /* Do not overwrite existing pool */
    VIR_STORAGE_POOL_BUILD_OVERWRITE = 8 /* Overwrite data */
};

Enum virStoragePoolDeleteFlags

enum virStoragePoolDeleteFlags {
    VIR_STORAGE_POOL_DELETE_NORMAL = 0 /* Delete metadata only    (fast) */
    VIR_STORAGE_POOL_DELETE_ZEROED = 1 /* Clear all data to zeros (slow) */
};

Structure virStoragePoolInfo

struct _virStoragePoolInfo {
    int	state	: virStoragePoolState flags
    unsigned long long	capacity	: Logical size bytes
    unsigned long long	allocation	: Current allocation bytes
    unsigned long long	available	: Remaining free space bytes
} virStoragePoolInfo;

Typedef virStoragePoolInfoPtr

virStoragePoolInfo * virStoragePoolInfoPtr;

Typedef virStoragePoolPtr

virStoragePool * virStoragePoolPtr;

a virStoragePoolPtr is pointer to a virStoragePool private structure, this is the type used to reference a storage pool in the API.

Enum virStoragePoolState

enum virStoragePoolState {
    VIR_STORAGE_POOL_INACTIVE = 0 /* Not running */
    VIR_STORAGE_POOL_BUILDING = 1 /* Initializing pool, not available */
    VIR_STORAGE_POOL_RUNNING = 2 /* Running normally */
    VIR_STORAGE_POOL_DEGRADED = 3 /* Running degraded */
    VIR_STORAGE_POOL_INACCESSIBLE = 4 /* Running, but not accessible */
    VIR_STORAGE_POOL_STATE_LAST = 5
};

Structure virStorageVol

struct _virStorageVol {
The content of this structure is not made public by the API.
} virStorageVol;

Enum virStorageVolCreateFlags

enum virStorageVolCreateFlags {
    VIR_STORAGE_VOL_CREATE_PREALLOC_METADATA = 1
};

Enum virStorageVolDeleteFlags

enum virStorageVolDeleteFlags {
    VIR_STORAGE_VOL_DELETE_NORMAL = 0 /* Delete metadata only    (fast) */
    VIR_STORAGE_VOL_DELETE_ZEROED = 1 /* Clear all data to zeros (slow) */
};

Structure virStorageVolInfo

struct _virStorageVolInfo {
    int	type	: virStorageVolType flags
    unsigned long long	capacity	: Logical size bytes
    unsigned long long	allocation	: Current allocation bytes
} virStorageVolInfo;

Typedef virStorageVolInfoPtr

virStorageVolInfo * virStorageVolInfoPtr;

Typedef virStorageVolPtr

virStorageVol * virStorageVolPtr;

a virStorageVolPtr is pointer to a virStorageVol private structure, this is the type used to reference a storage volume in the API.

Enum virStorageVolResizeFlags

enum virStorageVolResizeFlags {
    VIR_STORAGE_VOL_RESIZE_ALLOCATE = 1 /* force allocation of new size */
    VIR_STORAGE_VOL_RESIZE_DELTA = 2 /* size is relative to current */
    VIR_STORAGE_VOL_RESIZE_SHRINK = 4 /* allow decrease in capacity */
};

Enum virStorageVolType

enum virStorageVolType {
    VIR_STORAGE_VOL_FILE = 0 /* Regular file based volumes */
    VIR_STORAGE_VOL_BLOCK = 1 /* Block based volumes */
    VIR_STORAGE_VOL_DIR = 2 /* Directory-passthrough based volume */
    VIR_STORAGE_VOL_NETWORK = 3 /* Network volumes like RBD (RADOS Block Device) */
    VIR_STORAGE_VOL_NETDIR = 4 /* Network accessible directory that can  contain other network volumes */
    VIR_STORAGE_VOL_LAST = 5
};

Enum virStorageVolWipeAlgorithm

enum virStorageVolWipeAlgorithm {
    VIR_STORAGE_VOL_WIPE_ALG_ZERO = 0 /* 1-pass, all zeroes */
    VIR_STORAGE_VOL_WIPE_ALG_NNSA = 1 /* 4-pass  NNSA Policy Letter NAP-14.1-C (XVI-8) */
    VIR_STORAGE_VOL_WIPE_ALG_DOD = 2 /* 4-pass DoD 5220.22-M section 8-306 procedure */
    VIR_STORAGE_VOL_WIPE_ALG_BSI = 3 /* 9-pass method recommended by the German Center of Security in Information Technologies */
    VIR_STORAGE_VOL_WIPE_ALG_GUTMANN = 4 /* The canonical 35-pass sequence */
    VIR_STORAGE_VOL_WIPE_ALG_SCHNEIER = 5 /* 7-pass method described by Bruce Schneier in "Applied Cryptography" (1996) */
    VIR_STORAGE_VOL_WIPE_ALG_PFITZNER7 = 6 /* 7-pass random */
    VIR_STORAGE_VOL_WIPE_ALG_PFITZNER33 = 7 /* 33-pass random */
    VIR_STORAGE_VOL_WIPE_ALG_RANDOM = 8 /* 1-pass random */
    VIR_STORAGE_VOL_WIPE_ALG_LAST = 9 /* NB: this enum value will increase over time as new algorithms are  added to the libvirt API. It reflects the last algorithm supported  by this version of the libvirt API. */
};

Enum virStorageXMLFlags

enum virStorageXMLFlags {
    VIR_STORAGE_XML_INACTIVE = 1 /* dump inactive pool/volume information */
};

Structure virStream

struct _virStream {
The content of this structure is not made public by the API.
} virStream;

Enum virStreamEventType

enum virStreamEventType {
    VIR_STREAM_EVENT_READABLE = 1
    VIR_STREAM_EVENT_WRITABLE = 2
    VIR_STREAM_EVENT_ERROR = 4
    VIR_STREAM_EVENT_HANGUP = 8
};

Enum virStreamFlags

enum virStreamFlags {
    VIR_STREAM_NONBLOCK = 1
};

Typedef virStreamPtr

virStream * virStreamPtr;

a virStreamPtr is pointer to a virStream private structure, this is the type used to reference a data stream in the API.

Structure virTypedParameter

struct _virTypedParameter {
    char field[VIR_TYPED_PARAM_FIELD_LENGTH]	field	: parameter name
    int	type	: parameter type, virTypedParameterType
    union	value	: parameter value
} virTypedParameter;

Enum virTypedParameterFlags

enum virTypedParameterFlags {
    VIR_TYPED_PARAM_STRING_OKAY = 4
};

Typedef virTypedParameterPtr

virTypedParameter * virTypedParameterPtr;

a pointer to a virTypedParameter structure.

Enum virTypedParameterType

enum virTypedParameterType {
    VIR_TYPED_PARAM_INT = 1 /* integer case */
    VIR_TYPED_PARAM_UINT = 2 /* unsigned integer case */
    VIR_TYPED_PARAM_LLONG = 3 /* long long case */
    VIR_TYPED_PARAM_ULLONG = 4 /* unsigned long long case */
    VIR_TYPED_PARAM_DOUBLE = 5 /* double case */
    VIR_TYPED_PARAM_BOOLEAN = 6 /* boolean(character) case */
    VIR_TYPED_PARAM_STRING = 7 /* string case */
    VIR_TYPED_PARAM_LAST = 8
};

Structure virVcpuInfo

struct _virVcpuInfo {
    unsigned int	number	: virtual CPU number
    int	state	: value from virVcpuState
    unsigned long long	cpuTime	: CPU time used, in nanoseconds
    int	cpu	: real CPU number, or -1 if offline
} virVcpuInfo;

Typedef virVcpuInfoPtr

virVcpuInfo * virVcpuInfoPtr;

Enum virVcpuState

enum virVcpuState {
    VIR_VCPU_OFFLINE = 0 /* the virtual CPU is offline */
    VIR_VCPU_RUNNING = 1 /* the virtual CPU is running */
    VIR_VCPU_BLOCKED = 2 /* the virtual CPU is blocked on resource */
    VIR_VCPU_LAST = 3
};

Function type virConnectAuthCallbackPtr

int	virConnectAuthCallbackPtr	(virConnectCredentialPtr cred, 
					 unsigned int ncred, 
					 void * cbdata)

When authentication requires one or more interactions, this callback is invoked. For each interaction supplied, data must be gathered from the user and filled in to the 'result' and 'resultlen' fields. If an interaction cannot be filled, fill in NULL and 0.

Function type virConnectCloseFunc

void	virConnectCloseFunc		(virConnectPtr conn, 
					 int reason, 
					 void * opaque)

A callback function to be registered, and called when the connection is closed.

Function type virConnectDomainEventBalloonChangeCallback

void	virConnectDomainEventBalloonChangeCallback	(virConnectPtr conn, 
							 virDomainPtr dom, 
							 unsigned long long actual, 
							 void * opaque)

The callback signature to use when registering for an event of type VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE with virConnectDomainEventRegisterAny()

Function type virConnectDomainEventBlockJobCallback

void	virConnectDomainEventBlockJobCallback	(virConnectPtr conn, 
						 virDomainPtr dom, 
						 const char * disk, 
						 int type, 
						 int status, 
						 void * opaque)

The string returned for @disk can be used in any of the libvirt API that operate on a particular disk of the domain, and depends on what event type was registered with virConnectDomainEventRegisterAny(). If the callback was registered using the older type of VIR_DOMAIN_EVENT_ID_BLOCK_JOB, then @disk contains the absolute file name of the host resource for the active layer of the disk; however, this name is unstable (pivoting via block copy or active block commit will change which file is active, giving a different name for the two events associated with the same job) and cannot be relied on if the active layer is associated with a network resource. If the callback was registered using the newer type of VIR_DOMAIN_EVENT_ID_BLOCK_JOB_2, then @disk will contain the device target shorthand (the <target dev='...'/> sub-element, such as "vda").

Function type virConnectDomainEventCallback

int	virConnectDomainEventCallback	(virConnectPtr conn, 
					 virDomainPtr dom, 
					 int event, 
					 int detail, 
					 void * opaque)

A callback function to be registered, and called when a domain event occurs

Function type virConnectDomainEventDeviceRemovedCallback

void	virConnectDomainEventDeviceRemovedCallback	(virConnectPtr conn, 
							 virDomainPtr dom, 
							 const char * devAlias, 
							 void * opaque)

This callback occurs when a device is removed from the domain. The callback signature to use when registering for an event of type VIR_DOMAIN_EVENT_ID_DEVICE_REMOVED with virConnectDomainEventRegisterAny()

Function type virConnectDomainEventDiskChangeCallback

void	virConnectDomainEventDiskChangeCallback	(virConnectPtr conn, 
						 virDomainPtr dom, 
						 const char * oldSrcPath, 
						 const char * newSrcPath, 
						 const char * devAlias, 
						 int reason, 
						 void * opaque)

This callback occurs when disk gets changed. However, not all @reason will cause both @oldSrcPath and @newSrcPath to be non-NULL. Please see virConnectDomainEventDiskChangeReason for more details. The callback signature to use when registering for an event of type VIR_DOMAIN_EVENT_ID_DISK_CHANGE with virConnectDomainEventRegisterAny()

Function type virConnectDomainEventGenericCallback

void	virConnectDomainEventGenericCallback	(virConnectPtr conn, 
						 virDomainPtr dom, 
						 void * opaque)

A generic domain event callback handler, for use with virConnectDomainEventRegisterAny(). Specific events usually have a customization with extra parameters, often with @opaque being passed in a different parameter position; use VIR_DOMAIN_EVENT_CALLBACK() when registering an appropriate handler.

Function type virConnectDomainEventGraphicsCallback

void	virConnectDomainEventGraphicsCallback	(virConnectPtr conn, 
						 virDomainPtr dom, 
						 int phase, 
						 const virDomainEventGraphicsAddress * local, 
						 const virDomainEventGraphicsAddress * remote, 
						 const char * authScheme, 
						 const virDomainEventGraphicsSubject * subject, 
						 void * opaque)

The callback signature to use when registering for an event of type VIR_DOMAIN_EVENT_ID_GRAPHICS with virConnectDomainEventRegisterAny()

Function type virConnectDomainEventIOErrorCallback

void	virConnectDomainEventIOErrorCallback	(virConnectPtr conn, 
						 virDomainPtr dom, 
						 const char * srcPath, 
						 const char * devAlias, 
						 int action, 
						 void * opaque)

The callback signature to use when registering for an event of type VIR_DOMAIN_EVENT_ID_IO_ERROR with virConnectDomainEventRegisterAny()

Function type virConnectDomainEventIOErrorReasonCallback

void	virConnectDomainEventIOErrorReasonCallback	(virConnectPtr conn, 
							 virDomainPtr dom, 
							 const char * srcPath, 
							 const char * devAlias, 
							 int action, 
							 const char * reason, 
							 void * opaque)

The callback signature to use when registering for an event of type VIR_DOMAIN_EVENT_ID_IO_ERROR_REASON with virConnectDomainEventRegisterAny()

Function type virConnectDomainEventPMSuspendCallback

void	virConnectDomainEventPMSuspendCallback	(virConnectPtr conn, 
						 virDomainPtr dom, 
						 int reason, 
						 void * opaque)

This callback occurs when the guest is suspended. The callback signature to use when registering for an event of type VIR_DOMAIN_EVENT_ID_PMSUSPEND with virConnectDomainEventRegisterAny()

Function type virConnectDomainEventPMSuspendDiskCallback

void	virConnectDomainEventPMSuspendDiskCallback	(virConnectPtr conn, 
							 virDomainPtr dom, 
							 int reason, 
							 void * opaque)

This callback occurs when the guest is suspended to disk. The callback signature to use when registering for an event of type VIR_DOMAIN_EVENT_ID_PMSUSPEND_DISK with virConnectDomainEventRegisterAny()

Function type virConnectDomainEventPMWakeupCallback

void	virConnectDomainEventPMWakeupCallback	(virConnectPtr conn, 
						 virDomainPtr dom, 
						 int reason, 
						 void * opaque)

This callback occurs when the guest is woken up. The callback signature to use when registering for an event of type VIR_DOMAIN_EVENT_ID_PMWAKEUP with virConnectDomainEventRegisterAny()

Function type virConnectDomainEventRTCChangeCallback

void	virConnectDomainEventRTCChangeCallback	(virConnectPtr conn, 
						 virDomainPtr dom, 
						 long long utcoffset, 
						 void * opaque)

The callback signature to use when registering for an event of type VIR_DOMAIN_EVENT_ID_RTC_CHANGE with virConnectDomainEventRegisterAny()

Function type virConnectDomainEventTrayChangeCallback

void	virConnectDomainEventTrayChangeCallback	(virConnectPtr conn, 
						 virDomainPtr dom, 
						 const char * devAlias, 
						 int reason, 
						 void * opaque)

This callback occurs when the tray of a removable device is moved. The callback signature to use when registering for an event of type VIR_DOMAIN_EVENT_ID_TRAY_CHANGE with virConnectDomainEventRegisterAny()

Function type virConnectDomainEventTunableCallback

void	virConnectDomainEventTunableCallback	(virConnectPtr conn, 
						 virDomainPtr dom, 
						 virTypedParameterPtr params, 
						 int nparams, 
						 void * opaque)

This callback occurs when tunable values are updated. The params must not be freed in the callback handler as it's done internally after the callback handler is executed. Currently supported name spaces: "cputune.*" "blkdeviotune.*" The callback signature to use when registering for an event of type VIR_DOMAIN_EVENT_ID_TUNABLE with virConnectDomainEventRegisterAny()

Function type virConnectDomainEventWatchdogCallback

void	virConnectDomainEventWatchdogCallback	(virConnectPtr conn, 
						 virDomainPtr dom, 
						 int action, 
						 void * opaque)

The callback signature to use when registering for an event of type VIR_DOMAIN_EVENT_ID_WATCHDOG with virConnectDomainEventRegisterAny()

Function type virConnectNetworkEventGenericCallback

void	virConnectNetworkEventGenericCallback	(virConnectPtr conn, 
						 virNetworkPtr net, 
						 void * opaque)

A generic network event callback handler, for use with virConnectNetworkEventRegisterAny(). Specific events usually have a customization with extra parameters, often with @opaque being passed in a different parameter position; use VIR_NETWORK_EVENT_CALLBACK() when registering an appropriate handler.

Function type virConnectNetworkEventLifecycleCallback

void	virConnectNetworkEventLifecycleCallback	(virConnectPtr conn, 
						 virNetworkPtr net, 
						 int event, 
						 int detail, 
						 void * opaque)

This callback occurs when the network is started or stopped. The callback signature to use when registering for an event of type VIR_NETWORK_EVENT_ID_LIFECYCLE with virConnectNetworkEventRegisterAny()

Function type virEventAddHandleFunc

int	virEventAddHandleFunc		(int fd, 
					 int event, 
					 virEventHandleCallback cb, 
					 void * opaque, 
					 virFreeCallback ff)

Part of the EventImpl, this callback adds a file handle callback to listen for specific events. The same file handle can be registered multiple times provided the requested event sets are non-overlapping If the opaque user data requires free'ing when the handle is unregistered, then a 2nd callback can be supplied for this purpose. This callback needs to be invoked from a clean stack. If 'ff' callbacks are invoked directly from the virEventRemoveHandleFunc they will likely deadlock in libvirt.

Function type virEventAddTimeoutFunc

int	virEventAddTimeoutFunc		(int timeout, 
					 virEventTimeoutCallback cb, 
					 void * opaque, 
					 virFreeCallback ff)

Part of the EventImpl, this user-defined callback handles adding an event timeout. If the opaque user data requires free'ing when the handle is unregistered, then a 2nd callback can be supplied for this purpose.

Function type virEventHandleCallback

void	virEventHandleCallback		(int watch, 
					 int fd, 
					 int events, 
					 void * opaque)

Callback for receiving file handle events. The callback will be invoked once for each event which is pending.

Function type virEventRemoveHandleFunc

int	virEventRemoveHandleFunc	(int watch)

Part of the EventImpl, this user-provided callback is notified when an fd is no longer being listened on. If a virEventHandleFreeFunc was supplied when the handle was registered, it will be invoked some time during, or after this function call, when it is safe to release the user data.

Function type virEventRemoveTimeoutFunc

int	virEventRemoveTimeoutFunc	(int timer)

Part of the EventImpl, this user-defined callback removes a timer If a virEventTimeoutFreeFunc was supplied when the handle was registered, it will be invoked some time during, or after this function call, when it is safe to release the user data.

Function type virEventTimeoutCallback

void	virEventTimeoutCallback		(int timer, 
					 void * opaque)

callback for receiving timer events

Function type virEventUpdateHandleFunc

void	virEventUpdateHandleFunc	(int watch, 
					 int event)

Part of the EventImpl, this user-provided callback is notified when events to listen on change

Function type virEventUpdateTimeoutFunc

void	virEventUpdateTimeoutFunc	(int timer, 
					 int timeout)

Part of the EventImpl, this user-defined callback updates an event timeout.

Function type virFreeCallback

void	virFreeCallback			(void * opaque)

Type for a callback cleanup function to be paired with a callback. This function will be called as a final chance to clean up the @opaque registered with the primary callback, at the time when the primary callback is deregistered. It is forbidden to call any other libvirt APIs from an implementation of this callback, since it can be invoked from a context which is not re-entrant safe. Failure to abide by this requirement may lead to application deadlocks or crashes.

Function type virStreamEventCallback

void	virStreamEventCallback		(virStreamPtr stream, 
					 int events, 
					 void * opaque)

Callback for receiving stream events. The callback will be invoked once for each event which is pending.

Function type virStreamSinkFunc

int	virStreamSinkFunc		(virStreamPtr st, 
					 const char * data, 
					 size_t nbytes, 
					 void * opaque)

The virStreamSinkFunc callback is used together with the virStreamRecvAll function for libvirt to provide the data that has been received. The callback will be invoked multiple times, providing data in small chunks. The application should consume up 'nbytes' from the 'data' array of data and then return the number actual number of bytes consumed. The callback will continue to be invoked until it indicates the end of the stream has been reached. A return value of -1 at any time will abort the receive operation

Function type virStreamSourceFunc

int	virStreamSourceFunc		(virStreamPtr st, 
					 char * data, 
					 size_t nbytes, 
					 void * opaque)

The virStreamSourceFunc callback is used together with the virStreamSendAll function for libvirt to obtain the data that is to be sent. The callback will be invoked multiple times, fetching data in small chunks. The application should fill the 'data' array with up to 'nbytes' of data and then return the number actual number of bytes. The callback will continue to be invoked until it indicates the end of the source has been reached by returning 0. A return value of -1 at any time will abort the send operation

Variable virConnectAuthPtrDefault

virConnectAuthPtr virConnectAuthPtrDefault;

virConnectBaselineCPU ()

char *	virConnectBaselineCPU		(virConnectPtr conn, 
					 const char ** xmlCPUs, 
					 unsigned int ncpus, 
					 unsigned int flags)

Computes the most feature-rich CPU which is compatible with all given host CPUs. If @flags includes VIR_CONNECT_BASELINE_CPU_EXPAND_FEATURES then libvirt will explicitly list all CPU features that are part of the host CPU, without this flag features that are part of the CPU model will not be listed.

virConnectClose ()

int	virConnectClose			(virConnectPtr conn)

This function closes the connection to the Hypervisor. This should not be called if further interaction with the Hypervisor are needed especially if there is running domain which need further monitoring by the application. Connections are reference counted; the count is explicitly increased by the initial open (virConnectOpen, virConnectOpenAuth, and the like) as well as virConnectRef; it is also temporarily increased by other API that depend on the connection remaining alive. The open and every virConnectRef call should have a matching virConnectClose, and all other references will be released after the corresponding operation completes.

virConnectCompareCPU ()

int	virConnectCompareCPU		(virConnectPtr conn, 
					 const char * xmlDesc, 
					 unsigned int flags)

Compares the given CPU description with the host CPU

virConnectDomainEventDeregister ()

int	virConnectDomainEventDeregister	(virConnectPtr conn, 
					 virConnectDomainEventCallback cb)

Removes a callback previously registered with the virConnectDomainEventRegister() function. Use of this method is no longer recommended. Instead applications should try virConnectDomainEventDeregisterAny() which has a more flexible API contract

virConnectDomainEventDeregisterAny ()

int	virConnectDomainEventDeregisterAny	(virConnectPtr conn, 
						 int callbackID)

Removes an event callback. The callbackID parameter should be the value obtained from a previous virConnectDomainEventRegisterAny() method.

virConnectDomainEventRegister ()

int	virConnectDomainEventRegister	(virConnectPtr conn, 
					 virConnectDomainEventCallback cb, 
					 void * opaque, 
					 virFreeCallback freecb)

Adds a callback to receive notifications of domain lifecycle events occurring on a connection. This function requires that an event loop has been previously registered with virEventRegisterImpl() or virEventRegisterDefaultImpl(). Use of this method is no longer recommended. Instead applications should try virConnectDomainEventRegisterAny() which has a more flexible API contract. The virDomainPtr object handle passed into the callback upon delivery of an event is only valid for the duration of execution of the callback. If the callback wishes to keep the domain object after the callback returns, it shall take a reference to it, by calling virDomainRef. The reference can be released once the object is no longer required by calling virDomainFree.

virConnectDomainEventRegisterAny ()

int	virConnectDomainEventRegisterAny	(virConnectPtr conn, 
						 virDomainPtr dom, 
						 int eventID, 
						 virConnectDomainEventGenericCallback cb, 
						 void * opaque, 
						 virFreeCallback freecb)

Adds a callback to receive notifications of arbitrary domain events occurring on a domain. This function requires that an event loop has been previously registered with virEventRegisterImpl() or virEventRegisterDefaultImpl(). If @dom is NULL, then events will be monitored for any domain. If @dom is non-NULL, then only the specific domain will be monitored. Most types of event have a callback providing a custom set of parameters for the event. When registering an event, it is thus necessary to use the VIR_DOMAIN_EVENT_CALLBACK() macro to cast the supplied function pointer to match the signature of this method. The virDomainPtr object handle passed into the callback upon delivery of an event is only valid for the duration of execution of the callback. If the callback wishes to keep the domain object after the callback returns, it shall take a reference to it, by calling virDomainRef(). The reference can be released once the object is no longer required by calling virDomainFree(). The return value from this method is a positive integer identifier for the callback. To unregister a callback, this callback ID should be passed to the virConnectDomainEventDeregisterAny() method.

virConnectDomainXMLFromNative ()

char *	virConnectDomainXMLFromNative	(virConnectPtr conn, 
					 const char * nativeFormat, 
					 const char * nativeConfig, 
					 unsigned int flags)

Reads native configuration data describing a domain, and generates libvirt domain XML. The format of the native data is hypervisor dependant.

virConnectDomainXMLToNative ()

char *	virConnectDomainXMLToNative	(virConnectPtr conn, 
					 const char * nativeFormat, 
					 const char * domainXml, 
					 unsigned int flags)

Reads a domain XML configuration document, and generates a native configuration file describing the domain. The format of the native data is hypervisor dependant.

virConnectFindStoragePoolSources ()

char *	virConnectFindStoragePoolSources	(virConnectPtr conn, 
						 const char * type, 
						 const char * srcSpec, 
						 unsigned int flags)

Talks to a storage backend and attempts to auto-discover the set of available storage pool sources. e.g. For iSCSI this would be a set of iSCSI targets. For NFS this would be a list of exported paths. The srcSpec (optional for some storage pool types, e.g. local ones) is an instance of the storage pool's source element specifying where to look for the pools. srcSpec is not required for some types (e.g., those querying local storage resources only)

virConnectGetAllDomainStats ()

int	virConnectGetAllDomainStats	(virConnectPtr conn, 
					 unsigned int stats, 
					 virDomainStatsRecordPtr ** retStats, 
					 unsigned int flags)

Query statistics for all domains on a given connection. Report statistics of various parameters for a running VM according to @stats field. The statistics are returned as an array of structures for each queried domain. The structure contains an array of typed parameters containing the individual statistics. The typed parameter name for each statistic field consists of a dot-separated string containing name of the requested group followed by a group specific description of the statistic value. The statistic groups are enabled using the @stats parameter which is a binary-OR of enum virDomainStatsTypes. The following groups are available (although not necessarily implemented for each hypervisor): VIR_DOMAIN_STATS_STATE: Return domain state and reason for entering that state. The typed parameter keys are in this format: "state.state" - state of the VM, returned as int from virDomainState enum "state.reason" - reason for entering given state, returned as int from virDomain*Reason enum corresponding to given state. VIR_DOMAIN_STATS_CPU_TOTAL: Return CPU statistics and usage information. The typed parameter keys are in this format: "cpu.time" - total cpu time spent for this domain in nanoseconds as unsigned long long. "cpu.user" - user cpu time spent in nanoseconds as unsigned long long. "cpu.system" - system cpu time spent in nanoseconds as unsigned long long. VIR_DOMAIN_STATS_BALLOON: Return memory balloon device information. The typed parameter keys are in this format: "balloon.current" - the memory in kiB currently used as unsigned long long. "balloon.maximum" - the maximum memory in kiB allowed as unsigned long long. VIR_DOMAIN_STATS_VCPU: Return virtual CPU statistics. Due to VCPU hotplug, the vcpu.<num>.* array could be sparse. The actual size of the array corresponds to "vcpu.current". The array size will never exceed "vcpu.maximum". The typed parameter keys are in this format: "vcpu.current" - current number of online virtual CPUs as unsigned int. "vcpu.maximum" - maximum number of online virtual CPUs as unsigned int. "vcpu.<num>.state" - state of the virtual CPU <num>, as int from virVcpuState enum. "vcpu.<num>.time" - virtual cpu time spent by virtual CPU <num> as unsigned long long. VIR_DOMAIN_STATS_INTERFACE: Return network interface statistics. The typed parameter keys are in this format: "net.count" - number of network interfaces on this domain as unsigned int. "net.<num>.name" - name of the interface <num> as string. "net.<num>.rx.bytes" - bytes received as unsigned long long. "net.<num>.rx.pkts" - packets received as unsigned long long. "net.<num>.rx.errs" - receive errors as unsigned long long. "net.<num>.rx.drop" - receive packets dropped as unsigned long long. "net.<num>.tx.bytes" - bytes transmitted as unsigned long long. "net.<num>.tx.pkts" - packets transmitted as unsigned long long. "net.<num>.tx.errs" - transmission errors as unsigned long long. "net.<num>.tx.drop" - transmit packets dropped as unsigned long long. VIR_DOMAIN_STATS_BLOCK: Return block devices statistics. The typed parameter keys are in this format: "block.count" - number of block devices on this domain as unsigned int. "block.<num>.name" - name of the block device <num> as string. matches the target name (vda/sda/hda) of the block device. "block.<num>.rd.reqs" - number of read requests as unsigned long long. "block.<num>.rd.bytes" - number of read bytes as unsigned long long. "block.<num>.rd.times" - total time (ns) spent on reads as unsigned long long. "block.<num>.wr.reqs" - number of write requests as unsigned long long. "block.<num>.wr.bytes" - number of written bytes as unsigned long long. "block.<num>.wr.times" - total time (ns) spent on writes as unsigned long long. "block.<num>.fl.reqs" - total flush requests as unsigned long long. "block.<num>.fl.times" - total time (ns) spent on cache flushing as unsigned long long. "block.<num>.errors" - Xen only: the 'oo_req' value as unsigned long long. Note that entire stats groups or individual stat fields may be missing from the output in case they are not supported by the given hypervisor, are not applicable for the current state of the guest domain, or their retrieval was not successful. Using 0 for @stats returns all stats groups supported by the given hypervisor. Specifying VIR_CONNECT_GET_ALL_DOMAINS_STATS_ENFORCE_STATS as @flags makes the function return error in case some of the stat types in @stats were not recognized by the daemon. Similarly to virConnectListAllDomains, @flags can contain various flags to filter the list of domains to provide stats for. VIR_CONNECT_GET_ALL_DOMAINS_STATS_ACTIVE selects online domains while VIR_CONNECT_GET_ALL_DOMAINS_STATS_INACTIVE selects offline ones. VIR_CONNECT_GET_ALL_DOMAINS_STATS_PERSISTENT and VIR_CONNECT_GET_ALL_DOMAINS_STATS_TRANSIENT allow to filter the list according to their persistence. To filter the list of VMs by domain state @flags can contain VIR_CONNECT_GET_ALL_DOMAINS_STATS_RUNNING, VIR_CONNECT_GET_ALL_DOMAINS_STATS_PAUSED, VIR_CONNECT_GET_ALL_DOMAINS_STATS_SHUTOFF and/or VIR_CONNECT_GET_ALL_DOMAINS_STATS_OTHER for all other states.

virConnectGetCPUModelNames ()

int	virConnectGetCPUModelNames	(virConnectPtr conn, 
					 const char * arch, 
					 char ** * models, 
					 unsigned int flags)

Get the list of supported CPU models for a specific architecture.

virConnectGetCapabilities ()

char *	virConnectGetCapabilities	(virConnectPtr conn)

Provides capabilities of the hypervisor / driver.

virConnectGetDomainCapabilities ()

char *	virConnectGetDomainCapabilities	(virConnectPtr conn, 
					 const char * emulatorbin, 
					 const char * arch, 
					 const char * machine, 
					 const char * virttype, 
					 unsigned int flags)

Prior creating a domain (for instance via virDomainCreateXML or virDomainDefineXML) it may be suitable to know what the underlying emulator and/or libvirt is capable of. For instance, if host, libvirt and qemu is capable of VFIO passthrough and so on.

virConnectGetHostname ()

char *	virConnectGetHostname		(virConnectPtr conn)

This returns a system hostname on which the hypervisor is running (based on the result of the gethostname system call, but possibly expanded to a fully-qualified domain name via getaddrinfo). If we are connected to a remote system, then this returns the hostname of the remote system.

virConnectGetLibVersion ()

int	virConnectGetLibVersion		(virConnectPtr conn, 
					 unsigned long * libVer)

Provides @libVer, which is the version of libvirt used by the daemon running on the @conn host

virConnectGetMaxVcpus ()

int	virConnectGetMaxVcpus		(virConnectPtr conn, 
					 const char * type)

Provides the maximum number of virtual CPUs supported for a guest VM of a specific type. The 'type' parameter here corresponds to the 'type' attribute in the <domain> element of the XML.

virConnectGetSysinfo ()

char *	virConnectGetSysinfo		(virConnectPtr conn, 
					 unsigned int flags)

This returns the XML description of the sysinfo details for the host on which the hypervisor is running, in the same format as the <sysinfo> element of a domain XML. This information is generally available only for hypervisors running with root privileges.

virConnectGetType ()

const char *	virConnectGetType	(virConnectPtr conn)

Get the name of the Hypervisor driver used. This is merely the driver name; for example, both KVM and QEMU guests are serviced by the driver for the qemu:// URI, so a return of "QEMU" does not indicate whether KVM acceleration is present. For more details about the hypervisor, use virConnectGetCapabilities().

virConnectGetURI ()

char *	virConnectGetURI		(virConnectPtr conn)

This returns the URI (name) of the hypervisor connection. Normally this is the same as or similar to the string passed to the virConnectOpen/virConnectOpenReadOnly call, but the driver may make the URI canonical. If name == NULL was passed to virConnectOpen, then the driver will return a non-NULL URI which can be used to connect to the same hypervisor later.

virConnectGetVersion ()

int	virConnectGetVersion		(virConnectPtr conn, 
					 unsigned long * hvVer)

Get the version level of the Hypervisor running. This may work only with hypervisor call, i.e. with privileged access to the hypervisor, not with a Read-Only connection.

virConnectIsAlive ()

int	virConnectIsAlive		(virConnectPtr conn)

Determine if the connection to the hypervisor is still alive A connection will be classed as alive if it is either local, or running over a channel (TCP or UNIX socket) which is not closed.

virConnectIsEncrypted ()

int	virConnectIsEncrypted		(virConnectPtr conn)

Determine if the connection to the hypervisor is encrypted

virConnectIsSecure ()

int	virConnectIsSecure		(virConnectPtr conn)

Determine if the connection to the hypervisor is secure A connection will be classed as secure if it is either encrypted, or running over a channel which is not exposed to eavesdropping (eg a UNIX domain socket, or pipe)

virConnectListAllDomains ()

int	virConnectListAllDomains	(virConnectPtr conn, 
					 virDomainPtr ** domains, 
					 unsigned int flags)

Collect a possibly-filtered list of all domains, and return an allocated array of information for each. This API solves the race inherent in virConnectListDomains() and virConnectListDefinedDomains(). Normally, all domains are returned; however, @flags can be used to filter the results for a smaller list of targeted domains. The valid flags are divided into groups, where each group contains bits that describe mutually exclusive attributes of a domain, and where all bits within a group describe all possible domains. Some hypervisors might reject explicit bits from a group where the hypervisor cannot make a distinction (for example, not all hypervisors can tell whether domains have snapshots). For a group supported by a given hypervisor, the behavior when no bits of a group are set is identical to the behavior when all bits in that group are set. When setting bits from more than one group, it is possible to select an impossible combination (such as an inactive transient domain), in that case a hypervisor may return either 0 or an error. The first group of @flags is VIR_CONNECT_LIST_DOMAINS_ACTIVE (online domains) and VIR_CONNECT_LIST_DOMAINS_INACTIVE (offline domains). The next group of @flags is VIR_CONNECT_LIST_DOMAINS_PERSISTENT (defined domains) and VIR_CONNECT_LIST_DOMAINS_TRANSIENT (running but not defined). The next group of @flags covers various domain states: VIR_CONNECT_LIST_DOMAINS_RUNNING, VIR_CONNECT_LIST_DOMAINS_PAUSED, VIR_CONNECT_LIST_DOMAINS_SHUTOFF, and a catch-all for all other states (such as crashed, this catch-all covers the possibility of adding new states). The remaining groups cover boolean attributes commonly asked about domains; they include VIR_CONNECT_LIST_DOMAINS_MANAGEDSAVE and VIR_CONNECT_LIST_DOMAINS_NO_MANAGEDSAVE, for filtering based on whether a managed save image exists; VIR_CONNECT_LIST_DOMAINS_AUTOSTART and VIR_CONNECT_LIST_DOMAINS_NO_AUTOSTART, for filtering based on autostart; VIR_CONNECT_LIST_DOMAINS_HAS_SNAPSHOT and VIR_CONNECT_LIST_DOMAINS_NO_SNAPSHOT, for filtering based on whether a domain has snapshots. Example of usage: virDomainPtr *domains; size_t i; int ret; unsigned int flags = VIR_CONNECT_LIST_DOMAINS_RUNNING | VIR_CONNECT_LIST_DOMAINS_PERSISTENT; ret = virConnectListAllDomains(conn, &domains, flags); if (ret < 0) error(); for (i = 0; i < ret; i++) { do_something_with_domain(domains[i]); //here or in a separate loop if needed virDomainFree(domains[i]); } free(domains);

virConnectListAllInterfaces ()

int	virConnectListAllInterfaces	(virConnectPtr conn, 
					 virInterfacePtr ** ifaces, 
					 unsigned int flags)

Collect the list of interfaces, and allocate an array to store those objects. This API solves the race inherent between virConnectListInterfaces and virConnectListDefinedInterfaces. Normally, all interfaces are returned; however, @flags can be used to filter the results for a smaller list of targeted interfaces. The valid flags are divided into groups, where each group contains bits that describe mutually exclusive attributes of a interface, and where all bits within a group describe all possible interfaces. The only group of @flags is VIR_CONNECT_LIST_INTERFACES_ACTIVE (up) and VIR_CONNECT_LIST_INTERFACES_INACTIVE (down) to filter the interfaces by state.

virConnectListAllNWFilters ()

int	virConnectListAllNWFilters	(virConnectPtr conn, 
					 virNWFilterPtr ** filters, 
					 unsigned int flags)

Collect the list of network filters, and allocate an array to store those objects.

virConnectListAllNetworks ()

int	virConnectListAllNetworks	(virConnectPtr conn, 
					 virNetworkPtr ** nets, 
					 unsigned int flags)

Collect the list of networks, and allocate an array to store those objects. This API solves the race inherent between virConnectListNetworks and virConnectListDefinedNetworks. Normally, all networks are returned; however, @flags can be used to filter the results for a smaller list of targeted networks. The valid flags are divided into groups, where each group contains bits that describe mutually exclusive attributes of a network, and where all bits within a group describe all possible networks. The first group of @flags is VIR_CONNECT_LIST_NETWORKS_ACTIVE (up) and VIR_CONNECT_LIST_NETWORKS_INACTIVE (down) to filter the networks by state. The second group of @flags is VIR_CONNECT_LIST_NETWORKS_PERSISTENT (defined) and VIR_CONNECT_LIST_NETWORKS_TRANSIENT (running but not defined), to filter the networks by whether they have persistent config or not. The third group of @flags is VIR_CONNECT_LIST_NETWORKS_AUTOSTART and VIR_CONNECT_LIST_NETWORKS_NO_AUTOSTART, to filter the networks by whether they are marked as autostart or not.

virConnectListAllNodeDevices ()

int	virConnectListAllNodeDevices	(virConnectPtr conn, 
					 virNodeDevicePtr ** devices, 
					 unsigned int flags)

Collect the list of node devices, and allocate an array to store those objects. Normally, all node devices are returned; however, @flags can be used to filter the results for a smaller list of targeted node devices. The valid flags are divided into groups, where each group contains bits that describe mutually exclusive attributes of a node device, and where all bits within a group describe all possible node devices. Only one group of the @flags is provided to filter the node devices by capability type, flags include: VIR_CONNECT_LIST_NODE_DEVICES_CAP_SYSTEM VIR_CONNECT_LIST_NODE_DEVICES_CAP_PCI_DEV VIR_CONNECT_LIST_NODE_DEVICES_CAP_USB_DEV VIR_CONNECT_LIST_NODE_DEVICES_CAP_USB_INTERFACE VIR_CONNECT_LIST_NODE_DEVICES_CAP_NET VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI_HOST VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI_TARGET VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI VIR_CONNECT_LIST_NODE_DEVICES_CAP_STORAGE VIR_CONNECT_LIST_NODE_DEVICES_CAP_FC_HOST VIR_CONNECT_LIST_NODE_DEVICES_CAP_VPORTS VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI_GENERIC

virConnectListAllSecrets ()

int	virConnectListAllSecrets	(virConnectPtr conn, 
					 virSecretPtr ** secrets, 
					 unsigned int flags)

Collect the list of secrets, and allocate an array to store those objects. Normally, all secrets are returned; however, @flags can be used to filter the results for a smaller list of targeted secrets. The valid flags are divided into groups, where each group contains bits that describe mutually exclusive attributes of a secret, and where all bits within a group describe all possible secrets. The first group of @flags is used to filter secrets by its storage location. Flag VIR_CONNECT_LIST_SECRETS_EPHEMERAL selects secrets that are kept only in memory. Flag VIR_CONNECT_LIST_SECRETS_NO_EPHEMERAL selects secrets that are kept in persistent storage. The second group of @flags is used to filter secrets by privacy. Flag VIR_CONNECT_LIST_SECRETS_PRIVATE seclets secrets that are never revealed to any caller of libvirt nor to any other node. Flag VIR_CONNECT_LIST_SECRETS_NO_PRIVATE selects non-private secrets.

virConnectListAllStoragePools ()

int	virConnectListAllStoragePools	(virConnectPtr conn, 
					 virStoragePoolPtr ** pools, 
					 unsigned int flags)

Collect the list of storage pools, and allocate an array to store those objects. This API solves the race inherent between virConnectListStoragePools and virConnectListDefinedStoragePools. Normally, all storage pools are returned; however, @flags can be used to filter the results for a smaller list of targeted pools. The valid flags are divided into groups, where each group contains bits that describe mutually exclusive attributes of a pool, and where all bits within a group describe all possible pools. The first group of @flags is VIR_CONNECT_LIST_STORAGE_POOLS_ACTIVE (online) and VIR_CONNECT_LIST_STORAGE_POOLS_INACTIVE (offline) to filter the pools by state. The second group of @flags is VIR_CONNECT_LIST_STORAGE_POOLS_PERSITENT (defined) and VIR_CONNECT_LIST_STORAGE_POOLS_TRANSIENT (running but not defined), to filter the pools by whether they have persistent config or not. The third group of @flags is VIR_CONNECT_LIST_STORAGE_POOLS_AUTOSTART and VIR_CONNECT_LIST_STORAGE_POOLS_NO_AUTOSTART, to filter the pools by whether they are marked as autostart or not. The last group of @flags is provided to filter the pools by the types, the flags include: VIR_CONNECT_LIST_STORAGE_POOLS_DIR VIR_CONNECT_LIST_STORAGE_POOLS_FS VIR_CONNECT_LIST_STORAGE_POOLS_NETFS VIR_CONNECT_LIST_STORAGE_POOLS_LOGICAL VIR_CONNECT_LIST_STORAGE_POOLS_DISK VIR_CONNECT_LIST_STORAGE_POOLS_ISCSI VIR_CONNECT_LIST_STORAGE_POOLS_SCSI VIR_CONNECT_LIST_STORAGE_POOLS_MPATH VIR_CONNECT_LIST_STORAGE_POOLS_RBD VIR_CONNECT_LIST_STORAGE_POOLS_SHEEPDOG

virConnectListDefinedDomains ()

int	virConnectListDefinedDomains	(virConnectPtr conn, 
					 char ** const names, 
					 int maxnames)

list the defined but inactive domains, stores the pointers to the names in @names For active domains, see virConnectListDomains(). For more control over the results, see virConnectListAllDomains().

virConnectListDefinedInterfaces ()

int	virConnectListDefinedInterfaces	(virConnectPtr conn, 
					 char ** const names, 
					 int maxnames)

Collect the list of defined (inactive) physical host interfaces, and store their names in @names. For more control over the results, see virConnectListAllInterfaces().