[libvirt] [PATCH 10/12] Move virDomain related APIs out of libvirt.h.in

Create a new libvirt-domain.h file to hold the public API definitions for the virDomain type. This header file is not self-contained, so applications will not directly include it. They will contain to #include <libvirt/libvirt.h> --- cfg.mk | 2 +- docs/apibuild.py | 1 + include/libvirt/Makefile.am | 1 + include/libvirt/libvirt-domain.h | 3496 +++++++++++++++++++++++++++++++++++ include/libvirt/libvirt.h.in | 3731 ++------------------------------------ 5 files changed, 3632 insertions(+), 3599 deletions(-) create mode 100644 include/libvirt/libvirt-domain.h diff --git a/cfg.mk b/cfg.mk index c03fdab..501530f 100644 --- a/cfg.mk +++ b/cfg.mk @@ -303,7 +303,7 @@ sc_flags_debug: # than d). The existence of long long, and of documentation about # flags, makes the regex in the third test slightly harder. sc_flags_usage: - @test "$$(cat $(srcdir)/include/libvirt/libvirt.h.in \ + @test "$$(cat $(srcdir)/include/libvirt/libvirt-domain.h \ $(srcdir)/include/libvirt/virterror.h \ $(srcdir)/include/libvirt/libvirt-qemu.h \ $(srcdir)/include/libvirt/libvirt-lxc.h \ diff --git a/docs/apibuild.py b/docs/apibuild.py index e79ac42..bb93335 100755 --- a/docs/apibuild.py +++ b/docs/apibuild.py @@ -22,6 +22,7 @@ debugsym=None # included_files = { "libvirt.h": "header with general libvirt API definitions", + "libvirt-domain.h": "header with general libvirt API definitions", "libvirt-domain-snapshot.h": "header with general libvirt API definitions", "libvirt-event.h": "header with general libvirt API definitions", "libvirt-interface.h": "header with general libvirt API definitions", diff --git a/include/libvirt/Makefile.am b/include/libvirt/Makefile.am index 9b34539..ec5ebac 100644 --- a/include/libvirt/Makefile.am +++ b/include/libvirt/Makefile.am @@ -19,6 +19,7 @@ virincdir = $(includedir)/libvirt virinc_HEADERS = libvirt.h \ + libvirt-domain.h \ libvirt-domain-snapshot.h \ libvirt-event.h \ libvirt-interface.h \ diff --git a/include/libvirt/libvirt-domain.h b/include/libvirt/libvirt-domain.h new file mode 100644 index 0000000..b28d37d --- /dev/null +++ b/include/libvirt/libvirt-domain.h @@ -0,0 +1,3496 @@ +/* + * libvirt-domain.h + * Summary: APIs for management of domains + * Description: Provides APIs for the management of domains + * Author: Daniel Veillard <veillard(a)redhat.com&gt; + * + * Copyright (C) 2006-2014 Red Hat, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. If not, see + * <http://www.gnu.org/licenses/>;. + */ + +#ifndef __VIR_LIBVIRT_DOMAIN_H__ +# define __VIR_LIBVIRT_DOMAIN_H__ + +# ifndef __VIR_LIBVIRT_H_INCLUDES__ +# error "Don't include this file directly, only use libvirt/libvirt.h" +# endif + + +/** + * virDomain: + * + * a virDomain is a private structure representing a domain. + */ +typedef struct _virDomain virDomain; + +/** + * virDomainPtr: + * + * a virDomainPtr is pointer to a virDomain private structure, this is the + * type used to reference a domain in the API. + */ +typedef virDomain *virDomainPtr; + +/** + * virDomainState: + * + * A domain may be in different states at a given point in time + */ +typedef enum { + 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 */ + +# ifdef VIR_ENUM_SENTINELS + VIR_DOMAIN_LAST + /* + * 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. + */ +# endif +} virDomainState; + +typedef enum { + VIR_DOMAIN_NOSTATE_UNKNOWN = 0, + +# ifdef VIR_ENUM_SENTINELS + VIR_DOMAIN_NOSTATE_LAST +# endif +} virDomainNostateReason; + +typedef enum { + 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 */ + +# ifdef VIR_ENUM_SENTINELS + VIR_DOMAIN_RUNNING_LAST +# endif +} virDomainRunningReason; + +typedef enum { + VIR_DOMAIN_BLOCKED_UNKNOWN = 0, /* the reason is unknown */ + +# ifdef VIR_ENUM_SENTINELS + VIR_DOMAIN_BLOCKED_LAST +# endif +} virDomainBlockedReason; + +typedef enum { + 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 */ + +# ifdef VIR_ENUM_SENTINELS + VIR_DOMAIN_PAUSED_LAST +# endif +} virDomainPausedReason; + +typedef enum { + VIR_DOMAIN_SHUTDOWN_UNKNOWN = 0, /* the reason is unknown */ + VIR_DOMAIN_SHUTDOWN_USER = 1, /* shutting down on user request */ + +# ifdef VIR_ENUM_SENTINELS + VIR_DOMAIN_SHUTDOWN_LAST +# endif +} virDomainShutdownReason; + +typedef enum { + 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 */ +# ifdef VIR_ENUM_SENTINELS + VIR_DOMAIN_SHUTOFF_LAST +# endif +} virDomainShutoffReason; + +typedef enum { + VIR_DOMAIN_CRASHED_UNKNOWN = 0, /* crashed for unknown reason */ + VIR_DOMAIN_CRASHED_PANICKED = 1, /* domain panicked */ + +# ifdef VIR_ENUM_SENTINELS + VIR_DOMAIN_CRASHED_LAST +# endif +} virDomainCrashedReason; + +typedef enum { + VIR_DOMAIN_PMSUSPENDED_UNKNOWN = 0, + +# ifdef VIR_ENUM_SENTINELS + VIR_DOMAIN_PMSUSPENDED_LAST +# endif +} virDomainPMSuspendedReason; + +typedef enum { + VIR_DOMAIN_PMSUSPENDED_DISK_UNKNOWN = 0, + +# ifdef VIR_ENUM_SENTINELS + VIR_DOMAIN_PMSUSPENDED_DISK_LAST +# endif +} virDomainPMSuspendedDiskReason; + +/** + * virDomainControlState: + * + * Current state of a control interface to the domain. + */ +typedef enum { + 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 */ + +# ifdef VIR_ENUM_SENTINELS + VIR_DOMAIN_CONTROL_LAST +# endif +} virDomainControlState; + +/** + * virDomainControlInfo: + * + * Structure filled in by virDomainGetControlInfo and providing details about + * current state of control interface to a domain. + */ +typedef struct _virDomainControlInfo 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 (except for OK + and ERROR states) */ +}; + +/** + * virDomainControlInfoPtr: + * + * Pointer to virDomainControlInfo structure. + */ +typedef virDomainControlInfo *virDomainControlInfoPtr; + +/** + * virDomainModificationImpact: + * + * Several modification APIs take flags to determine whether a change + * to the domain affects just the running instance, just the + * persistent definition, or both at the same time. The counterpart + * query APIs also take the same flags to determine whether to query + * the running instance or persistent definition, although both cannot + * be queried at once. + * + * The use of VIR_DOMAIN_AFFECT_CURRENT will resolve to either + * VIR_DOMAIN_AFFECT_LIVE or VIR_DOMAIN_AFFECT_CONFIG according to + * current domain state. VIR_DOMAIN_AFFECT_LIVE requires a running + * domain, and VIR_DOMAIN_AFFECT_CONFIG requires a persistent domain + * (whether or not it is running). + * + * These enums should not conflict with those of virTypedParameterFlags. + */ +typedef enum { + VIR_DOMAIN_AFFECT_CURRENT = 0, /* Affect current domain state. */ + VIR_DOMAIN_AFFECT_LIVE = 1 << 0, /* Affect running domain state. */ + VIR_DOMAIN_AFFECT_CONFIG = 1 << 1, /* Affect persistent domain state. */ + /* 1 << 2 is reserved for virTypedParameterFlags */ +} virDomainModificationImpact; + +/** + * virDomainInfoPtr: + * + * a virDomainInfo is a structure filled by virDomainGetInfo() and extracting + * runtime information for a given active Domain + */ + +typedef struct _virDomainInfo 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 */ +}; + +/** + * virDomainInfoPtr: + * + * a virDomainInfoPtr is a pointer to a virDomainInfo structure. + */ + +typedef virDomainInfo *virDomainInfoPtr; + +/** + * virDomainCreateFlags: + * + * Flags OR'ed together to provide specific behaviour when creating a + * Domain. + */ +typedef enum { + VIR_DOMAIN_NONE = 0, /* Default behavior */ + VIR_DOMAIN_START_PAUSED = 1 << 0, /* Launch guest in paused state */ + VIR_DOMAIN_START_AUTODESTROY = 1 << 1, /* Automatically kill guest when virConnectPtr is closed */ + VIR_DOMAIN_START_BYPASS_CACHE = 1 << 2, /* Avoid file system cache pollution */ + VIR_DOMAIN_START_FORCE_BOOT = 1 << 3, /* Boot, discarding any managed save */ +} virDomainCreateFlags; + + +/* Management of scheduler parameters */ + +/** + * 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. + */ +# define VIR_DOMAIN_SCHEDULER_CPU_SHARES "cpu_shares" + +/** + * 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. + */ +# define VIR_DOMAIN_SCHEDULER_VCPU_PERIOD "vcpu_period" + +/** + * 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. + */ +# define VIR_DOMAIN_SCHEDULER_VCPU_QUOTA "vcpu_quota" + +/** + * 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. + */ +# define VIR_DOMAIN_SCHEDULER_EMULATOR_PERIOD "emulator_period" + +/** + * 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. + */ +# define VIR_DOMAIN_SCHEDULER_EMULATOR_QUOTA "emulator_quota" + +/** + * VIR_DOMAIN_SCHEDULER_WEIGHT: + * + * Macro represents the relative weight, when using the credit + * scheduler, as a uint. + */ +# define VIR_DOMAIN_SCHEDULER_WEIGHT "weight" + +/** + * VIR_DOMAIN_SCHEDULER_CAP: + * + * Macro represents the maximum scheduler cap, when using the credit + * scheduler, as a uint. + */ +# define VIR_DOMAIN_SCHEDULER_CAP "cap" + +/** + * VIR_DOMAIN_SCHEDULER_RESERVATION: + * + * Macro represents the scheduler reservation value, when using the + * allocation scheduler, as an llong. + */ +# define VIR_DOMAIN_SCHEDULER_RESERVATION "reservation" + +/** + * VIR_DOMAIN_SCHEDULER_LIMIT: + * + * Macro represents the scheduler limit value, when using the + * allocation scheduler, as an llong. + */ +# define VIR_DOMAIN_SCHEDULER_LIMIT "limit" + +/** + * VIR_DOMAIN_SCHEDULER_SHARES: + * + * Macro represents the scheduler shares value, when using the + * allocation scheduler, as an int. + */ +# define VIR_DOMAIN_SCHEDULER_SHARES "shares" + +/* + * Fetch scheduler parameters, caller allocates 'params' field of size 'nparams' + */ +int virDomainGetSchedulerParameters (virDomainPtr domain, + virTypedParameterPtr params, + int *nparams); +int virDomainGetSchedulerParametersFlags (virDomainPtr domain, + virTypedParameterPtr params, + int *nparams, + unsigned int flags); + +/* + * Change scheduler parameters + */ +int virDomainSetSchedulerParameters (virDomainPtr domain, + virTypedParameterPtr params, + int nparams); +int virDomainSetSchedulerParametersFlags (virDomainPtr domain, + virTypedParameterPtr params, + int nparams, + unsigned int flags); + +/** + * virDomainBlockStats: + * + * Block device stats for virDomainBlockStats. + * + * Hypervisors may return a field set to ((long long)-1) which indicates + * that the hypervisor does not support that statistic. + * + * NB. Here 'long long' means 64 bit integer. + */ +typedef struct _virDomainBlockStats 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'. */ +}; + +/** + * virDomainBlockStatsPtr: + * + * A pointer to a virDomainBlockStats structure + */ +typedef virDomainBlockStatsStruct *virDomainBlockStatsPtr; + + +/** + * VIR_DOMAIN_BLOCK_STATS_FIELD_LENGTH: + * + * Macro providing the field length of parameter names when using + * virDomainBlockStatsFlags(). + */ +# define VIR_DOMAIN_BLOCK_STATS_FIELD_LENGTH VIR_TYPED_PARAM_FIELD_LENGTH + +/** + * VIR_DOMAIN_BLOCK_STATS_READ_BYTES: + * + * Macro represents the total number of read bytes of the + * block device, as an llong. + */ +# define VIR_DOMAIN_BLOCK_STATS_READ_BYTES "rd_bytes" + +/** + * VIR_DOMAIN_BLOCK_STATS_READ_REQ: + * + * Macro represents the total read requests of the + * block device, as an llong. + */ +# define VIR_DOMAIN_BLOCK_STATS_READ_REQ "rd_operations" + +/** + * 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. + */ +# define VIR_DOMAIN_BLOCK_STATS_READ_TOTAL_TIMES "rd_total_times" + +/** + * VIR_DOMAIN_BLOCK_STATS_WRITE_BYTES: + * + * Macro represents the total number of write bytes of the + * block device, as an llong. + */ +# define VIR_DOMAIN_BLOCK_STATS_WRITE_BYTES "wr_bytes" + +/** + * VIR_DOMAIN_BLOCK_STATS_WRITE_REQ: + * + * Macro represents the total write requests of the + * block device, as an llong. + */ +# define VIR_DOMAIN_BLOCK_STATS_WRITE_REQ "wr_operations" + +/** + * 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. + */ +# define VIR_DOMAIN_BLOCK_STATS_WRITE_TOTAL_TIMES "wr_total_times" + +/** + * VIR_DOMAIN_BLOCK_STATS_FLUSH_REQ: + * + * Macro represents the total flush requests of the + * block device, as an llong. + */ +# define VIR_DOMAIN_BLOCK_STATS_FLUSH_REQ "flush_operations" + +/** + * 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. + */ +# define VIR_DOMAIN_BLOCK_STATS_FLUSH_TOTAL_TIMES "flush_total_times" + +/** + * VIR_DOMAIN_BLOCK_STATS_ERRS: + * + * In Xen this returns the mysterious 'oo_req', as an llong. + */ +# define VIR_DOMAIN_BLOCK_STATS_ERRS "errs" + +/** + * virDomainInterfaceStats: + * + * Network interface stats for virDomainInterfaceStats. + * + * Hypervisors may return a field set to ((long long)-1) which indicates + * that the hypervisor does not support that statistic. + * + * NB. Here 'long long' means 64 bit integer. + */ +typedef struct _virDomainInterfaceStats 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; +}; + +/** + * virDomainInterfaceStatsPtr: + * + * A pointer to a virDomainInterfaceStats structure + */ +typedef virDomainInterfaceStatsStruct *virDomainInterfaceStatsPtr; + +/** + * Memory Statistics Tags: + */ +typedef enum { + /* The total amount of data read from swap space (in kB). */ + 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, + +# ifdef VIR_ENUM_SENTINELS + VIR_DOMAIN_MEMORY_STAT_LAST = VIR_DOMAIN_MEMORY_STAT_NR +# endif +} virDomainMemoryStatTags; + +typedef struct _virDomainMemoryStat virDomainMemoryStatStruct; + +struct _virDomainMemoryStat { + int tag; + unsigned long long val; +}; + +typedef virDomainMemoryStatStruct *virDomainMemoryStatPtr; + + +/* Domain core dump flags. */ +typedef enum { + VIR_DUMP_CRASH = (1 << 0), /* crash after dump */ + VIR_DUMP_LIVE = (1 << 1), /* live dump */ + VIR_DUMP_BYPASS_CACHE = (1 << 2), /* avoid file system cache pollution */ + VIR_DUMP_RESET = (1 << 3), /* reset domain after dump finishes */ + VIR_DUMP_MEMORY_ONLY = (1 << 4), /* use dump-guest-memory */ +} virDomainCoreDumpFlags; + +/** + * virDomainCoreDumpFormat: + * + * Values for specifying different formats of domain core dumps. + */ +typedef enum { + VIR_DOMAIN_CORE_DUMP_FORMAT_RAW, /* dump guest memory in raw format */ + VIR_DOMAIN_CORE_DUMP_FORMAT_KDUMP_ZLIB, /* kdump-compressed format, with + * zlib compression */ + VIR_DOMAIN_CORE_DUMP_FORMAT_KDUMP_LZO, /* kdump-compressed format, with + * lzo compression */ + VIR_DOMAIN_CORE_DUMP_FORMAT_KDUMP_SNAPPY, /* kdump-compressed format, with + * snappy compression */ +# ifdef VIR_ENUM_SENTINELS + VIR_DOMAIN_CORE_DUMP_FORMAT_LAST + /* + * 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. + */ +# endif +} virDomainCoreDumpFormat; + +/* Domain migration flags. */ +typedef enum { + VIR_MIGRATE_LIVE = (1 << 0), /* live migration */ + VIR_MIGRATE_PEER2PEER = (1 << 1), /* 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 = (1 << 2), /* tunnel migration data over libvirtd connection */ + VIR_MIGRATE_PERSIST_DEST = (1 << 3), /* persist the VM on the destination */ + VIR_MIGRATE_UNDEFINE_SOURCE = (1 << 4), /* undefine the VM on the source */ + VIR_MIGRATE_PAUSED = (1 << 5), /* pause on remote side */ + VIR_MIGRATE_NON_SHARED_DISK = (1 << 6), /* migration with non-shared storage with full disk copy */ + VIR_MIGRATE_NON_SHARED_INC = (1 << 7), /* migration with non-shared storage with incremental copy */ + /* (same base image shared between source and destination) */ + VIR_MIGRATE_CHANGE_PROTECTION = (1 << 8), /* protect for changing domain configuration through the + * whole migration process; this will be used automatically + * when supported */ + VIR_MIGRATE_UNSAFE = (1 << 9), /* force migration even if it is considered unsafe */ + VIR_MIGRATE_OFFLINE = (1 << 10), /* offline migrate */ + VIR_MIGRATE_COMPRESSED = (1 << 11), /* compress data during migration */ + VIR_MIGRATE_ABORT_ON_ERROR = (1 << 12), /* abort migration on I/O errors happened during migration */ + VIR_MIGRATE_AUTO_CONVERGE = (1 << 13), /* force convergence */ + VIR_MIGRATE_RDMA_PIN_ALL = (1 << 14), /* RDMA memory pinning */ +} virDomainMigrateFlags; + + +/** + * 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. + */ +# define VIR_MIGRATE_PARAM_URI "migrate_uri" + +/** + * 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. + */ +# define VIR_MIGRATE_PARAM_DEST_NAME "destination_name" + +/** + * 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. + */ +# define VIR_MIGRATE_PARAM_DEST_XML "destination_xml" + +/** + * 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. + */ +# define VIR_MIGRATE_PARAM_BANDWIDTH "bandwidth" + +/** + * 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 + */ +# define VIR_MIGRATE_PARAM_GRAPHICS_URI "graphics_uri" + +/** + * 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. + */ +# define VIR_MIGRATE_PARAM_LISTEN_ADDRESS "listen_address" + +/* Domain migration. */ +virDomainPtr virDomainMigrate (virDomainPtr domain, virConnectPtr dconn, + unsigned long flags, const char *dname, + const char *uri, unsigned long bandwidth); +virDomainPtr virDomainMigrate2(virDomainPtr domain, virConnectPtr dconn, + const char *dxml, + unsigned long flags, const char *dname, + const char *uri, unsigned long bandwidth); +virDomainPtr virDomainMigrate3(virDomainPtr domain, + virConnectPtr dconn, + virTypedParameterPtr params, + unsigned int nparams, + unsigned int flags); + +int virDomainMigrateToURI (virDomainPtr domain, const char *duri, + unsigned long flags, const char *dname, + unsigned long bandwidth); + +int virDomainMigrateToURI2(virDomainPtr domain, + const char *dconnuri, + const char *miguri, + const char *dxml, + unsigned long flags, + const char *dname, + unsigned long bandwidth); +int virDomainMigrateToURI3(virDomainPtr domain, + const char *dconnuri, + virTypedParameterPtr params, + unsigned int nparams, + unsigned int flags); + +int virDomainMigrateSetMaxDowntime (virDomainPtr domain, + unsigned long long downtime, + unsigned int flags); + +int virDomainMigrateGetCompressionCache(virDomainPtr domain, + unsigned long long *cacheSize, + unsigned int flags); +int virDomainMigrateSetCompressionCache(virDomainPtr domain, + unsigned long long cacheSize, + unsigned int flags); + +int virDomainMigrateSetMaxSpeed(virDomainPtr domain, + unsigned long bandwidth, + unsigned int flags); + +int virDomainMigrateGetMaxSpeed(virDomainPtr domain, + unsigned long *bandwidth, + unsigned int flags); + +char * virConnectGetDomainCapabilities(virConnectPtr conn, + const char *emulatorbin, + const char *arch, + const char *machine, + const char *virttype, + unsigned int flags); + +/* + * Gather list of running domains + */ +int virConnectListDomains (virConnectPtr conn, + int *ids, + int maxids); + +/* + * Number of domains + */ +int virConnectNumOfDomains (virConnectPtr conn); + + +/* + * Get connection from domain. + */ +virConnectPtr virDomainGetConnect (virDomainPtr domain); + +/* + * Domain creation and destruction + */ + +virDomainPtr virDomainCreateXML (virConnectPtr conn, + const char *xmlDesc, + unsigned int flags); +virDomainPtr virDomainCreateXMLWithFiles(virConnectPtr conn, + const char *xmlDesc, + unsigned int nfiles, + int *files, + unsigned int flags); +virDomainPtr virDomainLookupByName (virConnectPtr conn, + const char *name); +virDomainPtr virDomainLookupByID (virConnectPtr conn, + int id); +virDomainPtr virDomainLookupByUUID (virConnectPtr conn, + const unsigned char *uuid); +virDomainPtr virDomainLookupByUUIDString (virConnectPtr conn, + const char *uuid); + +typedef enum { + VIR_DOMAIN_SHUTDOWN_DEFAULT = 0, /* hypervisor choice */ + VIR_DOMAIN_SHUTDOWN_ACPI_POWER_BTN = (1 << 0), /* Send ACPI event */ + VIR_DOMAIN_SHUTDOWN_GUEST_AGENT = (1 << 1), /* Use guest agent */ + VIR_DOMAIN_SHUTDOWN_INITCTL = (1 << 2), /* Use initctl */ + VIR_DOMAIN_SHUTDOWN_SIGNAL = (1 << 3), /* Send a signal */ + VIR_DOMAIN_SHUTDOWN_PARAVIRT = (1 << 4), /* Use paravirt guest control */ +} virDomainShutdownFlagValues; + +int virDomainShutdown (virDomainPtr domain); +int virDomainShutdownFlags (virDomainPtr domain, + unsigned int flags); + +typedef enum { + VIR_DOMAIN_REBOOT_DEFAULT = 0, /* hypervisor choice */ + VIR_DOMAIN_REBOOT_ACPI_POWER_BTN = (1 << 0), /* Send ACPI event */ + VIR_DOMAIN_REBOOT_GUEST_AGENT = (1 << 1), /* Use guest agent */ + VIR_DOMAIN_REBOOT_INITCTL = (1 << 2), /* Use initctl */ + VIR_DOMAIN_REBOOT_SIGNAL = (1 << 3), /* Send a signal */ + VIR_DOMAIN_REBOOT_PARAVIRT = (1 << 4), /* Use paravirt guest control */ +} virDomainRebootFlagValues; + +int virDomainReboot (virDomainPtr domain, + unsigned int flags); +int virDomainReset (virDomainPtr domain, + unsigned int flags); + +int virDomainDestroy (virDomainPtr domain); + +/** + * virDomainDestroyFlagsValues: + * + * Flags used to provide specific behaviour to the + * virDomainDestroyFlags() function + */ +typedef enum { + VIR_DOMAIN_DESTROY_DEFAULT = 0, /* Default behavior - could lead to data loss!! */ + VIR_DOMAIN_DESTROY_GRACEFUL = 1 << 0, /* only SIGTERM, no SIGKILL */ +} virDomainDestroyFlagsValues; + +int virDomainDestroyFlags (virDomainPtr domain, + unsigned int flags); +int virDomainRef (virDomainPtr domain); +int virDomainFree (virDomainPtr domain); + +/* + * Domain suspend/resume + */ +int virDomainSuspend (virDomainPtr domain); +int virDomainResume (virDomainPtr domain); +int virDomainPMSuspendForDuration (virDomainPtr domain, + unsigned int target, + unsigned long long duration, + unsigned int flags); +int virDomainPMWakeup (virDomainPtr domain, + unsigned int flags); +/* + * Domain save/restore + */ + +/** + * virDomainSaveRestoreFlags: + * Flags for use in virDomainSaveFlags(), virDomainManagedSave(), + * virDomainRestoreFlags(), and virDomainSaveImageDefineXML(). Not all + * flags apply to all these functions. + */ +typedef enum { + VIR_DOMAIN_SAVE_BYPASS_CACHE = 1 << 0, /* Avoid file system cache pollution */ + VIR_DOMAIN_SAVE_RUNNING = 1 << 1, /* Favor running over paused */ + VIR_DOMAIN_SAVE_PAUSED = 1 << 2, /* Favor paused over running */ +} virDomainSaveRestoreFlags; + +int virDomainSave (virDomainPtr domain, + const char *to); +int virDomainSaveFlags (virDomainPtr domain, + const char *to, + const char *dxml, + unsigned int flags); +int virDomainRestore (virConnectPtr conn, + const char *from); +int virDomainRestoreFlags (virConnectPtr conn, + const char *from, + const char *dxml, + unsigned int flags); + +char * virDomainSaveImageGetXMLDesc (virConnectPtr conn, + const char *file, + unsigned int flags); +int virDomainSaveImageDefineXML (virConnectPtr conn, + const char *file, + const char *dxml, + unsigned int flags); + +/* + * Managed domain save + */ +int virDomainManagedSave (virDomainPtr dom, + unsigned int flags); +int virDomainHasManagedSaveImage(virDomainPtr dom, + unsigned int flags); +int virDomainManagedSaveRemove(virDomainPtr dom, + unsigned int flags); + +/* + * Domain core dump + */ +int virDomainCoreDump (virDomainPtr domain, + const char *to, + unsigned int flags); + +/* + * Domain core dump with format specified + */ +int virDomainCoreDumpWithFormat (virDomainPtr domain, + const char *to, + unsigned int dumpformat, + unsigned int flags); + +/* + * Screenshot of current domain console + */ +char * virDomainScreenshot (virDomainPtr domain, + virStreamPtr stream, + unsigned int screen, + unsigned int flags); + +/* + * Domain runtime information, and collecting CPU statistics + */ + +int virDomainGetInfo (virDomainPtr domain, + virDomainInfoPtr info); +int virDomainGetState (virDomainPtr domain, + int *state, + int *reason, + unsigned int flags); + +/** + * VIR_DOMAIN_CPU_STATS_CPUTIME: + * cpu usage (sum of both vcpu and hypervisor usage) in nanoseconds, + * as a ullong + */ +# define VIR_DOMAIN_CPU_STATS_CPUTIME "cpu_time" + +/** + * VIR_DOMAIN_CPU_STATS_USERTIME: + * cpu time charged to user instructions in nanoseconds, as a ullong + */ +# define VIR_DOMAIN_CPU_STATS_USERTIME "user_time" + +/** + * VIR_DOMAIN_CPU_STATS_SYSTEMTIME: + * cpu time charged to system instructions in nanoseconds, as a ullong + */ +# define VIR_DOMAIN_CPU_STATS_SYSTEMTIME "system_time" + +/** + * VIR_DOMAIN_CPU_STATS_VCPUTIME: + * vcpu usage in nanoseconds (cpu_time excluding hypervisor time), + * as a ullong + */ +# define VIR_DOMAIN_CPU_STATS_VCPUTIME "vcpu_time" + +int virDomainGetCPUStats(virDomainPtr domain, + virTypedParameterPtr params, + unsigned int nparams, + int start_cpu, + unsigned int ncpus, + unsigned int flags); + +int virDomainGetControlInfo (virDomainPtr domain, + virDomainControlInfoPtr info, + unsigned int flags); + +/* + * Return scheduler type in effect 'sedf', 'credit', 'linux' + */ +char * virDomainGetSchedulerType(virDomainPtr domain, + int *nparams); + + +/* Manage blkio parameters. */ + +/** + * VIR_DOMAIN_BLKIO_WEIGHT: + * + * Macro for the Blkio tunable weight: it represents the io weight + * the guest can use, as a uint. + */ + +# define VIR_DOMAIN_BLKIO_WEIGHT "weight" + +/** + * 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 ','. + */ + +# define VIR_DOMAIN_BLKIO_DEVICE_WEIGHT "device_weight" + +/** + * 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 ','. + */ + +# define VIR_DOMAIN_BLKIO_DEVICE_READ_IOPS "device_read_iops_sec" + + +/** + * 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 ','. + */ +# define VIR_DOMAIN_BLKIO_DEVICE_WRITE_IOPS "device_write_iops_sec" + + +/** + * 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 ','. + */ +# define VIR_DOMAIN_BLKIO_DEVICE_READ_BPS "device_read_bytes_sec" + + +/** + * 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 ','. + */ +# define VIR_DOMAIN_BLKIO_DEVICE_WRITE_BPS "device_write_bytes_sec" + + +/* Set Blkio tunables for the domain*/ +int virDomainSetBlkioParameters(virDomainPtr domain, + virTypedParameterPtr params, + int nparams, unsigned int flags); +int virDomainGetBlkioParameters(virDomainPtr domain, + virTypedParameterPtr params, + int *nparams, unsigned int flags); + +/* Manage memory parameters. */ + +/** + * VIR_DOMAIN_MEMORY_PARAM_UNLIMITED: + * + * Macro providing the virMemoryParameter value that indicates "unlimited" + */ + +# define VIR_DOMAIN_MEMORY_PARAM_UNLIMITED 9007199254740991LL /* = INT64_MAX >> 10 */ + +/** + * VIR_DOMAIN_MEMORY_HARD_LIMIT: + * + * Macro for the memory tunable hard_limit: it represents the maximum memory + * the guest can use, as a ullong. + */ + +# define VIR_DOMAIN_MEMORY_HARD_LIMIT "hard_limit" + +/** + * 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. + */ + +# define VIR_DOMAIN_MEMORY_SOFT_LIMIT "soft_limit" + +/** + * 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. + */ + +# define VIR_DOMAIN_MEMORY_MIN_GUARANTEE "min_guarantee" + +/** + * 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. + */ + +# define VIR_DOMAIN_MEMORY_SWAP_HARD_LIMIT "swap_hard_limit" + +/* Set memory tunables for the domain*/ +int virDomainSetMemoryParameters(virDomainPtr domain, + virTypedParameterPtr params, + int nparams, unsigned int flags); +int virDomainGetMemoryParameters(virDomainPtr domain, + virTypedParameterPtr params, + int *nparams, unsigned int flags); + +/* Memory size modification flags. */ +typedef enum { + /* See virDomainModificationImpact for these flags. */ + VIR_DOMAIN_MEM_CURRENT = VIR_DOMAIN_AFFECT_CURRENT, + VIR_DOMAIN_MEM_LIVE = VIR_DOMAIN_AFFECT_LIVE, + VIR_DOMAIN_MEM_CONFIG = VIR_DOMAIN_AFFECT_CONFIG, + + /* Additionally, these flags may be bitwise-OR'd in. */ + VIR_DOMAIN_MEM_MAXIMUM = (1 << 2), /* affect Max rather than current */ +} virDomainMemoryModFlags; + + +/* Manage numa parameters */ + +/** + * virDomainNumatuneMemMode: + * Representation of the various modes in the <numatune> element of + * a domain. + */ +typedef enum { + VIR_DOMAIN_NUMATUNE_MEM_STRICT = 0, + VIR_DOMAIN_NUMATUNE_MEM_PREFERRED = 1, + VIR_DOMAIN_NUMATUNE_MEM_INTERLEAVE = 2, + +# ifdef VIR_ENUM_SENTINELS + VIR_DOMAIN_NUMATUNE_MEM_LAST /* This constant is subject to change */ +# endif +} virDomainNumatuneMemMode; + +/** + * VIR_DOMAIN_NUMA_NODESET: + * + * Macro for typed parameter name that lists the numa nodeset of a + * domain, as a string. + */ +# define VIR_DOMAIN_NUMA_NODESET "numa_nodeset" + +/** + * VIR_DOMAIN_NUMA_MODE: + * + * Macro for typed parameter name that lists the numa mode of a domain, + * as an int containing a virDomainNumatuneMemMode value. + */ +# define VIR_DOMAIN_NUMA_MODE "numa_mode" + +int virDomainSetNumaParameters(virDomainPtr domain, + virTypedParameterPtr params, + int nparams, unsigned int flags); +int virDomainGetNumaParameters(virDomainPtr domain, + virTypedParameterPtr params, + int *nparams, unsigned int flags); + +/* + * Dynamic control of domains + */ +const char * virDomainGetName (virDomainPtr domain); +unsigned int virDomainGetID (virDomainPtr domain); +int virDomainGetUUID (virDomainPtr domain, + unsigned char *uuid); +int virDomainGetUUIDString (virDomainPtr domain, + char *buf); +char * virDomainGetOSType (virDomainPtr domain); +unsigned long virDomainGetMaxMemory (virDomainPtr domain); +int virDomainSetMaxMemory (virDomainPtr domain, + unsigned long memory); +int virDomainSetMemory (virDomainPtr domain, + unsigned long memory); +int virDomainSetMemoryFlags (virDomainPtr domain, + unsigned long memory, + unsigned int flags); +int virDomainSetMemoryStatsPeriod (virDomainPtr domain, + int period, + unsigned int flags); +int virDomainGetMaxVcpus (virDomainPtr domain); +int virDomainGetSecurityLabel (virDomainPtr domain, + virSecurityLabelPtr seclabel); +char * virDomainGetHostname (virDomainPtr domain, + unsigned int flags); +int virDomainGetSecurityLabelList (virDomainPtr domain, + virSecurityLabelPtr* seclabels); + +typedef enum { + VIR_DOMAIN_METADATA_DESCRIPTION = 0, /* Operate on <description> */ + VIR_DOMAIN_METADATA_TITLE = 1, /* Operate on <title> */ + VIR_DOMAIN_METADATA_ELEMENT = 2, /* Operate on <metadata> */ + +# ifdef VIR_ENUM_SENTINELS + VIR_DOMAIN_METADATA_LAST +# endif +} virDomainMetadataType; + +int +virDomainSetMetadata(virDomainPtr domain, + int type, + const char *metadata, + const char *key, + const char *uri, + unsigned int flags); + +char * +virDomainGetMetadata(virDomainPtr domain, + int type, + const char *uri, + unsigned int flags); + +/* + * XML domain description + */ +/** + * virDomainXMLFlags: + * + * Flags available for virDomainGetXMLDesc + */ + +typedef enum { + VIR_DOMAIN_XML_SECURE = (1 << 0), /* dump security sensitive information too */ + VIR_DOMAIN_XML_INACTIVE = (1 << 1), /* dump inactive domain information */ + VIR_DOMAIN_XML_UPDATE_CPU = (1 << 2), /* update guest CPU requirements according to host CPU */ + VIR_DOMAIN_XML_MIGRATABLE = (1 << 3), /* dump XML suitable for migration */ +} virDomainXMLFlags; + +char * virDomainGetXMLDesc (virDomainPtr domain, + unsigned int flags); + + +char * virConnectDomainXMLFromNative(virConnectPtr conn, + const char *nativeFormat, + const char *nativeConfig, + unsigned int flags); +char * virConnectDomainXMLToNative(virConnectPtr conn, + const char *nativeFormat, + const char *domainXml, + unsigned int flags); + +int virDomainBlockStats (virDomainPtr dom, + const char *disk, + virDomainBlockStatsPtr stats, + size_t size); +int virDomainBlockStatsFlags (virDomainPtr dom, + const char *disk, + virTypedParameterPtr params, + int *nparams, + unsigned int flags); +int virDomainInterfaceStats (virDomainPtr dom, + const char *path, + virDomainInterfaceStatsPtr stats, + size_t size); + +/* Management of interface parameters */ + +/** + * VIR_DOMAIN_BANDWIDTH_IN_AVERAGE: + * + * Macro represents the inbound average of NIC bandwidth, as a uint. + */ +# define VIR_DOMAIN_BANDWIDTH_IN_AVERAGE "inbound.average" + +/** + * VIR_DOMAIN_BANDWIDTH_IN_PEAK: + * + * Macro represents the inbound peak of NIC bandwidth, as a uint. + */ +# define VIR_DOMAIN_BANDWIDTH_IN_PEAK "inbound.peak" + +/** + * VIR_DOMAIN_BANDWIDTH_IN_BURST: + * + * Macro represents the inbound burst of NIC bandwidth, as a uint. + */ +# define VIR_DOMAIN_BANDWIDTH_IN_BURST "inbound.burst" + +/** + * VIR_DOMAIN_BANDWIDTH_OUT_AVERAGE: + * + * Macro represents the outbound average of NIC bandwidth, as a uint. + */ +# define VIR_DOMAIN_BANDWIDTH_OUT_AVERAGE "outbound.average" + +/** + * VIR_DOMAIN_BANDWIDTH_OUT_PEAK: + * + * Macro represents the outbound peak of NIC bandwidth, as a uint. + */ +# define VIR_DOMAIN_BANDWIDTH_OUT_PEAK "outbound.peak" + +/** + * VIR_DOMAIN_BANDWIDTH_OUT_BURST: + * + * Macro represents the outbound burst of NIC bandwidth, as a uint. + */ +# define VIR_DOMAIN_BANDWIDTH_OUT_BURST "outbound.burst" + +int virDomainSetInterfaceParameters (virDomainPtr dom, + const char *device, + virTypedParameterPtr params, + int nparams, unsigned int flags); +int virDomainGetInterfaceParameters (virDomainPtr dom, + const char *device, + virTypedParameterPtr params, + int *nparams, unsigned int flags); + +/* Management of domain block devices */ + +int virDomainBlockPeek (virDomainPtr dom, + const char *disk, + unsigned long long offset, + size_t size, + void *buffer, + unsigned int flags); + +/** + * virDomainBlockResizeFlags: + * + * Flags available for virDomainBlockResize(). + */ +typedef enum { + VIR_DOMAIN_BLOCK_RESIZE_BYTES = 1 << 0, /* size in bytes instead of KiB */ +} virDomainBlockResizeFlags; + +int virDomainBlockResize (virDomainPtr dom, + const char *disk, + unsigned long long size, + unsigned int flags); + +/** virDomainBlockInfo: + * + * This struct provides information about the size of a block device + * backing store + * + * Examples: + * + * - Fully allocated raw file in filesystem: + * * capacity, allocation, physical: All the same + * + * - Sparse raw file in filesystem: + * * capacity: logical size of the file + * * allocation, physical: number of blocks allocated to file + * + * - qcow2 file in filesystem + * * capacity: logical size from qcow2 header + * * allocation, physical: logical size of the file / + * highest qcow extent (identical) + * + * - qcow2 file in a block device + * * capacity: logical size from qcow2 header + * * allocation: highest qcow extent written for an active domain + * * physical: size of the block device container + */ +typedef struct _virDomainBlockInfo virDomainBlockInfo; +typedef virDomainBlockInfo *virDomainBlockInfoPtr; +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 */ +}; + +int virDomainGetBlockInfo(virDomainPtr dom, + const char *disk, + virDomainBlockInfoPtr info, + unsigned int flags); + +/* Management of domain memory */ + +int virDomainMemoryStats (virDomainPtr dom, + virDomainMemoryStatPtr stats, + unsigned int nr_stats, + unsigned int flags); + +/* Memory peeking flags. */ + +typedef enum { + VIR_MEMORY_VIRTUAL = 1 << 0, /* addresses are virtual addresses */ + VIR_MEMORY_PHYSICAL = 1 << 1, /* addresses are physical addresses */ +} virDomainMemoryFlags; + +int virDomainMemoryPeek (virDomainPtr dom, + unsigned long long start, + size_t size, + void *buffer, + unsigned int flags); + +/* + * defined but not running domains + */ +virDomainPtr virDomainDefineXML (virConnectPtr conn, + const char *xml); +int virDomainUndefine (virDomainPtr domain); + +typedef enum { + VIR_DOMAIN_UNDEFINE_MANAGED_SAVE = (1 << 0), /* Also remove any + managed save */ + VIR_DOMAIN_UNDEFINE_SNAPSHOTS_METADATA = (1 << 1), /* If last use of domain, + then also remove any + snapshot metadata */ + VIR_DOMAIN_UNDEFINE_NVRAM = (1 << 2), /* Also remove any + nvram file */ + + /* Future undefine control flags should come here. */ +} virDomainUndefineFlagsValues; + + +int virDomainUndefineFlags (virDomainPtr domain, + unsigned int flags); +int virConnectNumOfDefinedDomains (virConnectPtr conn); +int virConnectListDefinedDomains (virConnectPtr conn, + char **const names, + int maxnames); +/** + * virConnectListAllDomainsFlags: + * + * Flags used to tune which domains are listed by virConnectListAllDomains(). + * Note that these flags come in groups; if all bits from a group are 0, + * then that group is not used to filter results. + */ +typedef enum { + VIR_CONNECT_LIST_DOMAINS_ACTIVE = 1 << 0, + VIR_CONNECT_LIST_DOMAINS_INACTIVE = 1 << 1, + + VIR_CONNECT_LIST_DOMAINS_PERSISTENT = 1 << 2, + VIR_CONNECT_LIST_DOMAINS_TRANSIENT = 1 << 3, + + VIR_CONNECT_LIST_DOMAINS_RUNNING = 1 << 4, + VIR_CONNECT_LIST_DOMAINS_PAUSED = 1 << 5, + VIR_CONNECT_LIST_DOMAINS_SHUTOFF = 1 << 6, + VIR_CONNECT_LIST_DOMAINS_OTHER = 1 << 7, + + VIR_CONNECT_LIST_DOMAINS_MANAGEDSAVE = 1 << 8, + VIR_CONNECT_LIST_DOMAINS_NO_MANAGEDSAVE = 1 << 9, + + VIR_CONNECT_LIST_DOMAINS_AUTOSTART = 1 << 10, + VIR_CONNECT_LIST_DOMAINS_NO_AUTOSTART = 1 << 11, + + VIR_CONNECT_LIST_DOMAINS_HAS_SNAPSHOT = 1 << 12, + VIR_CONNECT_LIST_DOMAINS_NO_SNAPSHOT = 1 << 13, +} virConnectListAllDomainsFlags; + +int virConnectListAllDomains (virConnectPtr conn, + virDomainPtr **domains, + unsigned int flags); +int virDomainCreate (virDomainPtr domain); +int virDomainCreateWithFlags (virDomainPtr domain, + unsigned int flags); + +int virDomainCreateWithFiles (virDomainPtr domain, + unsigned int nfiles, + int *files, + unsigned int flags); + +int virDomainGetAutostart (virDomainPtr domain, + int *autostart); +int virDomainSetAutostart (virDomainPtr domain, + int autostart); + +/** + * virVcpuInfo: structure for information about a virtual CPU in a domain. + */ + +typedef enum { + 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 */ + +# ifdef VIR_ENUM_SENTINELS + VIR_VCPU_LAST +# endif +} virVcpuState; + +typedef struct _virVcpuInfo 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 */ +}; +typedef virVcpuInfo *virVcpuInfoPtr; + +/* Flags for controlling virtual CPU hot-plugging. */ +typedef enum { + /* See virDomainModificationImpact for these flags. */ + VIR_DOMAIN_VCPU_CURRENT = VIR_DOMAIN_AFFECT_CURRENT, + VIR_DOMAIN_VCPU_LIVE = VIR_DOMAIN_AFFECT_LIVE, + VIR_DOMAIN_VCPU_CONFIG = VIR_DOMAIN_AFFECT_CONFIG, + + /* Additionally, these flags may be bitwise-OR'd in. */ + VIR_DOMAIN_VCPU_MAXIMUM = (1 << 2), /* Max rather than current count */ + VIR_DOMAIN_VCPU_GUEST = (1 << 3), /* Modify state of the cpu in the guest */ +} virDomainVcpuFlags; + +int virDomainSetVcpus (virDomainPtr domain, + unsigned int nvcpus); +int virDomainSetVcpusFlags (virDomainPtr domain, + unsigned int nvcpus, + unsigned int flags); +int virDomainGetVcpusFlags (virDomainPtr domain, + unsigned int flags); + +int virDomainPinVcpu (virDomainPtr domain, + unsigned int vcpu, + unsigned char *cpumap, + int maplen); +int virDomainPinVcpuFlags (virDomainPtr domain, + unsigned int vcpu, + unsigned char *cpumap, + int maplen, + unsigned int flags); + +int virDomainGetVcpuPinInfo (virDomainPtr domain, + int ncpumaps, + unsigned char *cpumaps, + int maplen, + unsigned int flags); + +int virDomainPinEmulator (virDomainPtr domain, + unsigned char *cpumap, + int maplen, + unsigned int flags); + +int virDomainGetEmulatorPinInfo (virDomainPtr domain, + unsigned char *cpumaps, + int maplen, + unsigned int flags); + +/** + * VIR_USE_CPU: + * @cpumap: pointer to a bit map of real CPUs (in 8-bit bytes) (IN/OUT) + * @cpu: the physical CPU number + * + * This macro is to be used in conjunction with virDomainPinVcpu() API. + * It sets the bit (CPU usable) of the related cpu in cpumap. + */ + +# define VIR_USE_CPU(cpumap, cpu) ((cpumap)[(cpu) / 8] |= (1 << ((cpu) % 8))) + +/** + * VIR_UNUSE_CPU: + * @cpumap: pointer to a bit map of real CPUs (in 8-bit bytes) (IN/OUT) + * @cpu: the physical CPU number + * + * This macro is to be used in conjunction with virDomainPinVcpu() API. + * It resets the bit (CPU not usable) of the related cpu in cpumap. + */ + +# define VIR_UNUSE_CPU(cpumap, cpu) ((cpumap)[(cpu) / 8] &= ~(1 << ((cpu) % 8))) + +/** + * VIR_CPU_USED: + * @cpumap: pointer to a bit map of real CPUs (in 8-bit bytes) (IN) + * @cpu: the physical CPU number + * + * This macro can be used in conjunction with virNodeGetCPUMap() API. + * It returns non-zero if the bit of the related CPU is set. + */ + +# define VIR_CPU_USED(cpumap, cpu) ((cpumap)[(cpu) / 8] & (1 << ((cpu) % 8))) + +/** + * VIR_CPU_MAPLEN: + * @cpu: number of physical CPUs + * + * 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. + */ + +# define VIR_CPU_MAPLEN(cpu) (((cpu) + 7) / 8) + + +int virDomainGetVcpus (virDomainPtr domain, + virVcpuInfoPtr info, + int maxinfo, + unsigned char *cpumaps, + int maplen); + +/** + * VIR_CPU_USABLE: + * @cpumaps: pointer to an array of cpumap (in 8-bit bytes) (IN) + * @maplen: the length (in bytes) of one cpumap + * @vcpu: the virtual CPU number + * @cpu: the physical CPU number + * + * 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. + */ + +# define VIR_CPU_USABLE(cpumaps, maplen, vcpu, cpu) \ + VIR_CPU_USED(VIR_GET_CPUMAP(cpumaps, maplen, vcpu), cpu) + +/** + * VIR_COPY_CPUMAP: + * @cpumaps: pointer to an array of cpumap (in 8-bit bytes) (IN) + * @maplen: the length (in bytes) of one cpumap + * @vcpu: the virtual CPU number + * @cpumap: pointer to a cpumap (in 8-bit bytes) (OUT) + * This cpumap must be previously allocated by the caller + * (ie: malloc(maplen)) + * + * 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. + */ +# define VIR_COPY_CPUMAP(cpumaps, maplen, vcpu, cpumap) \ + memcpy(cpumap, VIR_GET_CPUMAP(cpumaps, maplen, vcpu), maplen) + + +/** + * VIR_GET_CPUMAP: + * @cpumaps: pointer to an array of cpumap (in 8-bit bytes) (IN) + * @maplen: the length (in bytes) of one cpumap + * @vcpu: the virtual CPU number + * + * 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. + */ +# define VIR_GET_CPUMAP(cpumaps, maplen, vcpu) (&((cpumaps)[(vcpu) * (maplen)])) + + +typedef enum { + /* See virDomainModificationImpact for these flags. */ + VIR_DOMAIN_DEVICE_MODIFY_CURRENT = VIR_DOMAIN_AFFECT_CURRENT, + VIR_DOMAIN_DEVICE_MODIFY_LIVE = VIR_DOMAIN_AFFECT_LIVE, + VIR_DOMAIN_DEVICE_MODIFY_CONFIG = VIR_DOMAIN_AFFECT_CONFIG, + + /* Additionally, these flags may be bitwise-OR'd in. */ + VIR_DOMAIN_DEVICE_MODIFY_FORCE = (1 << 2), /* Forcibly modify device + (ex. force eject a cdrom) */ +} virDomainDeviceModifyFlags; + +int virDomainAttachDevice(virDomainPtr domain, const char *xml); +int virDomainDetachDevice(virDomainPtr domain, const char *xml); + +int virDomainAttachDeviceFlags(virDomainPtr domain, + const char *xml, unsigned int flags); +int virDomainDetachDeviceFlags(virDomainPtr domain, + const char *xml, unsigned int flags); +int virDomainUpdateDeviceFlags(virDomainPtr domain, + const char *xml, unsigned int flags); + +typedef struct _virDomainStatsRecord virDomainStatsRecord; +typedef virDomainStatsRecord *virDomainStatsRecordPtr; +struct _virDomainStatsRecord { + virDomainPtr dom; + virTypedParameterPtr params; + int nparams; +}; + +typedef enum { + VIR_DOMAIN_STATS_STATE = (1 << 0), /* return domain state */ + VIR_DOMAIN_STATS_CPU_TOTAL = (1 << 1), /* return domain CPU info */ + VIR_DOMAIN_STATS_BALLOON = (1 << 2), /* return domain balloon info */ + VIR_DOMAIN_STATS_VCPU = (1 << 3), /* return domain virtual CPU info */ + VIR_DOMAIN_STATS_INTERFACE = (1 << 4), /* return domain interfaces info */ + VIR_DOMAIN_STATS_BLOCK = (1 << 5), /* return domain block info */ +} virDomainStatsTypes; + +typedef enum { + 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_PERSISTENT = VIR_CONNECT_LIST_DOMAINS_PERSISTENT, + VIR_CONNECT_GET_ALL_DOMAINS_STATS_TRANSIENT = VIR_CONNECT_LIST_DOMAINS_TRANSIENT, + + VIR_CONNECT_GET_ALL_DOMAINS_STATS_RUNNING = VIR_CONNECT_LIST_DOMAINS_RUNNING, + VIR_CONNECT_GET_ALL_DOMAINS_STATS_PAUSED = VIR_CONNECT_LIST_DOMAINS_PAUSED, + VIR_CONNECT_GET_ALL_DOMAINS_STATS_SHUTOFF = VIR_CONNECT_LIST_DOMAINS_SHUTOFF, + VIR_CONNECT_GET_ALL_DOMAINS_STATS_OTHER = VIR_CONNECT_LIST_DOMAINS_OTHER, + + VIR_CONNECT_GET_ALL_DOMAINS_STATS_ENFORCE_STATS = 1 << 31, /* enforce requested stats */ +} virConnectGetAllDomainStatsFlags; + +int virConnectGetAllDomainStats(virConnectPtr conn, + unsigned int stats, + virDomainStatsRecordPtr **retStats, + unsigned int flags); + +int virDomainListGetStats(virDomainPtr *doms, + unsigned int stats, + virDomainStatsRecordPtr **retStats, + unsigned int flags); + +void virDomainStatsRecordListFree(virDomainStatsRecordPtr *stats); + +/* + * BlockJob API + */ + +/** + * virDomainBlockJobType: + * + * Describes various possible block jobs. + */ +typedef enum { + 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 */ + +# ifdef VIR_ENUM_SENTINELS + VIR_DOMAIN_BLOCK_JOB_TYPE_LAST +# endif +} virDomainBlockJobType; + +/** + * virDomainBlockJobAbortFlags: + * + * VIR_DOMAIN_BLOCK_JOB_ABORT_ASYNC: Request only, do not wait for completion + * VIR_DOMAIN_BLOCK_JOB_ABORT_PIVOT: Pivot to new file when ending a copy or + * active commit job + */ +typedef enum { + VIR_DOMAIN_BLOCK_JOB_ABORT_ASYNC = 1 << 0, + VIR_DOMAIN_BLOCK_JOB_ABORT_PIVOT = 1 << 1, +} virDomainBlockJobAbortFlags; + +int virDomainBlockJobAbort(virDomainPtr dom, const char *disk, + unsigned int flags); + +/* Flags for use with virDomainGetBlockJobInfo */ +typedef enum { + VIR_DOMAIN_BLOCK_JOB_INFO_BANDWIDTH_BYTES = 1 << 0, /* bandwidth in bytes/s + instead of MiB/s */ +} virDomainBlockJobInfoFlags; + +/* An iterator for monitoring block job operations */ +typedef unsigned long long virDomainBlockJobCursor; + +typedef struct _virDomainBlockJobInfo virDomainBlockJobInfo; +struct _virDomainBlockJobInfo { + int type; /* virDomainBlockJobType */ + unsigned long bandwidth; /* either bytes/s or MiB/s, according to flags */ + + /* + * The following fields provide an indication of block job progress. @cur + * indicates the current position and will be between 0 and @end. @end is + * the final cursor position for this operation and represents completion. + * To approximate progress, divide @cur by @end. + */ + virDomainBlockJobCursor cur; + virDomainBlockJobCursor end; +}; +typedef virDomainBlockJobInfo *virDomainBlockJobInfoPtr; + +int virDomainGetBlockJobInfo(virDomainPtr dom, const char *disk, + virDomainBlockJobInfoPtr info, + unsigned int flags); + +/* Flags for use with virDomainBlockJobSetSpeed */ +typedef enum { + VIR_DOMAIN_BLOCK_JOB_SPEED_BANDWIDTH_BYTES = 1 << 0, /* bandwidth in bytes/s + instead of MiB/s */ +} virDomainBlockJobSetSpeedFlags; + +int virDomainBlockJobSetSpeed(virDomainPtr dom, const char *disk, + unsigned long bandwidth, unsigned int flags); + +/* Flags for use with virDomainBlockPull (values chosen to be a subset + * of the flags for virDomainBlockRebase) */ +typedef enum { + VIR_DOMAIN_BLOCK_PULL_BANDWIDTH_BYTES = 1 << 6, /* bandwidth in bytes/s + instead of MiB/s */ +} virDomainBlockPullFlags; + +int virDomainBlockPull(virDomainPtr dom, const char *disk, + unsigned long bandwidth, unsigned int flags); + +/** + * virDomainBlockRebaseFlags: + * + * Flags available for virDomainBlockRebase(). + */ +typedef enum { + VIR_DOMAIN_BLOCK_REBASE_SHALLOW = 1 << 0, /* Limit copy to top of source + backing chain */ + VIR_DOMAIN_BLOCK_REBASE_REUSE_EXT = 1 << 1, /* Reuse existing external + file for a copy */ + VIR_DOMAIN_BLOCK_REBASE_COPY_RAW = 1 << 2, /* Make destination file raw */ + VIR_DOMAIN_BLOCK_REBASE_COPY = 1 << 3, /* Start a copy job */ + VIR_DOMAIN_BLOCK_REBASE_RELATIVE = 1 << 4, /* Keep backing chain + referenced using relative + names */ + VIR_DOMAIN_BLOCK_REBASE_COPY_DEV = 1 << 5, /* Treat destination as block + device instead of file */ + VIR_DOMAIN_BLOCK_REBASE_BANDWIDTH_BYTES = 1 << 6, /* bandwidth in bytes/s + instead of MiB/s */ +} virDomainBlockRebaseFlags; + +int virDomainBlockRebase(virDomainPtr dom, const char *disk, + const char *base, unsigned long bandwidth, + unsigned int flags); + +/** + * virDomainBlockCopyFlags: + * + * Flags available for virDomainBlockCopy(). + */ +typedef enum { + VIR_DOMAIN_BLOCK_COPY_SHALLOW = 1 << 0, /* Limit copy to top of source + backing chain */ + VIR_DOMAIN_BLOCK_COPY_REUSE_EXT = 1 << 1, /* Reuse existing external + file for a copy */ +} virDomainBlockCopyFlags; + +/** + * 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(). + */ +# define VIR_DOMAIN_BLOCK_COPY_BANDWIDTH "bandwidth" + +/** + * 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. + */ +# define VIR_DOMAIN_BLOCK_COPY_GRANULARITY "granularity" + +/** + * 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. + */ +# define VIR_DOMAIN_BLOCK_COPY_BUF_SIZE "buf-size" + +int virDomainBlockCopy(virDomainPtr dom, const char *disk, + const char *destxml, + virTypedParameterPtr params, + int nparams, + unsigned int flags); + +/** + * virDomainBlockCommitFlags: + * + * Flags available for virDomainBlockCommit(). + */ +typedef enum { + VIR_DOMAIN_BLOCK_COMMIT_SHALLOW = 1 << 0, /* NULL base means next backing + file, not whole chain */ + VIR_DOMAIN_BLOCK_COMMIT_DELETE = 1 << 1, /* Delete any files that are now + invalid after their contents + have been committed */ + VIR_DOMAIN_BLOCK_COMMIT_ACTIVE = 1 << 2, /* Allow a two-phase commit when + top is the active layer */ + VIR_DOMAIN_BLOCK_COMMIT_RELATIVE = 1 << 3, /* keep the backing chain + referenced using relative + names */ + VIR_DOMAIN_BLOCK_COMMIT_BANDWIDTH_BYTES = 1 << 4, /* bandwidth in bytes/s + instead of MiB/s */ +} virDomainBlockCommitFlags; + +int virDomainBlockCommit(virDomainPtr dom, const char *disk, const char *base, + const char *top, unsigned long bandwidth, + unsigned int flags); + + +/* Block I/O throttling support */ + +/** + * 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. + */ +# define VIR_DOMAIN_BLOCK_IOTUNE_TOTAL_BYTES_SEC "total_bytes_sec" + +/** + * 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. + */ +# define VIR_DOMAIN_BLOCK_IOTUNE_READ_BYTES_SEC "read_bytes_sec" + +/** + * 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. + */ +# define VIR_DOMAIN_BLOCK_IOTUNE_WRITE_BYTES_SEC "write_bytes_sec" + +/** + * 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. + */ +# define VIR_DOMAIN_BLOCK_IOTUNE_TOTAL_IOPS_SEC "total_iops_sec" + +/** + * 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. + */ +# define VIR_DOMAIN_BLOCK_IOTUNE_READ_IOPS_SEC "read_iops_sec" + +/** + * 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. + */ +# define VIR_DOMAIN_BLOCK_IOTUNE_WRITE_IOPS_SEC "write_iops_sec" + +int +virDomainSetBlockIoTune(virDomainPtr dom, + const char *disk, + virTypedParameterPtr params, + int nparams, + unsigned int flags); +int +virDomainGetBlockIoTune(virDomainPtr dom, + const char *disk, + virTypedParameterPtr params, + int *nparams, + unsigned int flags); + +/** + * virDomainDiskErrorCode: + * + * Disk I/O error. + */ +typedef enum { + 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 */ + +# ifdef VIR_ENUM_SENTINELS + VIR_DOMAIN_DISK_ERROR_LAST +# endif +} virDomainDiskErrorCode; + +/** + * virDomainDiskError: + * + */ +typedef struct _virDomainDiskError virDomainDiskError; +typedef virDomainDiskError *virDomainDiskErrorPtr; + +struct _virDomainDiskError { + char *disk; /* disk target */ + int error; /* virDomainDiskErrorCode */ +}; + +int virDomainGetDiskErrors(virDomainPtr dom, + virDomainDiskErrorPtr errors, + unsigned int maxerrors, + unsigned int flags); + + + +/** + * virKeycodeSet: + * + * Enum to specify which keycode mapping is in use for virDomainSendKey(). + */ +typedef enum { + 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, + +# ifdef VIR_ENUM_SENTINELS + VIR_KEYCODE_SET_LAST + /* + * 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. + */ +# endif +} virKeycodeSet; + +/** + * VIR_DOMAIN_SEND_KEY_MAX_KEYS: + * + * Maximum number of keycodes that can be sent in one virDomainSendKey() call. + */ +# define VIR_DOMAIN_SEND_KEY_MAX_KEYS 16 + +int virDomainSendKey(virDomainPtr domain, + unsigned int codeset, + unsigned int holdtime, + unsigned int *keycodes, + int nkeycodes, + unsigned int flags); + +/* + * These just happen to match Linux signal numbers. The numbers + * will be mapped to whatever the SIGNUM is in the guest OS in + * question by the agent delivering the signal. The names are + * based on the POSIX / XSI signal standard though. + * + * Do not rely on all values matching Linux though. It is possible + * this enum might be extended with new signals which have no + * mapping in Linux. + */ +typedef enum { + 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 */ + +# ifdef VIR_ENUM_SENTINELS + VIR_DOMAIN_PROCESS_SIGNAL_LAST +# endif +} virDomainProcessSignal; + +int virDomainSendProcessSignal(virDomainPtr domain, + long long pid_value, + unsigned int signum, + unsigned int flags); + +/* + * Deprecated calls + */ +virDomainPtr virDomainCreateLinux (virConnectPtr conn, + const char *xmlDesc, + unsigned int flags); + + +/* + * Domain Event Notification + */ + +/** + * virDomainEventType: + * + * a virDomainEventType is emitted during domain lifecycle events + */ +typedef enum { + 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, + +# ifdef VIR_ENUM_SENTINELS + VIR_DOMAIN_EVENT_LAST +# endif +} virDomainEventType; + +/** + * virDomainEventDefinedDetailType: + * + * Details on the cause of a 'defined' lifecycle event + */ +typedef enum { + VIR_DOMAIN_EVENT_DEFINED_ADDED = 0, /* Newly created config file */ + VIR_DOMAIN_EVENT_DEFINED_UPDATED = 1, /* Changed config file */ + +# ifdef VIR_ENUM_SENTINELS + VIR_DOMAIN_EVENT_DEFINED_LAST +# endif +} virDomainEventDefinedDetailType; + +/** + * virDomainEventUndefinedDetailType: + * + * Details on the cause of an 'undefined' lifecycle event + */ +typedef enum { + VIR_DOMAIN_EVENT_UNDEFINED_REMOVED = 0, /* Deleted the config file */ + +# ifdef VIR_ENUM_SENTINELS + VIR_DOMAIN_EVENT_UNDEFINED_LAST +# endif +} virDomainEventUndefinedDetailType; + +/** + * virDomainEventStartedDetailType: + * + * Details on the cause of a 'started' lifecycle event + */ +typedef enum { + 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 */ + +# ifdef VIR_ENUM_SENTINELS + VIR_DOMAIN_EVENT_STARTED_LAST +# endif +} virDomainEventStartedDetailType; + +/** + * virDomainEventSuspendedDetailType: + * + * Details on the cause of a 'suspended' lifecycle event + */ +typedef enum { + 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 */ + +# ifdef VIR_ENUM_SENTINELS + VIR_DOMAIN_EVENT_SUSPENDED_LAST +# endif +} virDomainEventSuspendedDetailType; + +/** + * virDomainEventResumedDetailType: + * + * Details on the cause of a 'resumed' lifecycle event + */ +typedef enum { + 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 */ + +# ifdef VIR_ENUM_SENTINELS + VIR_DOMAIN_EVENT_RESUMED_LAST +# endif +} virDomainEventResumedDetailType; + +/** + * virDomainEventStoppedDetailType: + * + * Details on the cause of a 'stopped' lifecycle event + */ +typedef enum { + 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 */ + +# ifdef VIR_ENUM_SENTINELS + VIR_DOMAIN_EVENT_STOPPED_LAST +# endif +} virDomainEventStoppedDetailType; + + +/** + * virDomainEventShutdownDetailType: + * + * Details on the cause of a 'shutdown' lifecycle event + */ +typedef enum { + VIR_DOMAIN_EVENT_SHUTDOWN_FINISHED = 0, /* Guest finished shutdown sequence */ + +# ifdef VIR_ENUM_SENTINELS + VIR_DOMAIN_EVENT_SHUTDOWN_LAST +# endif +} virDomainEventShutdownDetailType; + +/** + * virDomainEventPMSuspendedDetailType: + * + * Details on the cause of a 'pmsuspended' lifecycle event + */ +typedef enum { + VIR_DOMAIN_EVENT_PMSUSPENDED_MEMORY = 0, /* Guest was PM suspended to memory */ + VIR_DOMAIN_EVENT_PMSUSPENDED_DISK = 1, /* Guest was PM suspended to disk */ + +# ifdef VIR_ENUM_SENTINELS + VIR_DOMAIN_EVENT_PMSUSPENDED_LAST +# endif +} virDomainEventPMSuspendedDetailType; + +/** + * virDomainEventCrashedDetailType: + * + * Details on the cause of a 'crashed' lifecycle event + */ +typedef enum { + VIR_DOMAIN_EVENT_CRASHED_PANICKED = 0, /* Guest was panicked */ + +# ifdef VIR_ENUM_SENTINELS + VIR_DOMAIN_EVENT_CRASHED_LAST +# endif +} virDomainEventCrashedDetailType; + +/** + * virConnectDomainEventCallback: + * @conn: virConnect connection + * @dom: The domain on which the event occurred + * @event: The specific virDomainEventType which occurred + * @detail: event specific detail information + * @opaque: opaque user data + * + * A callback function to be registered, and called when a domain event occurs + * + * Returns 0 (the return value is currently ignored) + */ +typedef int (*virConnectDomainEventCallback)(virConnectPtr conn, + virDomainPtr dom, + int event, + int detail, + void *opaque); + +int virConnectDomainEventRegister(virConnectPtr conn, + virConnectDomainEventCallback cb, + void *opaque, + virFreeCallback freecb); + +int virConnectDomainEventDeregister(virConnectPtr conn, + virConnectDomainEventCallback cb); + + +int virDomainIsActive(virDomainPtr dom); +int virDomainIsPersistent(virDomainPtr dom); +int virDomainIsUpdated(virDomainPtr dom); + +typedef enum { + 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 */ + +# ifdef VIR_ENUM_SENTINELS + VIR_DOMAIN_JOB_LAST +# endif +} virDomainJobType; + +typedef struct _virDomainJobInfo virDomainJobInfo; +typedef virDomainJobInfo *virDomainJobInfoPtr; +struct _virDomainJobInfo { + /* One of virDomainJobType */ + 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 otherwise specified + * and is measuring the job as a whole. + * + * For VIR_DOMAIN_JOB_UNBOUNDED, dataTotal may be less + * than the final sum of dataProcessed + dataRemaining + * in the event that the hypervisor has to repeat some + * data, such as due to dirtied pages during migration. + * + * For VIR_DOMAIN_JOB_BOUNDED, dataTotal shall always + * equal the sum of dataProcessed + dataRemaining. + */ + 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; +}; + +/** + * virDomainGetJobStatsFlags: + * + * Flags OR'ed together to provide specific behavior when querying domain + * job statistics. + */ +typedef enum { + VIR_DOMAIN_JOB_STATS_COMPLETED = 1 << 0, /* return stats of a recently + * completed job */ +} virDomainGetJobStatsFlags; + +int virDomainGetJobInfo(virDomainPtr dom, + virDomainJobInfoPtr info); +int virDomainGetJobStats(virDomainPtr domain, + int *type, + virTypedParameterPtr *params, + int *nparams, + unsigned int flags); +int virDomainAbortJob(virDomainPtr dom); + +/** + * 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. + */ +# define VIR_DOMAIN_JOB_TIME_ELAPSED "time_elapsed" + +/** + * 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. + */ +# define VIR_DOMAIN_JOB_TIME_REMAINING "time_remaining" + +/** + * VIR_DOMAIN_JOB_DOWNTIME: + * + * virDomainGetJobStats field: downtime (ms) that is expected to happen + * during migration, as VIR_TYPED_PARAM_ULLONG. + */ +# define VIR_DOMAIN_JOB_DOWNTIME "downtime" + +/** + * 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. + */ +# define VIR_DOMAIN_JOB_SETUP_TIME "setup_time" + +/** + * 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. + */ +# define VIR_DOMAIN_JOB_DATA_TOTAL "data_total" + +/** + * 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. + */ +# define VIR_DOMAIN_JOB_DATA_PROCESSED "data_processed" + +/** + * 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. + */ +# define VIR_DOMAIN_JOB_DATA_REMAINING "data_remaining" + +/** + * 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. + */ +# define VIR_DOMAIN_JOB_MEMORY_TOTAL "memory_total" + +/** + * 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. + */ +# define VIR_DOMAIN_JOB_MEMORY_PROCESSED "memory_processed" + +/** + * 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. + */ +# define VIR_DOMAIN_JOB_MEMORY_REMAINING "memory_remaining" + +/** + * 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. + */ +# define VIR_DOMAIN_JOB_MEMORY_CONSTANT "memory_constant" + +/** + * 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. + */ +# define VIR_DOMAIN_JOB_MEMORY_NORMAL "memory_normal" + +/** + * 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. + */ +# define VIR_DOMAIN_JOB_MEMORY_NORMAL_BYTES "memory_normal_bytes" + +/** + * VIR_DOMAIN_JOB_MEMORY_BPS: + * + * virDomainGetJobStats field: network throughput used while migrating + * memory in Bytes per second, as VIR_TYPED_PARAM_ULLONG. + */ +# define VIR_DOMAIN_JOB_MEMORY_BPS "memory_bps" + +/** + * 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. + */ +# define VIR_DOMAIN_JOB_DISK_TOTAL "disk_total" + +/** + * 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. + */ +# define VIR_DOMAIN_JOB_DISK_PROCESSED "disk_processed" + +/** + * 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. + */ +# define VIR_DOMAIN_JOB_DISK_REMAINING "disk_remaining" + +/** + * VIR_DOMAIN_JOB_DISK_BPS: + * + * virDomainGetJobStats field: network throughput used while migrating + * disks in Bytes per second, as VIR_TYPED_PARAM_ULLONG. + */ +# define VIR_DOMAIN_JOB_DISK_BPS "disk_bps" + +/** + * 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. + */ +# define VIR_DOMAIN_JOB_COMPRESSION_CACHE "compression_cache" + +/** + * VIR_DOMAIN_JOB_COMPRESSION_BYTES: + * + * virDomainGetJobStats field: number of compressed bytes transferred + * since the beginning of migration, as VIR_TYPED_PARAM_ULLONG. + */ +# define VIR_DOMAIN_JOB_COMPRESSION_BYTES "compression_bytes" + +/** + * VIR_DOMAIN_JOB_COMPRESSION_PAGES: + * + * virDomainGetJobStats field: number of compressed pages transferred + * since the beginning of migration, as VIR_TYPED_PARAM_ULLONG. + */ +# define VIR_DOMAIN_JOB_COMPRESSION_PAGES "compression_pages" + +/** + * 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. + */ +# define VIR_DOMAIN_JOB_COMPRESSION_CACHE_MISSES "compression_cache_misses" + +/** + * 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. + */ +# define VIR_DOMAIN_JOB_COMPRESSION_OVERFLOW "compression_overflow" + + + +/** + * virConnectDomainEventGenericCallback: + * @conn: the connection pointer + * @dom: the domain pointer + * @opaque: application specified data + * + * 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. + */ +typedef void (*virConnectDomainEventGenericCallback)(virConnectPtr conn, + virDomainPtr dom, + void *opaque); + +/** + * virConnectDomainEventRTCChangeCallback: + * @conn: connection object + * @dom: domain on which the event occurred + * @utcoffset: the new RTC offset from UTC, measured in seconds + * @opaque: application specified data + * + * The callback signature to use when registering for an event of type + * VIR_DOMAIN_EVENT_ID_RTC_CHANGE with virConnectDomainEventRegisterAny() + */ +typedef void (*virConnectDomainEventRTCChangeCallback)(virConnectPtr conn, + virDomainPtr dom, + long long utcoffset, + void *opaque); + +/** + * virDomainEventWatchdogAction: + * + * The action that is to be taken due to the watchdog device firing + */ +typedef enum { + VIR_DOMAIN_EVENT_WATCHDOG_NONE = 0, /* No action, watchdog ignored */ + VIR_DOMAIN_EVENT_WATCHDOG_PAUSE, /* Guest CPUs are paused */ + VIR_DOMAIN_EVENT_WATCHDOG_RESET, /* Guest CPUs are reset */ + VIR_DOMAIN_EVENT_WATCHDOG_POWEROFF, /* Guest is forcibly powered off */ + VIR_DOMAIN_EVENT_WATCHDOG_SHUTDOWN, /* Guest is requested to gracefully shutdown */ + VIR_DOMAIN_EVENT_WATCHDOG_DEBUG, /* No action, a debug message logged */ + +# ifdef VIR_ENUM_SENTINELS + VIR_DOMAIN_EVENT_WATCHDOG_LAST +# endif +} virDomainEventWatchdogAction; + +/** + * virConnectDomainEventWatchdogCallback: + * @conn: connection object + * @dom: domain on which the event occurred + * @action: action that is to be taken due to watchdog firing + * @opaque: application specified data + * + * The callback signature to use when registering for an event of type + * VIR_DOMAIN_EVENT_ID_WATCHDOG with virConnectDomainEventRegisterAny() + * + */ +typedef void (*virConnectDomainEventWatchdogCallback)(virConnectPtr conn, + virDomainPtr dom, + int action, + void *opaque); + +/** + * virDomainEventIOErrorAction: + * + * The action that is to be taken due to an IO error occurring + */ +typedef enum { + VIR_DOMAIN_EVENT_IO_ERROR_NONE = 0, /* No action, IO error ignored */ + VIR_DOMAIN_EVENT_IO_ERROR_PAUSE, /* Guest CPUs are paused */ + VIR_DOMAIN_EVENT_IO_ERROR_REPORT, /* IO error reported to guest OS */ + +# ifdef VIR_ENUM_SENTINELS + VIR_DOMAIN_EVENT_IO_ERROR_LAST +# endif +} virDomainEventIOErrorAction; + + +/** + * virConnectDomainEventIOErrorCallback: + * @conn: connection object + * @dom: domain on which the event occurred + * @srcPath: The host file on which the IO error occurred + * @devAlias: The guest device alias associated with the path + * @action: action that is to be taken due to the IO error + * @opaque: application specified data + * + * The callback signature to use when registering for an event of type + * VIR_DOMAIN_EVENT_ID_IO_ERROR with virConnectDomainEventRegisterAny() + */ +typedef void (*virConnectDomainEventIOErrorCallback)(virConnectPtr conn, + virDomainPtr dom, + const char *srcPath, + const char *devAlias, + int action, + void *opaque); + +/** + * virConnectDomainEventIOErrorReasonCallback: + * @conn: connection object + * @dom: domain on which the event occurred + * @srcPath: The host file on which the IO error occurred + * @devAlias: The guest device alias associated with the path + * @action: action that is to be taken due to the IO error + * @reason: the cause of the IO error + * @opaque: application specified data + * + * The callback signature to use when registering for an event of type + * VIR_DOMAIN_EVENT_ID_IO_ERROR_REASON with virConnectDomainEventRegisterAny() + * + * If the I/O error is known to be caused by an ENOSPC condition in + * the host (where resizing the disk to be larger will allow the guest + * to be resumed as if nothing happened), @reason will be "enospc". + * Otherwise, @reason will be "", although future strings may be added + * if determination of other error types becomes possible. + * + */ +typedef void (*virConnectDomainEventIOErrorReasonCallback)(virConnectPtr conn, + virDomainPtr dom, + const char *srcPath, + const char *devAlias, + int action, + const char *reason, + void *opaque); + +/** + * virDomainEventGraphicsPhase: + * + * The phase of the graphics client connection + */ +typedef enum { + VIR_DOMAIN_EVENT_GRAPHICS_CONNECT = 0, /* Initial socket connection established */ + VIR_DOMAIN_EVENT_GRAPHICS_INITIALIZE, /* Authentication & setup completed */ + VIR_DOMAIN_EVENT_GRAPHICS_DISCONNECT, /* Final socket disconnection */ + +# ifdef VIR_ENUM_SENTINELS + VIR_DOMAIN_EVENT_GRAPHICS_LAST +# endif +} virDomainEventGraphicsPhase; + +/** + * virDomainEventGraphicsAddressType: + * + * The type of address for the connection + */ +typedef enum { + VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_IPV4, /* IPv4 address */ + VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_IPV6, /* IPv6 address */ + VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_UNIX, /* UNIX socket path */ + +# ifdef VIR_ENUM_SENTINELS + VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_LAST +# endif +} virDomainEventGraphicsAddressType; + + +/** + * virDomainEventGraphicsAddress: + * + * The data structure containing connection address details + * + */ +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) */ +}; +typedef struct _virDomainEventGraphicsAddress virDomainEventGraphicsAddress; +typedef virDomainEventGraphicsAddress *virDomainEventGraphicsAddressPtr; + + +/** + * virDomainEventGraphicsSubjectIdentity: + * + * The data structure representing a single identity + * + * The types of identity differ according to the authentication scheme, + * some examples are 'x509dname' and 'saslUsername'. + */ +struct _virDomainEventGraphicsSubjectIdentity { + char *type; /* Type of identity */ + char *name; /* Identity value */ +}; +typedef struct _virDomainEventGraphicsSubjectIdentity virDomainEventGraphicsSubjectIdentity; +typedef virDomainEventGraphicsSubjectIdentity *virDomainEventGraphicsSubjectIdentityPtr; + + +/** + * virDomainEventGraphicsSubject: + * + * The data structure representing an authenticated subject + * + * A subject will have zero or more identities. The types of + * identity differ according to the authentication scheme + */ +struct _virDomainEventGraphicsSubject { + int nidentity; /* Number of identities in array*/ + virDomainEventGraphicsSubjectIdentityPtr identities; /* Array of identities for subject */ +}; +typedef struct _virDomainEventGraphicsSubject virDomainEventGraphicsSubject; +typedef virDomainEventGraphicsSubject *virDomainEventGraphicsSubjectPtr; + + +/** + * virConnectDomainEventGraphicsCallback: + * @conn: connection object + * @dom: domain on which the event occurred + * @phase: the phase of the connection + * @local: the local server address + * @remote: the remote client address + * @authScheme: the authentication scheme activated + * @subject: the authenticated subject (user) + * @opaque: application specified data + * + * The callback signature to use when registering for an event of type + * VIR_DOMAIN_EVENT_ID_GRAPHICS with virConnectDomainEventRegisterAny() + */ +typedef void (*virConnectDomainEventGraphicsCallback)(virConnectPtr conn, + virDomainPtr dom, + int phase, + const virDomainEventGraphicsAddress *local, + const virDomainEventGraphicsAddress *remote, + const char *authScheme, + const virDomainEventGraphicsSubject *subject, + void *opaque); + +/** + * virConnectDomainEventBlockJobStatus: + * + * Tracks status of a virDomainBlockPull(), virDomainBlockRebase(), + * virDomainBlockCopy(), or virDomainBlockCommit() operation + */ +typedef enum { + VIR_DOMAIN_BLOCK_JOB_COMPLETED = 0, + VIR_DOMAIN_BLOCK_JOB_FAILED = 1, + VIR_DOMAIN_BLOCK_JOB_CANCELED = 2, + VIR_DOMAIN_BLOCK_JOB_READY = 3, + +# ifdef VIR_ENUM_SENTINELS + VIR_DOMAIN_BLOCK_JOB_LAST +# endif +} virConnectDomainEventBlockJobStatus; + +/** + * virConnectDomainEventBlockJobCallback: + * @conn: connection object + * @dom: domain on which the event occurred + * @disk: name associated with the affected disk (filename or target + * device, depending on how the callback was registered) + * @type: type of block job (virDomainBlockJobType) + * @status: status of the operation (virConnectDomainEventBlockJobStatus) + * @opaque: application specified data + * + * 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"). + */ +typedef void (*virConnectDomainEventBlockJobCallback)(virConnectPtr conn, + virDomainPtr dom, + const char *disk, + int type, + int status, + void *opaque); + +/** + * virConnectDomainEventDiskChangeReason: + * + * The reason describing why this callback is called + */ +typedef enum { + VIR_DOMAIN_EVENT_DISK_CHANGE_MISSING_ON_START = 0, /* oldSrcPath is set */ + VIR_DOMAIN_EVENT_DISK_DROP_MISSING_ON_START = 1, + +# ifdef VIR_ENUM_SENTINELS + VIR_DOMAIN_EVENT_DISK_CHANGE_LAST +# endif +} virConnectDomainEventDiskChangeReason; + +/** + * virConnectDomainEventDiskChangeCallback: + * @conn: connection object + * @dom: domain on which the event occurred + * @oldSrcPath: old source path + * @newSrcPath: new source path + * @devAlias: device alias name + * @reason: reason why this callback was called; any of + * virConnectDomainEventDiskChangeReason + * @opaque: application specified data + * + * 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() + */ +typedef void (*virConnectDomainEventDiskChangeCallback)(virConnectPtr conn, + virDomainPtr dom, + const char *oldSrcPath, + const char *newSrcPath, + const char *devAlias, + int reason, + void *opaque); + +/** + * virConnectDomainEventTrayChangeReason: + * + * The reason describing why the callback was called + */ +typedef enum { + VIR_DOMAIN_EVENT_TRAY_CHANGE_OPEN = 0, + VIR_DOMAIN_EVENT_TRAY_CHANGE_CLOSE, + +# ifdef VIR_ENUM_SENTINELS + VIR_DOMAIN_EVENT_TRAY_CHANGE_LAST +# endif +} virDomainEventTrayChangeReason; + +/** + * virConnectDomainEventTrayChangeCallback: + * @conn: connection object + * @dom: domain on which the event occurred + * @devAlias: device alias + * @reason: why the tray status was changed? + * @opaque: application specified data + * + * 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() + */ +typedef void (*virConnectDomainEventTrayChangeCallback)(virConnectPtr conn, + virDomainPtr dom, + const char *devAlias, + int reason, + void *opaque); + +/** + * virConnectDomainEventPMWakeupCallback: + * @conn: connection object + * @dom: domain on which the event occurred + * @reason: reason why the callback was called, unused currently, + * always passes 0 + * @opaque: application specified data + * + * 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() + */ +typedef void (*virConnectDomainEventPMWakeupCallback)(virConnectPtr conn, + virDomainPtr dom, + int reason, + void *opaque); + +/** + * virConnectDomainEventPMSuspendCallback: + * @conn: connection object + * @dom: domain on which the event occurred + * @reason: reason why the callback was called, unused currently, + * always passes 0 + * @opaque: application specified data + * + * 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() + */ +typedef void (*virConnectDomainEventPMSuspendCallback)(virConnectPtr conn, + virDomainPtr dom, + int reason, + void *opaque); + + +/** + * virConnectDomainEventBalloonChangeCallback: + * @conn: connection object + * @dom: domain on which the event occurred + * @actual: the new balloon level measured in kibibytes(blocks of 1024 bytes) + * @opaque: application specified data + * + * The callback signature to use when registering for an event of type + * VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE with virConnectDomainEventRegisterAny() + */ +typedef void (*virConnectDomainEventBalloonChangeCallback)(virConnectPtr conn, + virDomainPtr dom, + unsigned long long actual, + void *opaque); + +/** + * virConnectDomainEventPMSuspendDiskCallback: + * @conn: connection object + * @dom: domain on which the event occurred + * @reason: reason why the callback was called, unused currently, + * always passes 0 + * @opaque: application specified data + * + * 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() + */ +typedef void (*virConnectDomainEventPMSuspendDiskCallback)(virConnectPtr conn, + virDomainPtr dom, + int reason, + void *opaque); + +/** + * virConnectDomainEventDeviceRemovedCallback: + * @conn: connection object + * @dom: domain on which the event occurred + * @devAlias: device alias + * @opaque: application specified data + * + * 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() + */ +typedef void (*virConnectDomainEventDeviceRemovedCallback)(virConnectPtr conn, + virDomainPtr dom, + const char *devAlias, + void *opaque); + +/** + * 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. + */ +# define VIR_DOMAIN_TUNABLE_CPU_VCPUPIN "cputune.vcpupin%u" + +/** + * VIR_DOMAIN_TUNABLE_CPU_EMULATORPIN: + * + * Macro represents formatted pinning for emulator process, + * as VIR_TYPED_PARAM_STRING. + */ +# define VIR_DOMAIN_TUNABLE_CPU_EMULATORPIN "cputune.emulatorpin" + +/** + * 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. + */ +# define VIR_DOMAIN_TUNABLE_CPU_CPU_SHARES "cputune.cpu_shares" + +/** + * 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. + */ +# define VIR_DOMAIN_TUNABLE_CPU_VCPU_PERIOD "cputune.vcpu_period" + +/** + * 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. + */ +# define VIR_DOMAIN_TUNABLE_CPU_VCPU_QUOTA "cputune.vcpu_quota" + +/** + * 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. + */ +# define VIR_DOMAIN_TUNABLE_CPU_EMULATOR_PERIOD "cputune.emulator_period" + +/** + * 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. + */ +# define VIR_DOMAIN_TUNABLE_CPU_EMULATOR_QUOTA "cputune.emulator_quota" + +/** + * VIR_DOMAIN_TUNABLE_BLKDEV_DISK: + * + * Macro represents the name of guest disk for which the values are updated, + * as VIR_TYPED_PARAM_STRING. + */ +# define VIR_DOMAIN_TUNABLE_BLKDEV_DISK "blkdeviotune.disk" + +/** + * VIR_DOMAIN_TUNABLE_BLKDEV_TOTAL_BYTES_SEC: + * + * Marco represents the total throughput limit in bytes per second, + * as VIR_TYPED_PARAM_ULLONG. + */ +# define VIR_DOMAIN_TUNABLE_BLKDEV_TOTAL_BYTES_SEC "blkdeviotune.total_bytes_sec" + +/** + * VIR_DOMAIN_TUNABLE_BLKDEV_READ_BYTES_SEC: + * + * Marco represents the read throughput limit in bytes per second, + * as VIR_TYPED_PARAM_ULLONG. + */ +# define VIR_DOMAIN_TUNABLE_BLKDEV_READ_BYTES_SEC "blkdeviotune.read_bytes_sec" + +/** + * VIR_DOMAIN_TUNABLE_BLKDEV_WRITE_BYTES_SEC: + * + * Macro represents the write throughput limit in bytes per second, + * as VIR_TYPED_PARAM_ULLONG. + */ +# define VIR_DOMAIN_TUNABLE_BLKDEV_WRITE_BYTES_SEC "blkdeviotune.write_bytes_sec" + +/** + * VIR_DOMAIN_TUNABLE_BLKDEV_TOTAL_IOPS_SEC: + * + * Macro represents the total I/O operations per second, + * as VIR_TYPED_PARAM_ULLONG. + */ +# define VIR_DOMAIN_TUNABLE_BLKDEV_TOTAL_IOPS_SEC "blkdeviotune.total_iops_sec" + +/** + * VIR_DOMAIN_TUNABLE_BLKDEV_READ_IOPS_SEC: + * + * Macro represents the read I/O operations per second, + * as VIR_TYPED_PARAM_ULLONG. + */ +# define VIR_DOMAIN_TUNABLE_BLKDEV_READ_IOPS_SEC "blkdeviotune.read_iops_sec" + +/** + * VIR_DOMAIN_TUNABLE_BLKDEV_WRITE_IOPS_SEC: + * + * Macro represents the write I/O operations per second, + * as VIR_TYPED_PARAM_ULLONG. + */ +# define VIR_DOMAIN_TUNABLE_BLKDEV_WRITE_IOPS_SEC "blkdeviotune.write_iops_sec" + +/** + * virConnectDomainEventTunableCallback: + * @conn: connection object + * @dom: domain on which the event occurred + * @params: changed tunable values stored as array of virTypedParameter + * @nparams: size of the array + * @opaque: application specified data + * + * 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() + */ +typedef void (*virConnectDomainEventTunableCallback)(virConnectPtr conn, + virDomainPtr dom, + virTypedParameterPtr params, + int nparams, + void *opaque); + + +/** + * VIR_DOMAIN_EVENT_CALLBACK: + * + * Used to cast the event specific callback into the generic one + * for use for virConnectDomainEventRegisterAny() + */ +# define VIR_DOMAIN_EVENT_CALLBACK(cb) ((virConnectDomainEventGenericCallback)(cb)) + + +/** + * virDomainEventID: + * + * An enumeration of supported eventId parameters for + * virConnectDomainEventRegisterAny(). Each event id determines which + * signature of callback function will be used. + */ +typedef enum { + 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 */ + +# ifdef VIR_ENUM_SENTINELS + VIR_DOMAIN_EVENT_ID_LAST + /* + * 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. + */ +# endif +} virDomainEventID; + + +/* Use VIR_DOMAIN_EVENT_CALLBACK() to cast the 'cb' parameter */ +int virConnectDomainEventRegisterAny(virConnectPtr conn, + virDomainPtr dom, /* Optional, to filter */ + int eventID, + virConnectDomainEventGenericCallback cb, + void *opaque, + virFreeCallback freecb); + +int virConnectDomainEventDeregisterAny(virConnectPtr conn, + int callbackID); + + +/** + * virDomainConsoleFlags + * + * Since 0.9.10 + */ +typedef enum { + + VIR_DOMAIN_CONSOLE_FORCE = (1 << 0), /* abort a (possibly) active console + connection to force a new + connection */ + VIR_DOMAIN_CONSOLE_SAFE = (1 << 1), /* check if the console driver supports + safe console operations */ +} virDomainConsoleFlags; + +int virDomainOpenConsole(virDomainPtr dom, + const char *dev_name, + virStreamPtr st, + unsigned int flags); + +/** + * virDomainChannelFlags + * + * Since 1.0.2 + */ +typedef enum { + VIR_DOMAIN_CHANNEL_FORCE = (1 << 0), /* abort a (possibly) active channel + connection to force a new + connection */ +} virDomainChannelFlags; + +int virDomainOpenChannel(virDomainPtr dom, + const char *name, + virStreamPtr st, + unsigned int flags); + +typedef enum { + VIR_DOMAIN_OPEN_GRAPHICS_SKIPAUTH = (1 << 0), +} virDomainOpenGraphicsFlags; + +int virDomainOpenGraphics(virDomainPtr dom, + unsigned int idx, + int fd, + unsigned int flags); + +int virDomainOpenGraphicsFD(virDomainPtr dom, + unsigned int idx, + unsigned int flags); + +int virDomainInjectNMI(virDomainPtr domain, unsigned int flags); + +int virDomainFSTrim(virDomainPtr dom, + const char *mountPoint, + unsigned long long minimum, + unsigned int flags); + +int virDomainFSFreeze(virDomainPtr dom, + const char **mountpoints, + unsigned int nmountpoints, + unsigned int flags); + +int virDomainFSThaw(virDomainPtr dom, + const char **mountpoints, + unsigned int nmountpoints, + unsigned int flags); + +int virDomainGetTime(virDomainPtr dom, + long long *seconds, + unsigned int *nseconds, + unsigned int flags); + +typedef enum { + VIR_DOMAIN_TIME_SYNC = (1 << 0), /* Re-sync domain time from domain's RTC */ +} virDomainSetTimeFlags; + +int virDomainSetTime(virDomainPtr dom, + long long seconds, + unsigned int nseconds, + unsigned int flags); + +/** + * virSchedParameterType: + * + * A scheduler parameter field type. Provided for backwards + * compatibility; virTypedParameterType is the preferred enum since + * 0.9.2. + */ +typedef enum { + VIR_DOMAIN_SCHED_FIELD_INT = VIR_TYPED_PARAM_INT, + VIR_DOMAIN_SCHED_FIELD_UINT = VIR_TYPED_PARAM_UINT, + VIR_DOMAIN_SCHED_FIELD_LLONG = VIR_TYPED_PARAM_LLONG, + VIR_DOMAIN_SCHED_FIELD_ULLONG = VIR_TYPED_PARAM_ULLONG, + VIR_DOMAIN_SCHED_FIELD_DOUBLE = VIR_TYPED_PARAM_DOUBLE, + VIR_DOMAIN_SCHED_FIELD_BOOLEAN = VIR_TYPED_PARAM_BOOLEAN, +} virSchedParameterType; + +/** + * 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. + */ +# define VIR_DOMAIN_SCHED_FIELD_LENGTH VIR_TYPED_PARAM_FIELD_LENGTH + +/** + * virSchedParameter: + * + * a virSchedParameter is the set of scheduler parameters. + * Provided for backwards compatibility; virTypedParameter is the + * preferred alias since 0.9.2. + */ +# define _virSchedParameter _virTypedParameter +typedef struct _virTypedParameter virSchedParameter; + +/** + * virSchedParameterPtr: + * + * a virSchedParameterPtr is a pointer to a virSchedParameter structure. + * Provided for backwards compatibility; virTypedParameterPtr is the + * preferred alias since 0.9.2. + */ +typedef virSchedParameter *virSchedParameterPtr; + +/** + * virBlkioParameterType: + * + * A blkio parameter field type. Provided for backwards + * compatibility; virTypedParameterType is the preferred enum since + * 0.9.2. + */ +typedef enum { + VIR_DOMAIN_BLKIO_PARAM_INT = VIR_TYPED_PARAM_INT, + VIR_DOMAIN_BLKIO_PARAM_UINT = VIR_TYPED_PARAM_UINT, + VIR_DOMAIN_BLKIO_PARAM_LLONG = VIR_TYPED_PARAM_LLONG, + VIR_DOMAIN_BLKIO_PARAM_ULLONG = VIR_TYPED_PARAM_ULLONG, + VIR_DOMAIN_BLKIO_PARAM_DOUBLE = VIR_TYPED_PARAM_DOUBLE, + VIR_DOMAIN_BLKIO_PARAM_BOOLEAN = VIR_TYPED_PARAM_BOOLEAN, +} virBlkioParameterType; + +/** + * 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. + */ +# define VIR_DOMAIN_BLKIO_FIELD_LENGTH VIR_TYPED_PARAM_FIELD_LENGTH + +/** + * virBlkioParameter: + * + * a virBlkioParameter is the set of blkio parameters. + * Provided for backwards compatibility; virTypedParameter is the + * preferred alias since 0.9.2. + */ +# define _virBlkioParameter _virTypedParameter +typedef struct _virTypedParameter virBlkioParameter; + +/** + * virBlkioParameterPtr: + * + * a virBlkioParameterPtr is a pointer to a virBlkioParameter structure. + * Provided for backwards compatibility; virTypedParameterPtr is the + * preferred alias since 0.9.2. + */ +typedef virBlkioParameter *virBlkioParameterPtr; + +/** + * virMemoryParameterType: + * + * A memory parameter field type. Provided for backwards + * compatibility; virTypedParameterType is the preferred enum since + * 0.9.2. + */ +typedef enum { + VIR_DOMAIN_MEMORY_PARAM_INT = VIR_TYPED_PARAM_INT, + VIR_DOMAIN_MEMORY_PARAM_UINT = VIR_TYPED_PARAM_UINT, + VIR_DOMAIN_MEMORY_PARAM_LLONG = VIR_TYPED_PARAM_LLONG, + VIR_DOMAIN_MEMORY_PARAM_ULLONG = VIR_TYPED_PARAM_ULLONG, + VIR_DOMAIN_MEMORY_PARAM_DOUBLE = VIR_TYPED_PARAM_DOUBLE, + VIR_DOMAIN_MEMORY_PARAM_BOOLEAN = VIR_TYPED_PARAM_BOOLEAN, +} virMemoryParameterType; + +/** + * 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. + */ +# define VIR_DOMAIN_MEMORY_FIELD_LENGTH VIR_TYPED_PARAM_FIELD_LENGTH + +/** + * virMemoryParameter: + * + * a virMemoryParameter is the set of scheduler parameters. + * Provided for backwards compatibility; virTypedParameter is the + * preferred alias since 0.9.2. + */ +# define _virMemoryParameter _virTypedParameter +typedef struct _virTypedParameter virMemoryParameter; + +/** + * virMemoryParameterPtr: + * + * a virMemoryParameterPtr is a pointer to a virMemoryParameter structure. + * Provided for backwards compatibility; virTypedParameterPtr is the + * preferred alias since 0.9.2. + */ +typedef virMemoryParameter *virMemoryParameterPtr; + + +#endif /* __VIR_LIBVIRT_DOMAIN_H__ */ diff --git a/include/libvirt/libvirt.h.in b/include/libvirt/libvirt.h.in index 186b996..37d709a 100644 --- a/include/libvirt/libvirt.h.in +++ b/include/libvirt/libvirt.h.in @@ -96,253 +96,6 @@ typedef struct _virConnect virConnect; typedef virConnect *virConnectPtr; /** - * virDomain: - * - * a virDomain is a private structure representing a domain. - */ -typedef struct _virDomain virDomain; - -/** - * virDomainPtr: - * - * a virDomainPtr is pointer to a virDomain private structure, this is the - * type used to reference a domain in the API. - */ -typedef virDomain *virDomainPtr; - -/** - * virDomainState: - * - * A domain may be in different states at a given point in time - */ -typedef enum { - 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 */ - -#ifdef VIR_ENUM_SENTINELS - VIR_DOMAIN_LAST - /* - * 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. - */ -#endif -} virDomainState; - -typedef enum { - VIR_DOMAIN_NOSTATE_UNKNOWN = 0, - -#ifdef VIR_ENUM_SENTINELS - VIR_DOMAIN_NOSTATE_LAST -#endif -} virDomainNostateReason; - -typedef enum { - 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 */ - -#ifdef VIR_ENUM_SENTINELS - VIR_DOMAIN_RUNNING_LAST -#endif -} virDomainRunningReason; - -typedef enum { - VIR_DOMAIN_BLOCKED_UNKNOWN = 0, /* the reason is unknown */ - -#ifdef VIR_ENUM_SENTINELS - VIR_DOMAIN_BLOCKED_LAST -#endif -} virDomainBlockedReason; - -typedef enum { - 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 */ - -#ifdef VIR_ENUM_SENTINELS - VIR_DOMAIN_PAUSED_LAST -#endif -} virDomainPausedReason; - -typedef enum { - VIR_DOMAIN_SHUTDOWN_UNKNOWN = 0, /* the reason is unknown */ - VIR_DOMAIN_SHUTDOWN_USER = 1, /* shutting down on user request */ - -#ifdef VIR_ENUM_SENTINELS - VIR_DOMAIN_SHUTDOWN_LAST -#endif -} virDomainShutdownReason; - -typedef enum { - 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 */ -#ifdef VIR_ENUM_SENTINELS - VIR_DOMAIN_SHUTOFF_LAST -#endif -} virDomainShutoffReason; - -typedef enum { - VIR_DOMAIN_CRASHED_UNKNOWN = 0, /* crashed for unknown reason */ - VIR_DOMAIN_CRASHED_PANICKED = 1, /* domain panicked */ - -#ifdef VIR_ENUM_SENTINELS - VIR_DOMAIN_CRASHED_LAST -#endif -} virDomainCrashedReason; - -typedef enum { - VIR_DOMAIN_PMSUSPENDED_UNKNOWN = 0, - -#ifdef VIR_ENUM_SENTINELS - VIR_DOMAIN_PMSUSPENDED_LAST -#endif -} virDomainPMSuspendedReason; - -typedef enum { - VIR_DOMAIN_PMSUSPENDED_DISK_UNKNOWN = 0, - -#ifdef VIR_ENUM_SENTINELS - VIR_DOMAIN_PMSUSPENDED_DISK_LAST -#endif -} virDomainPMSuspendedDiskReason; - -/** - * virDomainControlState: - * - * Current state of a control interface to the domain. - */ -typedef enum { - 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 */ - -#ifdef VIR_ENUM_SENTINELS - VIR_DOMAIN_CONTROL_LAST -#endif -} virDomainControlState; - -/** - * virDomainControlInfo: - * - * Structure filled in by virDomainGetControlInfo and providing details about - * current state of control interface to a domain. - */ -typedef struct _virDomainControlInfo 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 (except for OK - and ERROR states) */ -}; - -/** - * virDomainControlInfoPtr: - * - * Pointer to virDomainControlInfo structure. - */ -typedef virDomainControlInfo *virDomainControlInfoPtr; - -/** - * virDomainModificationImpact: - * - * Several modification APIs take flags to determine whether a change - * to the domain affects just the running instance, just the - * persistent definition, or both at the same time. The counterpart - * query APIs also take the same flags to determine whether to query - * the running instance or persistent definition, although both cannot - * be queried at once. - * - * The use of VIR_DOMAIN_AFFECT_CURRENT will resolve to either - * VIR_DOMAIN_AFFECT_LIVE or VIR_DOMAIN_AFFECT_CONFIG according to - * current domain state. VIR_DOMAIN_AFFECT_LIVE requires a running - * domain, and VIR_DOMAIN_AFFECT_CONFIG requires a persistent domain - * (whether or not it is running). - * - * These enums should not conflict with those of virTypedParameterFlags. - */ -typedef enum { - VIR_DOMAIN_AFFECT_CURRENT = 0, /* Affect current domain state. */ - VIR_DOMAIN_AFFECT_LIVE = 1 << 0, /* Affect running domain state. */ - VIR_DOMAIN_AFFECT_CONFIG = 1 << 1, /* Affect persistent domain state. */ - /* 1 << 2 is reserved for virTypedParameterFlags */ -} virDomainModificationImpact; - -/** - * virDomainInfoPtr: - * - * a virDomainInfo is a structure filled by virDomainGetInfo() and extracting - * runtime information for a given active Domain - */ - -typedef struct _virDomainInfo 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 */ -}; - -/** - * virDomainInfoPtr: - * - * a virDomainInfoPtr is a pointer to a virDomainInfo structure. - */ - -typedef virDomainInfo *virDomainInfoPtr; - -/** - * virDomainCreateFlags: - * - * Flags OR'ed together to provide specific behaviour when creating a - * Domain. - */ -typedef enum { - VIR_DOMAIN_NONE = 0, /* Default behavior */ - VIR_DOMAIN_START_PAUSED = 1 << 0, /* Launch guest in paused state */ - VIR_DOMAIN_START_AUTODESTROY = 1 << 1, /* Automatically kill guest when virConnectPtr is closed */ - VIR_DOMAIN_START_BYPASS_CACHE = 1 << 2, /* Avoid file system cache pollution */ - VIR_DOMAIN_START_FORCE_BOOT = 1 << 3, /* Boot, discarding any managed save */ -} virDomainCreateFlags; - - -/** * virNodeSuspendTarget: * * Flags to indicate which system-wide sleep state the host must be @@ -867,657 +620,160 @@ int virNodeGetCPUMap(virConnectPtr conn, unsigned int flags); -/* Management of scheduler parameters */ - /** - * VIR_DOMAIN_SCHEDULER_CPU_SHARES: + * VIR_NODEINFO_MAXCPUS: + * @nodeinfo: virNodeInfo instance * - * Macro represents proportional weight of the scheduler used on the - * host cpu, when using the posix scheduler, as a ullong. + * This macro is to calculate the total number of CPUs supported + * but not necessary active in the host. */ -#define VIR_DOMAIN_SCHEDULER_CPU_SHARES "cpu_shares" -/** - * 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. - */ -#define VIR_DOMAIN_SCHEDULER_VCPU_PERIOD "vcpu_period" -/** - * 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. - */ -#define VIR_DOMAIN_SCHEDULER_VCPU_QUOTA "vcpu_quota" +#define VIR_NODEINFO_MAXCPUS(nodeinfo) ((nodeinfo).nodes*(nodeinfo).sockets*(nodeinfo).cores*(nodeinfo).threads) /** - * VIR_DOMAIN_SCHEDULER_EMULATOR_PERIOD: + * virNodeInfoPtr: * - * 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. + * a virNodeInfoPtr is a pointer to a virNodeInfo structure. */ -#define VIR_DOMAIN_SCHEDULER_EMULATOR_PERIOD "emulator_period" -/** - * 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. - */ -#define VIR_DOMAIN_SCHEDULER_EMULATOR_QUOTA "emulator_quota" +typedef virNodeInfo *virNodeInfoPtr; /** - * VIR_DOMAIN_SCHEDULER_WEIGHT: + * virNodeCPUStatsPtr: * - * Macro represents the relative weight, when using the credit - * scheduler, as a uint. + * a virNodeCPUStatsPtr is a pointer to a virNodeCPUStats structure. */ -#define VIR_DOMAIN_SCHEDULER_WEIGHT "weight" -/** - * VIR_DOMAIN_SCHEDULER_CAP: - * - * Macro represents the maximum scheduler cap, when using the credit - * scheduler, as a uint. - */ -#define VIR_DOMAIN_SCHEDULER_CAP "cap" +typedef virNodeCPUStats *virNodeCPUStatsPtr; /** - * VIR_DOMAIN_SCHEDULER_RESERVATION: + * virNodeMemoryStatsPtr: * - * Macro represents the scheduler reservation value, when using the - * allocation scheduler, as an llong. + * a virNodeMemoryStatsPtr is a pointer to a virNodeMemoryStats structure. */ -#define VIR_DOMAIN_SCHEDULER_RESERVATION "reservation" -/** - * VIR_DOMAIN_SCHEDULER_LIMIT: - * - * Macro represents the scheduler limit value, when using the - * allocation scheduler, as an llong. - */ -#define VIR_DOMAIN_SCHEDULER_LIMIT "limit" +typedef virNodeMemoryStats *virNodeMemoryStatsPtr; /** - * VIR_DOMAIN_SCHEDULER_SHARES: + * virConnectFlags * - * Macro represents the scheduler shares value, when using the - * allocation scheduler, as an int. + * Flags when opening a connection to a hypervisor */ -#define VIR_DOMAIN_SCHEDULER_SHARES "shares" +typedef enum { + VIR_CONNECT_RO = (1 << 0), /* A readonly connection */ + VIR_CONNECT_NO_ALIASES = (1 << 1), /* Don't try to resolve URI aliases */ +} virConnectFlags; -/* - * Fetch scheduler parameters, caller allocates 'params' field of size 'nparams' - */ -int virDomainGetSchedulerParameters (virDomainPtr domain, - virTypedParameterPtr params, - int *nparams); -int virDomainGetSchedulerParametersFlags (virDomainPtr domain, - virTypedParameterPtr params, - int *nparams, - unsigned int flags); -/* - * Change scheduler parameters - */ -int virDomainSetSchedulerParameters (virDomainPtr domain, - virTypedParameterPtr params, - int nparams); -int virDomainSetSchedulerParametersFlags (virDomainPtr domain, - virTypedParameterPtr params, - int nparams, - unsigned int flags); +typedef enum { + 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 */ -/** - * virDomainBlockStats: - * - * Block device stats for virDomainBlockStats. - * - * Hypervisors may return a field set to ((long long)-1) which indicates - * that the hypervisor does not support that statistic. - * - * NB. Here 'long long' means 64 bit integer. - */ -typedef struct _virDomainBlockStats 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'. */ +#ifdef VIR_ENUM_SENTINELS + VIR_CRED_LAST /* More may be added - expect the unexpected */ +#endif +} virConnectCredentialType; + +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 */ }; -/** - * virDomainBlockStatsPtr: - * - * A pointer to a virDomainBlockStats structure - */ -typedef virDomainBlockStatsStruct *virDomainBlockStatsPtr; +typedef struct _virConnectCredential virConnectCredential; +typedef virConnectCredential *virConnectCredentialPtr; /** - * VIR_DOMAIN_BLOCK_STATS_FIELD_LENGTH: + * virConnectAuthCallbackPtr: + * @cred: list of virConnectCredential object to fetch from user + * @ncred: size of cred list + * @cbdata: opaque data passed to virConnectOpenAuth * - * Macro providing the field length of parameter names when using - * virDomainBlockStatsFlags(). - */ -#define VIR_DOMAIN_BLOCK_STATS_FIELD_LENGTH VIR_TYPED_PARAM_FIELD_LENGTH - -/** - * VIR_DOMAIN_BLOCK_STATS_READ_BYTES: + * 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. * - * Macro represents the total number of read bytes of the - * block device, as an llong. + * Returns 0 if all interactions were filled, or -1 upon error */ -#define VIR_DOMAIN_BLOCK_STATS_READ_BYTES "rd_bytes" +typedef int (*virConnectAuthCallbackPtr)(virConnectCredentialPtr cred, + unsigned int ncred, + void *cbdata); -/** - * VIR_DOMAIN_BLOCK_STATS_READ_REQ: - * - * Macro represents the total read requests of the - * block device, as an llong. - */ -#define VIR_DOMAIN_BLOCK_STATS_READ_REQ "rd_operations" +struct _virConnectAuth { + int *credtype; /* List of supported virConnectCredentialType values */ + unsigned int ncredtype; -/** - * 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. - */ -#define VIR_DOMAIN_BLOCK_STATS_READ_TOTAL_TIMES "rd_total_times" + virConnectAuthCallbackPtr cb; /* Callback used to collect credentials */ + void *cbdata; +}; -/** - * VIR_DOMAIN_BLOCK_STATS_WRITE_BYTES: - * - * Macro represents the total number of write bytes of the - * block device, as an llong. - */ -#define VIR_DOMAIN_BLOCK_STATS_WRITE_BYTES "wr_bytes" -/** - * VIR_DOMAIN_BLOCK_STATS_WRITE_REQ: - * - * Macro represents the total write requests of the - * block device, as an llong. - */ -#define VIR_DOMAIN_BLOCK_STATS_WRITE_REQ "wr_operations" +typedef struct _virConnectAuth virConnectAuth; +typedef virConnectAuth *virConnectAuthPtr; -/** - * 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. - */ -#define VIR_DOMAIN_BLOCK_STATS_WRITE_TOTAL_TIMES "wr_total_times" +VIR_EXPORT_VAR virConnectAuthPtr virConnectAuthPtrDefault; /** - * VIR_DOMAIN_BLOCK_STATS_FLUSH_REQ: + * VIR_UUID_BUFLEN: * - * Macro represents the total flush requests of the - * block device, as an llong. + * This macro provides the length of the buffer required + * for virDomainGetUUID() */ -#define VIR_DOMAIN_BLOCK_STATS_FLUSH_REQ "flush_operations" -/** - * 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. - */ -#define VIR_DOMAIN_BLOCK_STATS_FLUSH_TOTAL_TIMES "flush_total_times" +#define VIR_UUID_BUFLEN (16) /** - * VIR_DOMAIN_BLOCK_STATS_ERRS: + * VIR_UUID_STRING_BUFLEN: * - * In Xen this returns the mysterious 'oo_req', as an llong. + * This macro provides the length of the buffer required + * for virDomainGetUUIDString() */ -#define VIR_DOMAIN_BLOCK_STATS_ERRS "errs" + +#define VIR_UUID_STRING_BUFLEN (36+1) + +/* library versioning */ /** - * virDomainInterfaceStats: - * - * Network interface stats for virDomainInterfaceStats. - * - * Hypervisors may return a field set to ((long long)-1) which indicates - * that the hypervisor does not support that statistic. + * LIBVIR_VERSION_NUMBER: * - * NB. Here 'long long' means 64 bit integer. + * Macro providing the version of the library as + * version * 1,000,000 + minor * 1000 + micro */ -typedef struct _virDomainInterfaceStats 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; -}; + +#define LIBVIR_VERSION_NUMBER @LIBVIRT_VERSION_NUMBER@ /** - * virDomainInterfaceStatsPtr: + * LIBVIR_CHECK_VERSION: + * @major: major component of the version number + * @minor: minor component of the version number + * @micro: micro component of the version number * - * A pointer to a virDomainInterfaceStats structure + * 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 */ -typedef virDomainInterfaceStatsStruct *virDomainInterfaceStatsPtr; +#define LIBVIR_CHECK_VERSION(major, minor, micro) \ + ((major) * 1000000 + (minor) * 1000 + (micro) <= LIBVIR_VERSION_NUMBER) -/** - * Memory Statistics Tags: - */ -typedef enum { - /* The total amount of data read from swap space (in kB). */ - 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, - -#ifdef VIR_ENUM_SENTINELS - VIR_DOMAIN_MEMORY_STAT_LAST = VIR_DOMAIN_MEMORY_STAT_NR -#endif -} virDomainMemoryStatTags; - -typedef struct _virDomainMemoryStat virDomainMemoryStatStruct; - -struct _virDomainMemoryStat { - int tag; - unsigned long long val; -}; - -typedef virDomainMemoryStatStruct *virDomainMemoryStatPtr; - - -/* Domain core dump flags. */ -typedef enum { - VIR_DUMP_CRASH = (1 << 0), /* crash after dump */ - VIR_DUMP_LIVE = (1 << 1), /* live dump */ - VIR_DUMP_BYPASS_CACHE = (1 << 2), /* avoid file system cache pollution */ - VIR_DUMP_RESET = (1 << 3), /* reset domain after dump finishes */ - VIR_DUMP_MEMORY_ONLY = (1 << 4), /* use dump-guest-memory */ -} virDomainCoreDumpFlags; - -/** - * virDomainCoreDumpFormat: - * - * Values for specifying different formats of domain core dumps. - */ -typedef enum { - VIR_DOMAIN_CORE_DUMP_FORMAT_RAW, /* dump guest memory in raw format */ - VIR_DOMAIN_CORE_DUMP_FORMAT_KDUMP_ZLIB, /* kdump-compressed format, with - * zlib compression */ - VIR_DOMAIN_CORE_DUMP_FORMAT_KDUMP_LZO, /* kdump-compressed format, with - * lzo compression */ - VIR_DOMAIN_CORE_DUMP_FORMAT_KDUMP_SNAPPY, /* kdump-compressed format, with - * snappy compression */ -#ifdef VIR_ENUM_SENTINELS - VIR_DOMAIN_CORE_DUMP_FORMAT_LAST - /* - * 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. - */ -#endif -} virDomainCoreDumpFormat; - -/* Domain migration flags. */ -typedef enum { - VIR_MIGRATE_LIVE = (1 << 0), /* live migration */ - VIR_MIGRATE_PEER2PEER = (1 << 1), /* 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 = (1 << 2), /* tunnel migration data over libvirtd connection */ - VIR_MIGRATE_PERSIST_DEST = (1 << 3), /* persist the VM on the destination */ - VIR_MIGRATE_UNDEFINE_SOURCE = (1 << 4), /* undefine the VM on the source */ - VIR_MIGRATE_PAUSED = (1 << 5), /* pause on remote side */ - VIR_MIGRATE_NON_SHARED_DISK = (1 << 6), /* migration with non-shared storage with full disk copy */ - VIR_MIGRATE_NON_SHARED_INC = (1 << 7), /* migration with non-shared storage with incremental copy */ - /* (same base image shared between source and destination) */ - VIR_MIGRATE_CHANGE_PROTECTION = (1 << 8), /* protect for changing domain configuration through the - * whole migration process; this will be used automatically - * when supported */ - VIR_MIGRATE_UNSAFE = (1 << 9), /* force migration even if it is considered unsafe */ - VIR_MIGRATE_OFFLINE = (1 << 10), /* offline migrate */ - VIR_MIGRATE_COMPRESSED = (1 << 11), /* compress data during migration */ - VIR_MIGRATE_ABORT_ON_ERROR = (1 << 12), /* abort migration on I/O errors happened during migration */ - VIR_MIGRATE_AUTO_CONVERGE = (1 << 13), /* force convergence */ - VIR_MIGRATE_RDMA_PIN_ALL = (1 << 14), /* RDMA memory pinning */ -} virDomainMigrateFlags; - - -/** - * 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. - */ -#define VIR_MIGRATE_PARAM_URI "migrate_uri" - -/** - * 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. - */ -#define VIR_MIGRATE_PARAM_DEST_NAME "destination_name" - -/** - * 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. - */ -#define VIR_MIGRATE_PARAM_DEST_XML "destination_xml" - -/** - * 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. - */ -#define VIR_MIGRATE_PARAM_BANDWIDTH "bandwidth" - -/** - * 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 - */ -#define VIR_MIGRATE_PARAM_GRAPHICS_URI "graphics_uri" - -/** - * 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. - */ -#define VIR_MIGRATE_PARAM_LISTEN_ADDRESS "listen_address" - -/* Domain migration. */ -virDomainPtr virDomainMigrate (virDomainPtr domain, virConnectPtr dconn, - unsigned long flags, const char *dname, - const char *uri, unsigned long bandwidth); -virDomainPtr virDomainMigrate2(virDomainPtr domain, virConnectPtr dconn, - const char *dxml, - unsigned long flags, const char *dname, - const char *uri, unsigned long bandwidth); -virDomainPtr virDomainMigrate3(virDomainPtr domain, - virConnectPtr dconn, - virTypedParameterPtr params, - unsigned int nparams, - unsigned int flags); - -int virDomainMigrateToURI (virDomainPtr domain, const char *duri, - unsigned long flags, const char *dname, - unsigned long bandwidth); - -int virDomainMigrateToURI2(virDomainPtr domain, - const char *dconnuri, - const char *miguri, - const char *dxml, - unsigned long flags, - const char *dname, - unsigned long bandwidth); -int virDomainMigrateToURI3(virDomainPtr domain, - const char *dconnuri, - virTypedParameterPtr params, - unsigned int nparams, - unsigned int flags); - -int virDomainMigrateSetMaxDowntime (virDomainPtr domain, - unsigned long long downtime, - unsigned int flags); - -int virDomainMigrateGetCompressionCache(virDomainPtr domain, - unsigned long long *cacheSize, - unsigned int flags); -int virDomainMigrateSetCompressionCache(virDomainPtr domain, - unsigned long long cacheSize, - unsigned int flags); - -int virDomainMigrateSetMaxSpeed(virDomainPtr domain, - unsigned long bandwidth, - unsigned int flags); - -int virDomainMigrateGetMaxSpeed(virDomainPtr domain, - unsigned long *bandwidth, - unsigned int flags); - -/** - * VIR_NODEINFO_MAXCPUS: - * @nodeinfo: virNodeInfo instance - * - * This macro is to calculate the total number of CPUs supported - * but not necessary active in the host. - */ - - -#define VIR_NODEINFO_MAXCPUS(nodeinfo) ((nodeinfo).nodes*(nodeinfo).sockets*(nodeinfo).cores*(nodeinfo).threads) - -/** - * virNodeInfoPtr: - * - * a virNodeInfoPtr is a pointer to a virNodeInfo structure. - */ - -typedef virNodeInfo *virNodeInfoPtr; - -/** - * virNodeCPUStatsPtr: - * - * a virNodeCPUStatsPtr is a pointer to a virNodeCPUStats structure. - */ - -typedef virNodeCPUStats *virNodeCPUStatsPtr; - -/** - * virNodeMemoryStatsPtr: - * - * a virNodeMemoryStatsPtr is a pointer to a virNodeMemoryStats structure. - */ - -typedef virNodeMemoryStats *virNodeMemoryStatsPtr; - -/** - * virConnectFlags - * - * Flags when opening a connection to a hypervisor - */ -typedef enum { - VIR_CONNECT_RO = (1 << 0), /* A readonly connection */ - VIR_CONNECT_NO_ALIASES = (1 << 1), /* Don't try to resolve URI aliases */ -} virConnectFlags; - - -typedef enum { - 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 */ - -#ifdef VIR_ENUM_SENTINELS - VIR_CRED_LAST /* More may be added - expect the unexpected */ -#endif -} virConnectCredentialType; - -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 */ -}; - -typedef struct _virConnectCredential virConnectCredential; -typedef virConnectCredential *virConnectCredentialPtr; - - -/** - * virConnectAuthCallbackPtr: - * @cred: list of virConnectCredential object to fetch from user - * @ncred: size of cred list - * @cbdata: opaque data passed to virConnectOpenAuth - * - * 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. - * - * Returns 0 if all interactions were filled, or -1 upon error - */ -typedef int (*virConnectAuthCallbackPtr)(virConnectCredentialPtr cred, - unsigned int ncred, - void *cbdata); - -struct _virConnectAuth { - int *credtype; /* List of supported virConnectCredentialType values */ - unsigned int ncredtype; - - virConnectAuthCallbackPtr cb; /* Callback used to collect credentials */ - void *cbdata; -}; - - -typedef struct _virConnectAuth virConnectAuth; -typedef virConnectAuth *virConnectAuthPtr; - -VIR_EXPORT_VAR virConnectAuthPtr virConnectAuthPtrDefault; - -/** - * VIR_UUID_BUFLEN: - * - * This macro provides the length of the buffer required - * for virDomainGetUUID() - */ - -#define VIR_UUID_BUFLEN (16) - -/** - * VIR_UUID_STRING_BUFLEN: - * - * This macro provides the length of the buffer required - * for virDomainGetUUIDString() - */ - -#define VIR_UUID_STRING_BUFLEN (36+1) - -/* library versioning */ - -/** - * LIBVIR_VERSION_NUMBER: - * - * Macro providing the version of the library as - * version * 1,000,000 + minor * 1000 + micro - */ - -#define LIBVIR_VERSION_NUMBER @LIBVIRT_VERSION_NUMBER@ - -/** - * LIBVIR_CHECK_VERSION: - * @major: major component of the version number - * @minor: minor component of the version number - * @micro: micro component of the version number - * - * 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 - */ -#define LIBVIR_CHECK_VERSION(major, minor, micro) \ - ((major) * 1000000 + (minor) * 1000 + (micro) <= LIBVIR_VERSION_NUMBER) - -int virGetVersion (unsigned long *libVer, - const char *type, - unsigned long *typeVer); +int virGetVersion (unsigned long *libVer, + const char *type, + unsigned long *typeVer); /* * Connection and disconnections to the Hypervisor @@ -1586,13 +842,6 @@ int virNodeGetInfo (virConnectPtr conn, virNodeInfoPtr info); char * virConnectGetCapabilities (virConnectPtr conn); -char * virConnectGetDomainCapabilities(virConnectPtr conn, - const char *emulatorbin, - const char *arch, - const char *machine, - const char *virttype, - unsigned int flags); - int virNodeGetCPUStats (virConnectPtr conn, int cpuNum, virNodeCPUStatsPtr params, @@ -1616,2643 +865,62 @@ int virNodeSuspendForDuration (virConnectPtr conn, unsigned int flags); /* - * Gather list of running domains + * NUMA support */ -int virConnectListDomains (virConnectPtr conn, - int *ids, - int maxids); -/* - * Number of domains - */ -int virConnectNumOfDomains (virConnectPtr conn); +int virNodeGetCellsFreeMemory(virConnectPtr conn, + unsigned long long *freeMems, + int startCell, + int maxCells); -/* - * Get connection from domain. - */ -virConnectPtr virDomainGetConnect (virDomainPtr domain); +int virConnectIsEncrypted(virConnectPtr conn); +int virConnectIsSecure(virConnectPtr conn); +int virConnectIsAlive(virConnectPtr conn); /* - * Domain creation and destruction + * CPU specification API */ -virDomainPtr virDomainCreateXML (virConnectPtr conn, - const char *xmlDesc, - unsigned int flags); -virDomainPtr virDomainCreateXMLWithFiles(virConnectPtr conn, - const char *xmlDesc, - unsigned int nfiles, - int *files, - unsigned int flags); -virDomainPtr virDomainLookupByName (virConnectPtr conn, - const char *name); -virDomainPtr virDomainLookupByID (virConnectPtr conn, - int id); -virDomainPtr virDomainLookupByUUID (virConnectPtr conn, - const unsigned char *uuid); -virDomainPtr virDomainLookupByUUIDString (virConnectPtr conn, - const char *uuid); - typedef enum { - VIR_DOMAIN_SHUTDOWN_DEFAULT = 0, /* hypervisor choice */ - VIR_DOMAIN_SHUTDOWN_ACPI_POWER_BTN = (1 << 0), /* Send ACPI event */ - VIR_DOMAIN_SHUTDOWN_GUEST_AGENT = (1 << 1), /* Use guest agent */ - VIR_DOMAIN_SHUTDOWN_INITCTL = (1 << 2), /* Use initctl */ - VIR_DOMAIN_SHUTDOWN_SIGNAL = (1 << 3), /* Send a signal */ - VIR_DOMAIN_SHUTDOWN_PARAVIRT = (1 << 4), /* Use paravirt guest control */ -} virDomainShutdownFlagValues; - -int virDomainShutdown (virDomainPtr domain); -int virDomainShutdownFlags (virDomainPtr domain, - unsigned int flags); + VIR_CPU_COMPARE_ERROR = -1, + VIR_CPU_COMPARE_INCOMPATIBLE = 0, + VIR_CPU_COMPARE_IDENTICAL = 1, + VIR_CPU_COMPARE_SUPERSET = 2, + +#ifdef VIR_ENUM_SENTINELS + VIR_CPU_COMPARE_LAST +#endif +} virCPUCompareResult; typedef enum { - VIR_DOMAIN_REBOOT_DEFAULT = 0, /* hypervisor choice */ - VIR_DOMAIN_REBOOT_ACPI_POWER_BTN = (1 << 0), /* Send ACPI event */ - VIR_DOMAIN_REBOOT_GUEST_AGENT = (1 << 1), /* Use guest agent */ - VIR_DOMAIN_REBOOT_INITCTL = (1 << 2), /* Use initctl */ - VIR_DOMAIN_REBOOT_SIGNAL = (1 << 3), /* Send a signal */ - VIR_DOMAIN_REBOOT_PARAVIRT = (1 << 4), /* Use paravirt guest control */ -} virDomainRebootFlagValues; - -int virDomainReboot (virDomainPtr domain, - unsigned int flags); -int virDomainReset (virDomainPtr domain, - unsigned int flags); + VIR_CONNECT_COMPARE_CPU_FAIL_INCOMPATIBLE = (1 << 0), /* treat incompatible + CPUs as failure */ +} virConnectCompareCPUFlags; + +int virConnectCompareCPU(virConnectPtr conn, + const char *xmlDesc, + unsigned int flags); -int virDomainDestroy (virDomainPtr domain); +int virConnectGetCPUModelNames(virConnectPtr conn, + const char *arch, + char ***models, + unsigned int flags); /** - * virDomainDestroyFlagsValues: + * virConnectBaselineCPUFlags * - * Flags used to provide specific behaviour to the - * virDomainDestroyFlags() function + * Flags when getting XML description of a computed CPU */ typedef enum { - VIR_DOMAIN_DESTROY_DEFAULT = 0, /* Default behavior - could lead to data loss!! */ - VIR_DOMAIN_DESTROY_GRACEFUL = 1 << 0, /* only SIGTERM, no SIGKILL */ -} virDomainDestroyFlagsValues; - -int virDomainDestroyFlags (virDomainPtr domain, - unsigned int flags); -int virDomainRef (virDomainPtr domain); -int virDomainFree (virDomainPtr domain); - -/* - * Domain suspend/resume - */ -int virDomainSuspend (virDomainPtr domain); -int virDomainResume (virDomainPtr domain); -int virDomainPMSuspendForDuration (virDomainPtr domain, - unsigned int target, - unsigned long long duration, - unsigned int flags); -int virDomainPMWakeup (virDomainPtr domain, - unsigned int flags); -/* - * Domain save/restore - */ - -/** - * virDomainSaveRestoreFlags: - * Flags for use in virDomainSaveFlags(), virDomainManagedSave(), - * virDomainRestoreFlags(), and virDomainSaveImageDefineXML(). Not all - * flags apply to all these functions. - */ -typedef enum { - VIR_DOMAIN_SAVE_BYPASS_CACHE = 1 << 0, /* Avoid file system cache pollution */ - VIR_DOMAIN_SAVE_RUNNING = 1 << 1, /* Favor running over paused */ - VIR_DOMAIN_SAVE_PAUSED = 1 << 2, /* Favor paused over running */ -} virDomainSaveRestoreFlags; - -int virDomainSave (virDomainPtr domain, - const char *to); -int virDomainSaveFlags (virDomainPtr domain, - const char *to, - const char *dxml, - unsigned int flags); -int virDomainRestore (virConnectPtr conn, - const char *from); -int virDomainRestoreFlags (virConnectPtr conn, - const char *from, - const char *dxml, - unsigned int flags); - -char * virDomainSaveImageGetXMLDesc (virConnectPtr conn, - const char *file, - unsigned int flags); -int virDomainSaveImageDefineXML (virConnectPtr conn, - const char *file, - const char *dxml, - unsigned int flags); - -/* - * Managed domain save - */ -int virDomainManagedSave (virDomainPtr dom, - unsigned int flags); -int virDomainHasManagedSaveImage(virDomainPtr dom, - unsigned int flags); -int virDomainManagedSaveRemove(virDomainPtr dom, - unsigned int flags); - -/* - * Domain core dump - */ -int virDomainCoreDump (virDomainPtr domain, - const char *to, - unsigned int flags); - -/* - * Domain core dump with format specified - */ -int virDomainCoreDumpWithFormat (virDomainPtr domain, - const char *to, - unsigned int dumpformat, - unsigned int flags); - -/* - * Screenshot of current domain console - */ -char * virDomainScreenshot (virDomainPtr domain, - virStreamPtr stream, - unsigned int screen, - unsigned int flags); - -/* - * Domain runtime information, and collecting CPU statistics - */ - -int virDomainGetInfo (virDomainPtr domain, - virDomainInfoPtr info); -int virDomainGetState (virDomainPtr domain, - int *state, - int *reason, - unsigned int flags); - -/** - * VIR_DOMAIN_CPU_STATS_CPUTIME: - * cpu usage (sum of both vcpu and hypervisor usage) in nanoseconds, - * as a ullong - */ -#define VIR_DOMAIN_CPU_STATS_CPUTIME "cpu_time" - -/** - * VIR_DOMAIN_CPU_STATS_USERTIME: - * cpu time charged to user instructions in nanoseconds, as a ullong - */ -#define VIR_DOMAIN_CPU_STATS_USERTIME "user_time" - -/** - * VIR_DOMAIN_CPU_STATS_SYSTEMTIME: - * cpu time charged to system instructions in nanoseconds, as a ullong - */ -#define VIR_DOMAIN_CPU_STATS_SYSTEMTIME "system_time" - -/** - * VIR_DOMAIN_CPU_STATS_VCPUTIME: - * vcpu usage in nanoseconds (cpu_time excluding hypervisor time), - * as a ullong - */ -#define VIR_DOMAIN_CPU_STATS_VCPUTIME "vcpu_time" - -int virDomainGetCPUStats(virDomainPtr domain, - virTypedParameterPtr params, - unsigned int nparams, - int start_cpu, - unsigned int ncpus, - unsigned int flags); - -int virDomainGetControlInfo (virDomainPtr domain, - virDomainControlInfoPtr info, - unsigned int flags); - -/* - * Return scheduler type in effect 'sedf', 'credit', 'linux' - */ -char * virDomainGetSchedulerType(virDomainPtr domain, - int *nparams); - - -/* Manage blkio parameters. */ - -/** - * VIR_DOMAIN_BLKIO_WEIGHT: - * - * Macro for the Blkio tunable weight: it represents the io weight - * the guest can use, as a uint. - */ - -#define VIR_DOMAIN_BLKIO_WEIGHT "weight" - -/** - * 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 ','. - */ - -#define VIR_DOMAIN_BLKIO_DEVICE_WEIGHT "device_weight" - -/** - * 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 ','. - */ - -#define VIR_DOMAIN_BLKIO_DEVICE_READ_IOPS "device_read_iops_sec" - - -/** - * 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 ','. - */ -#define VIR_DOMAIN_BLKIO_DEVICE_WRITE_IOPS "device_write_iops_sec" - - -/** - * 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 ','. - */ -#define VIR_DOMAIN_BLKIO_DEVICE_READ_BPS "device_read_bytes_sec" - - -/** - * 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 ','. - */ -#define VIR_DOMAIN_BLKIO_DEVICE_WRITE_BPS "device_write_bytes_sec" - - -/* Set Blkio tunables for the domain*/ -int virDomainSetBlkioParameters(virDomainPtr domain, - virTypedParameterPtr params, - int nparams, unsigned int flags); -int virDomainGetBlkioParameters(virDomainPtr domain, - virTypedParameterPtr params, - int *nparams, unsigned int flags); - -/* Manage memory parameters. */ - -/** - * VIR_DOMAIN_MEMORY_PARAM_UNLIMITED: - * - * Macro providing the virMemoryParameter value that indicates "unlimited" - */ - -#define VIR_DOMAIN_MEMORY_PARAM_UNLIMITED 9007199254740991LL /* = INT64_MAX >> 10 */ - -/** - * VIR_DOMAIN_MEMORY_HARD_LIMIT: - * - * Macro for the memory tunable hard_limit: it represents the maximum memory - * the guest can use, as a ullong. - */ - -#define VIR_DOMAIN_MEMORY_HARD_LIMIT "hard_limit" - -/** - * 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. - */ - -#define VIR_DOMAIN_MEMORY_SOFT_LIMIT "soft_limit" - -/** - * 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. - */ - -#define VIR_DOMAIN_MEMORY_MIN_GUARANTEE "min_guarantee" - -/** - * 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. - */ - -#define VIR_DOMAIN_MEMORY_SWAP_HARD_LIMIT "swap_hard_limit" - -/* Set memory tunables for the domain*/ -int virDomainSetMemoryParameters(virDomainPtr domain, - virTypedParameterPtr params, - int nparams, unsigned int flags); -int virDomainGetMemoryParameters(virDomainPtr domain, - virTypedParameterPtr params, - int *nparams, unsigned int flags); - -/* Memory size modification flags. */ -typedef enum { - /* See virDomainModificationImpact for these flags. */ - VIR_DOMAIN_MEM_CURRENT = VIR_DOMAIN_AFFECT_CURRENT, - VIR_DOMAIN_MEM_LIVE = VIR_DOMAIN_AFFECT_LIVE, - VIR_DOMAIN_MEM_CONFIG = VIR_DOMAIN_AFFECT_CONFIG, - - /* Additionally, these flags may be bitwise-OR'd in. */ - VIR_DOMAIN_MEM_MAXIMUM = (1 << 2), /* affect Max rather than current */ -} virDomainMemoryModFlags; - - -/* Manage numa parameters */ - -/** - * virDomainNumatuneMemMode: - * Representation of the various modes in the <numatune> element of - * a domain. - */ -typedef enum { - VIR_DOMAIN_NUMATUNE_MEM_STRICT = 0, - VIR_DOMAIN_NUMATUNE_MEM_PREFERRED = 1, - VIR_DOMAIN_NUMATUNE_MEM_INTERLEAVE = 2, - -#ifdef VIR_ENUM_SENTINELS - VIR_DOMAIN_NUMATUNE_MEM_LAST /* This constant is subject to change */ -#endif -} virDomainNumatuneMemMode; - -/** - * VIR_DOMAIN_NUMA_NODESET: - * - * Macro for typed parameter name that lists the numa nodeset of a - * domain, as a string. - */ -#define VIR_DOMAIN_NUMA_NODESET "numa_nodeset" - -/** - * VIR_DOMAIN_NUMA_MODE: - * - * Macro for typed parameter name that lists the numa mode of a domain, - * as an int containing a virDomainNumatuneMemMode value. - */ -#define VIR_DOMAIN_NUMA_MODE "numa_mode" - -int virDomainSetNumaParameters(virDomainPtr domain, - virTypedParameterPtr params, - int nparams, unsigned int flags); -int virDomainGetNumaParameters(virDomainPtr domain, - virTypedParameterPtr params, - int *nparams, unsigned int flags); - -/* - * Dynamic control of domains - */ -const char * virDomainGetName (virDomainPtr domain); -unsigned int virDomainGetID (virDomainPtr domain); -int virDomainGetUUID (virDomainPtr domain, - unsigned char *uuid); -int virDomainGetUUIDString (virDomainPtr domain, - char *buf); -char * virDomainGetOSType (virDomainPtr domain); -unsigned long virDomainGetMaxMemory (virDomainPtr domain); -int virDomainSetMaxMemory (virDomainPtr domain, - unsigned long memory); -int virDomainSetMemory (virDomainPtr domain, - unsigned long memory); -int virDomainSetMemoryFlags (virDomainPtr domain, - unsigned long memory, - unsigned int flags); -int virDomainSetMemoryStatsPeriod (virDomainPtr domain, - int period, - unsigned int flags); -int virDomainGetMaxVcpus (virDomainPtr domain); -int virDomainGetSecurityLabel (virDomainPtr domain, - virSecurityLabelPtr seclabel); -char * virDomainGetHostname (virDomainPtr domain, - unsigned int flags); -int virDomainGetSecurityLabelList (virDomainPtr domain, - virSecurityLabelPtr* seclabels); - -typedef enum { - VIR_DOMAIN_METADATA_DESCRIPTION = 0, /* Operate on <description> */ - VIR_DOMAIN_METADATA_TITLE = 1, /* Operate on <title> */ - VIR_DOMAIN_METADATA_ELEMENT = 2, /* Operate on <metadata> */ - -#ifdef VIR_ENUM_SENTINELS - VIR_DOMAIN_METADATA_LAST -#endif -} virDomainMetadataType; - -int -virDomainSetMetadata(virDomainPtr domain, - int type, - const char *metadata, - const char *key, - const char *uri, - unsigned int flags); - -char * -virDomainGetMetadata(virDomainPtr domain, - int type, - const char *uri, - unsigned int flags); - -/* - * XML domain description - */ -/** - * virDomainXMLFlags: - * - * Flags available for virDomainGetXMLDesc - */ - -typedef enum { - VIR_DOMAIN_XML_SECURE = (1 << 0), /* dump security sensitive information too */ - VIR_DOMAIN_XML_INACTIVE = (1 << 1), /* dump inactive domain information */ - VIR_DOMAIN_XML_UPDATE_CPU = (1 << 2), /* update guest CPU requirements according to host CPU */ - VIR_DOMAIN_XML_MIGRATABLE = (1 << 3), /* dump XML suitable for migration */ -} virDomainXMLFlags; - -char * virDomainGetXMLDesc (virDomainPtr domain, - unsigned int flags); - - -char * virConnectDomainXMLFromNative(virConnectPtr conn, - const char *nativeFormat, - const char *nativeConfig, - unsigned int flags); -char * virConnectDomainXMLToNative(virConnectPtr conn, - const char *nativeFormat, - const char *domainXml, - unsigned int flags); - -int virDomainBlockStats (virDomainPtr dom, - const char *disk, - virDomainBlockStatsPtr stats, - size_t size); -int virDomainBlockStatsFlags (virDomainPtr dom, - const char *disk, - virTypedParameterPtr params, - int *nparams, - unsigned int flags); -int virDomainInterfaceStats (virDomainPtr dom, - const char *path, - virDomainInterfaceStatsPtr stats, - size_t size); - -/* Management of interface parameters */ - -/** - * VIR_DOMAIN_BANDWIDTH_IN_AVERAGE: - * - * Macro represents the inbound average of NIC bandwidth, as a uint. - */ -#define VIR_DOMAIN_BANDWIDTH_IN_AVERAGE "inbound.average" - -/** - * VIR_DOMAIN_BANDWIDTH_IN_PEAK: - * - * Macro represents the inbound peak of NIC bandwidth, as a uint. - */ -#define VIR_DOMAIN_BANDWIDTH_IN_PEAK "inbound.peak" - -/** - * VIR_DOMAIN_BANDWIDTH_IN_BURST: - * - * Macro represents the inbound burst of NIC bandwidth, as a uint. - */ -#define VIR_DOMAIN_BANDWIDTH_IN_BURST "inbound.burst" - -/** - * VIR_DOMAIN_BANDWIDTH_OUT_AVERAGE: - * - * Macro represents the outbound average of NIC bandwidth, as a uint. - */ -#define VIR_DOMAIN_BANDWIDTH_OUT_AVERAGE "outbound.average" - -/** - * VIR_DOMAIN_BANDWIDTH_OUT_PEAK: - * - * Macro represents the outbound peak of NIC bandwidth, as a uint. - */ -#define VIR_DOMAIN_BANDWIDTH_OUT_PEAK "outbound.peak" - -/** - * VIR_DOMAIN_BANDWIDTH_OUT_BURST: - * - * Macro represents the outbound burst of NIC bandwidth, as a uint. - */ -#define VIR_DOMAIN_BANDWIDTH_OUT_BURST "outbound.burst" - -int virDomainSetInterfaceParameters (virDomainPtr dom, - const char *device, - virTypedParameterPtr params, - int nparams, unsigned int flags); -int virDomainGetInterfaceParameters (virDomainPtr dom, - const char *device, - virTypedParameterPtr params, - int *nparams, unsigned int flags); - -/* Management of domain block devices */ - -int virDomainBlockPeek (virDomainPtr dom, - const char *disk, - unsigned long long offset, - size_t size, - void *buffer, - unsigned int flags); - -/** - * virDomainBlockResizeFlags: - * - * Flags available for virDomainBlockResize(). - */ -typedef enum { - VIR_DOMAIN_BLOCK_RESIZE_BYTES = 1 << 0, /* size in bytes instead of KiB */ -} virDomainBlockResizeFlags; - -int virDomainBlockResize (virDomainPtr dom, - const char *disk, - unsigned long long size, - unsigned int flags); - -/** virDomainBlockInfo: - * - * This struct provides information about the size of a block device - * backing store - * - * Examples: - * - * - Fully allocated raw file in filesystem: - * * capacity, allocation, physical: All the same - * - * - Sparse raw file in filesystem: - * * capacity: logical size of the file - * * allocation, physical: number of blocks allocated to file - * - * - qcow2 file in filesystem - * * capacity: logical size from qcow2 header - * * allocation, physical: logical size of the file / - * highest qcow extent (identical) - * - * - qcow2 file in a block device - * * capacity: logical size from qcow2 header - * * allocation: highest qcow extent written for an active domain - * * physical: size of the block device container - */ -typedef struct _virDomainBlockInfo virDomainBlockInfo; -typedef virDomainBlockInfo *virDomainBlockInfoPtr; -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 */ -}; - -int virDomainGetBlockInfo(virDomainPtr dom, - const char *disk, - virDomainBlockInfoPtr info, - unsigned int flags); - -/* Management of domain memory */ - -int virDomainMemoryStats (virDomainPtr dom, - virDomainMemoryStatPtr stats, - unsigned int nr_stats, - unsigned int flags); - -/* Memory peeking flags. */ - -typedef enum { - VIR_MEMORY_VIRTUAL = 1 << 0, /* addresses are virtual addresses */ - VIR_MEMORY_PHYSICAL = 1 << 1, /* addresses are physical addresses */ -} virDomainMemoryFlags; - -int virDomainMemoryPeek (virDomainPtr dom, - unsigned long long start, - size_t size, - void *buffer, - unsigned int flags); - -/* - * defined but not running domains - */ -virDomainPtr virDomainDefineXML (virConnectPtr conn, - const char *xml); -int virDomainUndefine (virDomainPtr domain); - -typedef enum { - VIR_DOMAIN_UNDEFINE_MANAGED_SAVE = (1 << 0), /* Also remove any - managed save */ - VIR_DOMAIN_UNDEFINE_SNAPSHOTS_METADATA = (1 << 1), /* If last use of domain, - then also remove any - snapshot metadata */ - VIR_DOMAIN_UNDEFINE_NVRAM = (1 << 2), /* Also remove any - nvram file */ - - /* Future undefine control flags should come here. */ -} virDomainUndefineFlagsValues; - - -int virDomainUndefineFlags (virDomainPtr domain, - unsigned int flags); -int virConnectNumOfDefinedDomains (virConnectPtr conn); -int virConnectListDefinedDomains (virConnectPtr conn, - char **const names, - int maxnames); -/** - * virConnectListAllDomainsFlags: - * - * Flags used to tune which domains are listed by virConnectListAllDomains(). - * Note that these flags come in groups; if all bits from a group are 0, - * then that group is not used to filter results. - */ -typedef enum { - VIR_CONNECT_LIST_DOMAINS_ACTIVE = 1 << 0, - VIR_CONNECT_LIST_DOMAINS_INACTIVE = 1 << 1, - - VIR_CONNECT_LIST_DOMAINS_PERSISTENT = 1 << 2, - VIR_CONNECT_LIST_DOMAINS_TRANSIENT = 1 << 3, - - VIR_CONNECT_LIST_DOMAINS_RUNNING = 1 << 4, - VIR_CONNECT_LIST_DOMAINS_PAUSED = 1 << 5, - VIR_CONNECT_LIST_DOMAINS_SHUTOFF = 1 << 6, - VIR_CONNECT_LIST_DOMAINS_OTHER = 1 << 7, - - VIR_CONNECT_LIST_DOMAINS_MANAGEDSAVE = 1 << 8, - VIR_CONNECT_LIST_DOMAINS_NO_MANAGEDSAVE = 1 << 9, - - VIR_CONNECT_LIST_DOMAINS_AUTOSTART = 1 << 10, - VIR_CONNECT_LIST_DOMAINS_NO_AUTOSTART = 1 << 11, - - VIR_CONNECT_LIST_DOMAINS_HAS_SNAPSHOT = 1 << 12, - VIR_CONNECT_LIST_DOMAINS_NO_SNAPSHOT = 1 << 13, -} virConnectListAllDomainsFlags; - -int virConnectListAllDomains (virConnectPtr conn, - virDomainPtr **domains, - unsigned int flags); -int virDomainCreate (virDomainPtr domain); -int virDomainCreateWithFlags (virDomainPtr domain, - unsigned int flags); - -int virDomainCreateWithFiles (virDomainPtr domain, - unsigned int nfiles, - int *files, - unsigned int flags); - -int virDomainGetAutostart (virDomainPtr domain, - int *autostart); -int virDomainSetAutostart (virDomainPtr domain, - int autostart); - -/** - * virVcpuInfo: structure for information about a virtual CPU in a domain. - */ - -typedef enum { - 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 */ - -#ifdef VIR_ENUM_SENTINELS - VIR_VCPU_LAST -#endif -} virVcpuState; - -typedef struct _virVcpuInfo 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 */ -}; -typedef virVcpuInfo *virVcpuInfoPtr; - -/* Flags for controlling virtual CPU hot-plugging. */ -typedef enum { - /* See virDomainModificationImpact for these flags. */ - VIR_DOMAIN_VCPU_CURRENT = VIR_DOMAIN_AFFECT_CURRENT, - VIR_DOMAIN_VCPU_LIVE = VIR_DOMAIN_AFFECT_LIVE, - VIR_DOMAIN_VCPU_CONFIG = VIR_DOMAIN_AFFECT_CONFIG, - - /* Additionally, these flags may be bitwise-OR'd in. */ - VIR_DOMAIN_VCPU_MAXIMUM = (1 << 2), /* Max rather than current count */ - VIR_DOMAIN_VCPU_GUEST = (1 << 3), /* Modify state of the cpu in the guest */ -} virDomainVcpuFlags; - -int virDomainSetVcpus (virDomainPtr domain, - unsigned int nvcpus); -int virDomainSetVcpusFlags (virDomainPtr domain, - unsigned int nvcpus, - unsigned int flags); -int virDomainGetVcpusFlags (virDomainPtr domain, - unsigned int flags); - -int virDomainPinVcpu (virDomainPtr domain, - unsigned int vcpu, - unsigned char *cpumap, - int maplen); -int virDomainPinVcpuFlags (virDomainPtr domain, - unsigned int vcpu, - unsigned char *cpumap, - int maplen, - unsigned int flags); - -int virDomainGetVcpuPinInfo (virDomainPtr domain, - int ncpumaps, - unsigned char *cpumaps, - int maplen, - unsigned int flags); - -int virDomainPinEmulator (virDomainPtr domain, - unsigned char *cpumap, - int maplen, - unsigned int flags); - -int virDomainGetEmulatorPinInfo (virDomainPtr domain, - unsigned char *cpumaps, - int maplen, - unsigned int flags); - -/** - * VIR_USE_CPU: - * @cpumap: pointer to a bit map of real CPUs (in 8-bit bytes) (IN/OUT) - * @cpu: the physical CPU number - * - * This macro is to be used in conjunction with virDomainPinVcpu() API. - * It sets the bit (CPU usable) of the related cpu in cpumap. - */ - -#define VIR_USE_CPU(cpumap, cpu) ((cpumap)[(cpu) / 8] |= (1 << ((cpu) % 8))) - -/** - * VIR_UNUSE_CPU: - * @cpumap: pointer to a bit map of real CPUs (in 8-bit bytes) (IN/OUT) - * @cpu: the physical CPU number - * - * This macro is to be used in conjunction with virDomainPinVcpu() API. - * It resets the bit (CPU not usable) of the related cpu in cpumap. - */ - -#define VIR_UNUSE_CPU(cpumap, cpu) ((cpumap)[(cpu) / 8] &= ~(1 << ((cpu) % 8))) - -/** - * VIR_CPU_USED: - * @cpumap: pointer to a bit map of real CPUs (in 8-bit bytes) (IN) - * @cpu: the physical CPU number - * - * This macro can be used in conjunction with virNodeGetCPUMap() API. - * It returns non-zero if the bit of the related CPU is set. - */ - -#define VIR_CPU_USED(cpumap, cpu) ((cpumap)[(cpu) / 8] & (1 << ((cpu) % 8))) - -/** - * VIR_CPU_MAPLEN: - * @cpu: number of physical CPUs - * - * 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. - */ - -#define VIR_CPU_MAPLEN(cpu) (((cpu) + 7) / 8) - - -int virDomainGetVcpus (virDomainPtr domain, - virVcpuInfoPtr info, - int maxinfo, - unsigned char *cpumaps, - int maplen); - -/** - * VIR_CPU_USABLE: - * @cpumaps: pointer to an array of cpumap (in 8-bit bytes) (IN) - * @maplen: the length (in bytes) of one cpumap - * @vcpu: the virtual CPU number - * @cpu: the physical CPU number - * - * 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. - */ - -#define VIR_CPU_USABLE(cpumaps, maplen, vcpu, cpu) \ - VIR_CPU_USED(VIR_GET_CPUMAP(cpumaps, maplen, vcpu), cpu) - -/** - * VIR_COPY_CPUMAP: - * @cpumaps: pointer to an array of cpumap (in 8-bit bytes) (IN) - * @maplen: the length (in bytes) of one cpumap - * @vcpu: the virtual CPU number - * @cpumap: pointer to a cpumap (in 8-bit bytes) (OUT) - * This cpumap must be previously allocated by the caller - * (ie: malloc(maplen)) - * - * 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. - */ -#define VIR_COPY_CPUMAP(cpumaps, maplen, vcpu, cpumap) \ - memcpy(cpumap, VIR_GET_CPUMAP(cpumaps, maplen, vcpu), maplen) - - -/** - * VIR_GET_CPUMAP: - * @cpumaps: pointer to an array of cpumap (in 8-bit bytes) (IN) - * @maplen: the length (in bytes) of one cpumap - * @vcpu: the virtual CPU number - * - * 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. - */ -#define VIR_GET_CPUMAP(cpumaps, maplen, vcpu) (&((cpumaps)[(vcpu) * (maplen)])) - - -typedef enum { - /* See virDomainModificationImpact for these flags. */ - VIR_DOMAIN_DEVICE_MODIFY_CURRENT = VIR_DOMAIN_AFFECT_CURRENT, - VIR_DOMAIN_DEVICE_MODIFY_LIVE = VIR_DOMAIN_AFFECT_LIVE, - VIR_DOMAIN_DEVICE_MODIFY_CONFIG = VIR_DOMAIN_AFFECT_CONFIG, - - /* Additionally, these flags may be bitwise-OR'd in. */ - VIR_DOMAIN_DEVICE_MODIFY_FORCE = (1 << 2), /* Forcibly modify device - (ex. force eject a cdrom) */ -} virDomainDeviceModifyFlags; - -int virDomainAttachDevice(virDomainPtr domain, const char *xml); -int virDomainDetachDevice(virDomainPtr domain, const char *xml); - -int virDomainAttachDeviceFlags(virDomainPtr domain, - const char *xml, unsigned int flags); -int virDomainDetachDeviceFlags(virDomainPtr domain, - const char *xml, unsigned int flags); -int virDomainUpdateDeviceFlags(virDomainPtr domain, - const char *xml, unsigned int flags); - -typedef struct _virDomainStatsRecord virDomainStatsRecord; -typedef virDomainStatsRecord *virDomainStatsRecordPtr; -struct _virDomainStatsRecord { - virDomainPtr dom; - virTypedParameterPtr params; - int nparams; -}; - -typedef enum { - VIR_DOMAIN_STATS_STATE = (1 << 0), /* return domain state */ - VIR_DOMAIN_STATS_CPU_TOTAL = (1 << 1), /* return domain CPU info */ - VIR_DOMAIN_STATS_BALLOON = (1 << 2), /* return domain balloon info */ - VIR_DOMAIN_STATS_VCPU = (1 << 3), /* return domain virtual CPU info */ - VIR_DOMAIN_STATS_INTERFACE = (1 << 4), /* return domain interfaces info */ - VIR_DOMAIN_STATS_BLOCK = (1 << 5), /* return domain block info */ -} virDomainStatsTypes; - -typedef enum { - 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_PERSISTENT = VIR_CONNECT_LIST_DOMAINS_PERSISTENT, - VIR_CONNECT_GET_ALL_DOMAINS_STATS_TRANSIENT = VIR_CONNECT_LIST_DOMAINS_TRANSIENT, - - VIR_CONNECT_GET_ALL_DOMAINS_STATS_RUNNING = VIR_CONNECT_LIST_DOMAINS_RUNNING, - VIR_CONNECT_GET_ALL_DOMAINS_STATS_PAUSED = VIR_CONNECT_LIST_DOMAINS_PAUSED, - VIR_CONNECT_GET_ALL_DOMAINS_STATS_SHUTOFF = VIR_CONNECT_LIST_DOMAINS_SHUTOFF, - VIR_CONNECT_GET_ALL_DOMAINS_STATS_OTHER = VIR_CONNECT_LIST_DOMAINS_OTHER, - - VIR_CONNECT_GET_ALL_DOMAINS_STATS_ENFORCE_STATS = 1 << 31, /* enforce requested stats */ -} virConnectGetAllDomainStatsFlags; - -int virConnectGetAllDomainStats(virConnectPtr conn, - unsigned int stats, - virDomainStatsRecordPtr **retStats, - unsigned int flags); - -int virDomainListGetStats(virDomainPtr *doms, - unsigned int stats, - virDomainStatsRecordPtr **retStats, - unsigned int flags); - -void virDomainStatsRecordListFree(virDomainStatsRecordPtr *stats); - -/* - * BlockJob API - */ - -/** - * virDomainBlockJobType: - * - * Describes various possible block jobs. - */ -typedef enum { - 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 */ - -#ifdef VIR_ENUM_SENTINELS - VIR_DOMAIN_BLOCK_JOB_TYPE_LAST -#endif -} virDomainBlockJobType; - -/** - * virDomainBlockJobAbortFlags: - * - * VIR_DOMAIN_BLOCK_JOB_ABORT_ASYNC: Request only, do not wait for completion - * VIR_DOMAIN_BLOCK_JOB_ABORT_PIVOT: Pivot to new file when ending a copy or - * active commit job - */ -typedef enum { - VIR_DOMAIN_BLOCK_JOB_ABORT_ASYNC = 1 << 0, - VIR_DOMAIN_BLOCK_JOB_ABORT_PIVOT = 1 << 1, -} virDomainBlockJobAbortFlags; - -int virDomainBlockJobAbort(virDomainPtr dom, const char *disk, - unsigned int flags); - -/* Flags for use with virDomainGetBlockJobInfo */ -typedef enum { - VIR_DOMAIN_BLOCK_JOB_INFO_BANDWIDTH_BYTES = 1 << 0, /* bandwidth in bytes/s - instead of MiB/s */ -} virDomainBlockJobInfoFlags; - -/* An iterator for monitoring block job operations */ -typedef unsigned long long virDomainBlockJobCursor; - -typedef struct _virDomainBlockJobInfo virDomainBlockJobInfo; -struct _virDomainBlockJobInfo { - int type; /* virDomainBlockJobType */ - unsigned long bandwidth; /* either bytes/s or MiB/s, according to flags */ - - /* - * The following fields provide an indication of block job progress. @cur - * indicates the current position and will be between 0 and @end. @end is - * the final cursor position for this operation and represents completion. - * To approximate progress, divide @cur by @end. - */ - virDomainBlockJobCursor cur; - virDomainBlockJobCursor end; -}; -typedef virDomainBlockJobInfo *virDomainBlockJobInfoPtr; - -int virDomainGetBlockJobInfo(virDomainPtr dom, const char *disk, - virDomainBlockJobInfoPtr info, - unsigned int flags); - -/* Flags for use with virDomainBlockJobSetSpeed */ -typedef enum { - VIR_DOMAIN_BLOCK_JOB_SPEED_BANDWIDTH_BYTES = 1 << 0, /* bandwidth in bytes/s - instead of MiB/s */ -} virDomainBlockJobSetSpeedFlags; - -int virDomainBlockJobSetSpeed(virDomainPtr dom, const char *disk, - unsigned long bandwidth, unsigned int flags); - -/* Flags for use with virDomainBlockPull (values chosen to be a subset - * of the flags for virDomainBlockRebase) */ -typedef enum { - VIR_DOMAIN_BLOCK_PULL_BANDWIDTH_BYTES = 1 << 6, /* bandwidth in bytes/s - instead of MiB/s */ -} virDomainBlockPullFlags; - -int virDomainBlockPull(virDomainPtr dom, const char *disk, - unsigned long bandwidth, unsigned int flags); - -/** - * virDomainBlockRebaseFlags: - * - * Flags available for virDomainBlockRebase(). - */ -typedef enum { - VIR_DOMAIN_BLOCK_REBASE_SHALLOW = 1 << 0, /* Limit copy to top of source - backing chain */ - VIR_DOMAIN_BLOCK_REBASE_REUSE_EXT = 1 << 1, /* Reuse existing external - file for a copy */ - VIR_DOMAIN_BLOCK_REBASE_COPY_RAW = 1 << 2, /* Make destination file raw */ - VIR_DOMAIN_BLOCK_REBASE_COPY = 1 << 3, /* Start a copy job */ - VIR_DOMAIN_BLOCK_REBASE_RELATIVE = 1 << 4, /* Keep backing chain - referenced using relative - names */ - VIR_DOMAIN_BLOCK_REBASE_COPY_DEV = 1 << 5, /* Treat destination as block - device instead of file */ - VIR_DOMAIN_BLOCK_REBASE_BANDWIDTH_BYTES = 1 << 6, /* bandwidth in bytes/s - instead of MiB/s */ -} virDomainBlockRebaseFlags; - -int virDomainBlockRebase(virDomainPtr dom, const char *disk, - const char *base, unsigned long bandwidth, - unsigned int flags); - -/** - * virDomainBlockCopyFlags: - * - * Flags available for virDomainBlockCopy(). - */ -typedef enum { - VIR_DOMAIN_BLOCK_COPY_SHALLOW = 1 << 0, /* Limit copy to top of source - backing chain */ - VIR_DOMAIN_BLOCK_COPY_REUSE_EXT = 1 << 1, /* Reuse existing external - file for a copy */ -} virDomainBlockCopyFlags; - -/** - * 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(). - */ -#define VIR_DOMAIN_BLOCK_COPY_BANDWIDTH "bandwidth" - -/** - * 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. - */ -#define VIR_DOMAIN_BLOCK_COPY_GRANULARITY "granularity" - -/** - * 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. - */ -#define VIR_DOMAIN_BLOCK_COPY_BUF_SIZE "buf-size" - -int virDomainBlockCopy(virDomainPtr dom, const char *disk, - const char *destxml, - virTypedParameterPtr params, - int nparams, - unsigned int flags); - -/** - * virDomainBlockCommitFlags: - * - * Flags available for virDomainBlockCommit(). - */ -typedef enum { - VIR_DOMAIN_BLOCK_COMMIT_SHALLOW = 1 << 0, /* NULL base means next backing - file, not whole chain */ - VIR_DOMAIN_BLOCK_COMMIT_DELETE = 1 << 1, /* Delete any files that are now - invalid after their contents - have been committed */ - VIR_DOMAIN_BLOCK_COMMIT_ACTIVE = 1 << 2, /* Allow a two-phase commit when - top is the active layer */ - VIR_DOMAIN_BLOCK_COMMIT_RELATIVE = 1 << 3, /* keep the backing chain - referenced using relative - names */ - VIR_DOMAIN_BLOCK_COMMIT_BANDWIDTH_BYTES = 1 << 4, /* bandwidth in bytes/s - instead of MiB/s */ -} virDomainBlockCommitFlags; - -int virDomainBlockCommit(virDomainPtr dom, const char *disk, const char *base, - const char *top, unsigned long bandwidth, - unsigned int flags); - - -/* Block I/O throttling support */ - -/** - * 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. - */ -#define VIR_DOMAIN_BLOCK_IOTUNE_TOTAL_BYTES_SEC "total_bytes_sec" - -/** - * 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. - */ -#define VIR_DOMAIN_BLOCK_IOTUNE_READ_BYTES_SEC "read_bytes_sec" - -/** - * 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. - */ -#define VIR_DOMAIN_BLOCK_IOTUNE_WRITE_BYTES_SEC "write_bytes_sec" - -/** - * 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. - */ -#define VIR_DOMAIN_BLOCK_IOTUNE_TOTAL_IOPS_SEC "total_iops_sec" - -/** - * 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. - */ -#define VIR_DOMAIN_BLOCK_IOTUNE_READ_IOPS_SEC "read_iops_sec" - -/** - * 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. - */ -#define VIR_DOMAIN_BLOCK_IOTUNE_WRITE_IOPS_SEC "write_iops_sec" - -int -virDomainSetBlockIoTune(virDomainPtr dom, - const char *disk, - virTypedParameterPtr params, - int nparams, - unsigned int flags); -int -virDomainGetBlockIoTune(virDomainPtr dom, - const char *disk, - virTypedParameterPtr params, - int *nparams, - unsigned int flags); - -/** - * virDomainDiskErrorCode: - * - * Disk I/O error. - */ -typedef enum { - 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 */ - -#ifdef VIR_ENUM_SENTINELS - VIR_DOMAIN_DISK_ERROR_LAST -#endif -} virDomainDiskErrorCode; - -/** - * virDomainDiskError: - * - */ -typedef struct _virDomainDiskError virDomainDiskError; -typedef virDomainDiskError *virDomainDiskErrorPtr; - -struct _virDomainDiskError { - char *disk; /* disk target */ - int error; /* virDomainDiskErrorCode */ -}; - -int virDomainGetDiskErrors(virDomainPtr dom, - virDomainDiskErrorPtr errors, - unsigned int maxerrors, - unsigned int flags); - - -/* - * NUMA support - */ - -int virNodeGetCellsFreeMemory(virConnectPtr conn, - unsigned long long *freeMems, - int startCell, - int maxCells); - - - - -/** - * virKeycodeSet: - * - * Enum to specify which keycode mapping is in use for virDomainSendKey(). - */ -typedef enum { - 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, - -#ifdef VIR_ENUM_SENTINELS - VIR_KEYCODE_SET_LAST - /* - * 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. - */ -#endif -} virKeycodeSet; - -/** - * VIR_DOMAIN_SEND_KEY_MAX_KEYS: - * - * Maximum number of keycodes that can be sent in one virDomainSendKey() call. - */ -#define VIR_DOMAIN_SEND_KEY_MAX_KEYS 16 - -int virDomainSendKey(virDomainPtr domain, - unsigned int codeset, - unsigned int holdtime, - unsigned int *keycodes, - int nkeycodes, - unsigned int flags); - -/* - * These just happen to match Linux signal numbers. The numbers - * will be mapped to whatever the SIGNUM is in the guest OS in - * question by the agent delivering the signal. The names are - * based on the POSIX / XSI signal standard though. - * - * Do not rely on all values matching Linux though. It is possible - * this enum might be extended with new signals which have no - * mapping in Linux. - */ -typedef enum { - 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 */ - -#ifdef VIR_ENUM_SENTINELS - VIR_DOMAIN_PROCESS_SIGNAL_LAST -#endif -} virDomainProcessSignal; - -int virDomainSendProcessSignal(virDomainPtr domain, - long long pid_value, - unsigned int signum, - unsigned int flags); - -/* - * Deprecated calls - */ -virDomainPtr virDomainCreateLinux (virConnectPtr conn, - const char *xmlDesc, - unsigned int flags); - - -/* - * Domain Event Notification - */ - -/** - * virDomainEventType: - * - * a virDomainEventType is emitted during domain lifecycle events - */ -typedef enum { - 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, - -#ifdef VIR_ENUM_SENTINELS - VIR_DOMAIN_EVENT_LAST -#endif -} virDomainEventType; - -/** - * virDomainEventDefinedDetailType: - * - * Details on the cause of a 'defined' lifecycle event - */ -typedef enum { - VIR_DOMAIN_EVENT_DEFINED_ADDED = 0, /* Newly created config file */ - VIR_DOMAIN_EVENT_DEFINED_UPDATED = 1, /* Changed config file */ - -#ifdef VIR_ENUM_SENTINELS - VIR_DOMAIN_EVENT_DEFINED_LAST -#endif -} virDomainEventDefinedDetailType; - -/** - * virDomainEventUndefinedDetailType: - * - * Details on the cause of an 'undefined' lifecycle event - */ -typedef enum { - VIR_DOMAIN_EVENT_UNDEFINED_REMOVED = 0, /* Deleted the config file */ - -#ifdef VIR_ENUM_SENTINELS - VIR_DOMAIN_EVENT_UNDEFINED_LAST -#endif -} virDomainEventUndefinedDetailType; - -/** - * virDomainEventStartedDetailType: - * - * Details on the cause of a 'started' lifecycle event - */ -typedef enum { - 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 */ - -#ifdef VIR_ENUM_SENTINELS - VIR_DOMAIN_EVENT_STARTED_LAST -#endif -} virDomainEventStartedDetailType; - -/** - * virDomainEventSuspendedDetailType: - * - * Details on the cause of a 'suspended' lifecycle event - */ -typedef enum { - 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 */ - -#ifdef VIR_ENUM_SENTINELS - VIR_DOMAIN_EVENT_SUSPENDED_LAST -#endif -} virDomainEventSuspendedDetailType; - -/** - * virDomainEventResumedDetailType: - * - * Details on the cause of a 'resumed' lifecycle event - */ -typedef enum { - 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 */ - -#ifdef VIR_ENUM_SENTINELS - VIR_DOMAIN_EVENT_RESUMED_LAST -#endif -} virDomainEventResumedDetailType; - -/** - * virDomainEventStoppedDetailType: - * - * Details on the cause of a 'stopped' lifecycle event - */ -typedef enum { - 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 */ - -#ifdef VIR_ENUM_SENTINELS - VIR_DOMAIN_EVENT_STOPPED_LAST -#endif -} virDomainEventStoppedDetailType; - - -/** - * virDomainEventShutdownDetailType: - * - * Details on the cause of a 'shutdown' lifecycle event - */ -typedef enum { - VIR_DOMAIN_EVENT_SHUTDOWN_FINISHED = 0, /* Guest finished shutdown sequence */ - -#ifdef VIR_ENUM_SENTINELS - VIR_DOMAIN_EVENT_SHUTDOWN_LAST -#endif -} virDomainEventShutdownDetailType; - -/** - * virDomainEventPMSuspendedDetailType: - * - * Details on the cause of a 'pmsuspended' lifecycle event - */ -typedef enum { - VIR_DOMAIN_EVENT_PMSUSPENDED_MEMORY = 0, /* Guest was PM suspended to memory */ - VIR_DOMAIN_EVENT_PMSUSPENDED_DISK = 1, /* Guest was PM suspended to disk */ - -#ifdef VIR_ENUM_SENTINELS - VIR_DOMAIN_EVENT_PMSUSPENDED_LAST -#endif -} virDomainEventPMSuspendedDetailType; - -/** - * virDomainEventCrashedDetailType: - * - * Details on the cause of a 'crashed' lifecycle event - */ -typedef enum { - VIR_DOMAIN_EVENT_CRASHED_PANICKED = 0, /* Guest was panicked */ - -#ifdef VIR_ENUM_SENTINELS - VIR_DOMAIN_EVENT_CRASHED_LAST -#endif -} virDomainEventCrashedDetailType; - -/** - * virConnectDomainEventCallback: - * @conn: virConnect connection - * @dom: The domain on which the event occurred - * @event: The specific virDomainEventType which occurred - * @detail: event specific detail information - * @opaque: opaque user data - * - * A callback function to be registered, and called when a domain event occurs - * - * Returns 0 (the return value is currently ignored) - */ -typedef int (*virConnectDomainEventCallback)(virConnectPtr conn, - virDomainPtr dom, - int event, - int detail, - void *opaque); - -int virConnectDomainEventRegister(virConnectPtr conn, - virConnectDomainEventCallback cb, - void *opaque, - virFreeCallback freecb); - -int virConnectDomainEventDeregister(virConnectPtr conn, - virConnectDomainEventCallback cb); - - -int virDomainIsActive(virDomainPtr dom); -int virDomainIsPersistent(virDomainPtr dom); -int virDomainIsUpdated(virDomainPtr dom); - - -int virConnectIsEncrypted(virConnectPtr conn); -int virConnectIsSecure(virConnectPtr conn); -int virConnectIsAlive(virConnectPtr conn); - -/* - * CPU specification API - */ - -typedef enum { - VIR_CPU_COMPARE_ERROR = -1, - VIR_CPU_COMPARE_INCOMPATIBLE = 0, - VIR_CPU_COMPARE_IDENTICAL = 1, - VIR_CPU_COMPARE_SUPERSET = 2, - -#ifdef VIR_ENUM_SENTINELS - VIR_CPU_COMPARE_LAST -#endif -} virCPUCompareResult; - -typedef enum { - VIR_CONNECT_COMPARE_CPU_FAIL_INCOMPATIBLE = (1 << 0), /* treat incompatible - CPUs as failure */ -} virConnectCompareCPUFlags; - -int virConnectCompareCPU(virConnectPtr conn, - const char *xmlDesc, - unsigned int flags); - -int virConnectGetCPUModelNames(virConnectPtr conn, - const char *arch, - char ***models, - unsigned int flags); - -/** - * virConnectBaselineCPUFlags - * - * Flags when getting XML description of a computed CPU - */ -typedef enum { - VIR_CONNECT_BASELINE_CPU_EXPAND_FEATURES = (1 << 0), /* show all features */ -} virConnectBaselineCPUFlags; - -char *virConnectBaselineCPU(virConnectPtr conn, - const char **xmlCPUs, - unsigned int ncpus, - unsigned int flags); - -typedef enum { - 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 */ - -#ifdef VIR_ENUM_SENTINELS - VIR_DOMAIN_JOB_LAST -#endif -} virDomainJobType; - -typedef struct _virDomainJobInfo virDomainJobInfo; -typedef virDomainJobInfo *virDomainJobInfoPtr; -struct _virDomainJobInfo { - /* One of virDomainJobType */ - 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 otherwise specified - * and is measuring the job as a whole. - * - * For VIR_DOMAIN_JOB_UNBOUNDED, dataTotal may be less - * than the final sum of dataProcessed + dataRemaining - * in the event that the hypervisor has to repeat some - * data, such as due to dirtied pages during migration. - * - * For VIR_DOMAIN_JOB_BOUNDED, dataTotal shall always - * equal the sum of dataProcessed + dataRemaining. - */ - 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; -}; - -/** - * virDomainGetJobStatsFlags: - * - * Flags OR'ed together to provide specific behavior when querying domain - * job statistics. - */ -typedef enum { - VIR_DOMAIN_JOB_STATS_COMPLETED = 1 << 0, /* return stats of a recently - * completed job */ -} virDomainGetJobStatsFlags; - -int virDomainGetJobInfo(virDomainPtr dom, - virDomainJobInfoPtr info); -int virDomainGetJobStats(virDomainPtr domain, - int *type, - virTypedParameterPtr *params, - int *nparams, - unsigned int flags); -int virDomainAbortJob(virDomainPtr dom); - -/** - * 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. - */ -#define VIR_DOMAIN_JOB_TIME_ELAPSED "time_elapsed" - -/** - * 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. - */ -#define VIR_DOMAIN_JOB_TIME_REMAINING "time_remaining" - -/** - * VIR_DOMAIN_JOB_DOWNTIME: - * - * virDomainGetJobStats field: downtime (ms) that is expected to happen - * during migration, as VIR_TYPED_PARAM_ULLONG. - */ -#define VIR_DOMAIN_JOB_DOWNTIME "downtime" - -/** - * 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. - */ -#define VIR_DOMAIN_JOB_SETUP_TIME "setup_time" - -/** - * 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. - */ -#define VIR_DOMAIN_JOB_DATA_TOTAL "data_total" - -/** - * 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. - */ -#define VIR_DOMAIN_JOB_DATA_PROCESSED "data_processed" - -/** - * 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. - */ -#define VIR_DOMAIN_JOB_DATA_REMAINING "data_remaining" - -/** - * 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. - */ -#define VIR_DOMAIN_JOB_MEMORY_TOTAL "memory_total" - -/** - * 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. - */ -#define VIR_DOMAIN_JOB_MEMORY_PROCESSED "memory_processed" - -/** - * 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. - */ -#define VIR_DOMAIN_JOB_MEMORY_REMAINING "memory_remaining" - -/** - * 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. - */ -#define VIR_DOMAIN_JOB_MEMORY_CONSTANT "memory_constant" - -/** - * 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. - */ -#define VIR_DOMAIN_JOB_MEMORY_NORMAL "memory_normal" - -/** - * 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. - */ -#define VIR_DOMAIN_JOB_MEMORY_NORMAL_BYTES "memory_normal_bytes" - -/** - * VIR_DOMAIN_JOB_MEMORY_BPS: - * - * virDomainGetJobStats field: network throughput used while migrating - * memory in Bytes per second, as VIR_TYPED_PARAM_ULLONG. - */ -#define VIR_DOMAIN_JOB_MEMORY_BPS "memory_bps" - -/** - * 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. - */ -#define VIR_DOMAIN_JOB_DISK_TOTAL "disk_total" - -/** - * 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. - */ -#define VIR_DOMAIN_JOB_DISK_PROCESSED "disk_processed" - -/** - * 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. - */ -#define VIR_DOMAIN_JOB_DISK_REMAINING "disk_remaining" - -/** - * VIR_DOMAIN_JOB_DISK_BPS: - * - * virDomainGetJobStats field: network throughput used while migrating - * disks in Bytes per second, as VIR_TYPED_PARAM_ULLONG. - */ -#define VIR_DOMAIN_JOB_DISK_BPS "disk_bps" - -/** - * 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. - */ -#define VIR_DOMAIN_JOB_COMPRESSION_CACHE "compression_cache" - -/** - * VIR_DOMAIN_JOB_COMPRESSION_BYTES: - * - * virDomainGetJobStats field: number of compressed bytes transferred - * since the beginning of migration, as VIR_TYPED_PARAM_ULLONG. - */ -#define VIR_DOMAIN_JOB_COMPRESSION_BYTES "compression_bytes" - -/** - * VIR_DOMAIN_JOB_COMPRESSION_PAGES: - * - * virDomainGetJobStats field: number of compressed pages transferred - * since the beginning of migration, as VIR_TYPED_PARAM_ULLONG. - */ -#define VIR_DOMAIN_JOB_COMPRESSION_PAGES "compression_pages" - -/** - * 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. - */ -#define VIR_DOMAIN_JOB_COMPRESSION_CACHE_MISSES "compression_cache_misses" - -/** - * 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. - */ -#define VIR_DOMAIN_JOB_COMPRESSION_OVERFLOW "compression_overflow" - - - -/** - * virConnectDomainEventGenericCallback: - * @conn: the connection pointer - * @dom: the domain pointer - * @opaque: application specified data - * - * 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. - */ -typedef void (*virConnectDomainEventGenericCallback)(virConnectPtr conn, - virDomainPtr dom, - void *opaque); - -/** - * virConnectDomainEventRTCChangeCallback: - * @conn: connection object - * @dom: domain on which the event occurred - * @utcoffset: the new RTC offset from UTC, measured in seconds - * @opaque: application specified data - * - * The callback signature to use when registering for an event of type - * VIR_DOMAIN_EVENT_ID_RTC_CHANGE with virConnectDomainEventRegisterAny() - */ -typedef void (*virConnectDomainEventRTCChangeCallback)(virConnectPtr conn, - virDomainPtr dom, - long long utcoffset, - void *opaque); - -/** - * virDomainEventWatchdogAction: - * - * The action that is to be taken due to the watchdog device firing - */ -typedef enum { - VIR_DOMAIN_EVENT_WATCHDOG_NONE = 0, /* No action, watchdog ignored */ - VIR_DOMAIN_EVENT_WATCHDOG_PAUSE, /* Guest CPUs are paused */ - VIR_DOMAIN_EVENT_WATCHDOG_RESET, /* Guest CPUs are reset */ - VIR_DOMAIN_EVENT_WATCHDOG_POWEROFF, /* Guest is forcibly powered off */ - VIR_DOMAIN_EVENT_WATCHDOG_SHUTDOWN, /* Guest is requested to gracefully shutdown */ - VIR_DOMAIN_EVENT_WATCHDOG_DEBUG, /* No action, a debug message logged */ - -#ifdef VIR_ENUM_SENTINELS - VIR_DOMAIN_EVENT_WATCHDOG_LAST -#endif -} virDomainEventWatchdogAction; - -/** - * virConnectDomainEventWatchdogCallback: - * @conn: connection object - * @dom: domain on which the event occurred - * @action: action that is to be taken due to watchdog firing - * @opaque: application specified data - * - * The callback signature to use when registering for an event of type - * VIR_DOMAIN_EVENT_ID_WATCHDOG with virConnectDomainEventRegisterAny() - * - */ -typedef void (*virConnectDomainEventWatchdogCallback)(virConnectPtr conn, - virDomainPtr dom, - int action, - void *opaque); - -/** - * virDomainEventIOErrorAction: - * - * The action that is to be taken due to an IO error occurring - */ -typedef enum { - VIR_DOMAIN_EVENT_IO_ERROR_NONE = 0, /* No action, IO error ignored */ - VIR_DOMAIN_EVENT_IO_ERROR_PAUSE, /* Guest CPUs are paused */ - VIR_DOMAIN_EVENT_IO_ERROR_REPORT, /* IO error reported to guest OS */ - -#ifdef VIR_ENUM_SENTINELS - VIR_DOMAIN_EVENT_IO_ERROR_LAST -#endif -} virDomainEventIOErrorAction; - - -/** - * virConnectDomainEventIOErrorCallback: - * @conn: connection object - * @dom: domain on which the event occurred - * @srcPath: The host file on which the IO error occurred - * @devAlias: The guest device alias associated with the path - * @action: action that is to be taken due to the IO error - * @opaque: application specified data - * - * The callback signature to use when registering for an event of type - * VIR_DOMAIN_EVENT_ID_IO_ERROR with virConnectDomainEventRegisterAny() - */ -typedef void (*virConnectDomainEventIOErrorCallback)(virConnectPtr conn, - virDomainPtr dom, - const char *srcPath, - const char *devAlias, - int action, - void *opaque); - -/** - * virConnectDomainEventIOErrorReasonCallback: - * @conn: connection object - * @dom: domain on which the event occurred - * @srcPath: The host file on which the IO error occurred - * @devAlias: The guest device alias associated with the path - * @action: action that is to be taken due to the IO error - * @reason: the cause of the IO error - * @opaque: application specified data - * - * The callback signature to use when registering for an event of type - * VIR_DOMAIN_EVENT_ID_IO_ERROR_REASON with virConnectDomainEventRegisterAny() - * - * If the I/O error is known to be caused by an ENOSPC condition in - * the host (where resizing the disk to be larger will allow the guest - * to be resumed as if nothing happened), @reason will be "enospc". - * Otherwise, @reason will be "", although future strings may be added - * if determination of other error types becomes possible. - * - */ -typedef void (*virConnectDomainEventIOErrorReasonCallback)(virConnectPtr conn, - virDomainPtr dom, - const char *srcPath, - const char *devAlias, - int action, - const char *reason, - void *opaque); - -/** - * virDomainEventGraphicsPhase: - * - * The phase of the graphics client connection - */ -typedef enum { - VIR_DOMAIN_EVENT_GRAPHICS_CONNECT = 0, /* Initial socket connection established */ - VIR_DOMAIN_EVENT_GRAPHICS_INITIALIZE, /* Authentication & setup completed */ - VIR_DOMAIN_EVENT_GRAPHICS_DISCONNECT, /* Final socket disconnection */ - -#ifdef VIR_ENUM_SENTINELS - VIR_DOMAIN_EVENT_GRAPHICS_LAST -#endif -} virDomainEventGraphicsPhase; - -/** - * virDomainEventGraphicsAddressType: - * - * The type of address for the connection - */ -typedef enum { - VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_IPV4, /* IPv4 address */ - VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_IPV6, /* IPv6 address */ - VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_UNIX, /* UNIX socket path */ - -#ifdef VIR_ENUM_SENTINELS - VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_LAST -#endif -} virDomainEventGraphicsAddressType; - - -/** - * virDomainEventGraphicsAddress: - * - * The data structure containing connection address details - * - */ -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) */ -}; -typedef struct _virDomainEventGraphicsAddress virDomainEventGraphicsAddress; -typedef virDomainEventGraphicsAddress *virDomainEventGraphicsAddressPtr; - - -/** - * virDomainEventGraphicsSubjectIdentity: - * - * The data structure representing a single identity - * - * The types of identity differ according to the authentication scheme, - * some examples are 'x509dname' and 'saslUsername'. - */ -struct _virDomainEventGraphicsSubjectIdentity { - char *type; /* Type of identity */ - char *name; /* Identity value */ -}; -typedef struct _virDomainEventGraphicsSubjectIdentity virDomainEventGraphicsSubjectIdentity; -typedef virDomainEventGraphicsSubjectIdentity *virDomainEventGraphicsSubjectIdentityPtr; - - -/** - * virDomainEventGraphicsSubject: - * - * The data structure representing an authenticated subject - * - * A subject will have zero or more identities. The types of - * identity differ according to the authentication scheme - */ -struct _virDomainEventGraphicsSubject { - int nidentity; /* Number of identities in array*/ - virDomainEventGraphicsSubjectIdentityPtr identities; /* Array of identities for subject */ -}; -typedef struct _virDomainEventGraphicsSubject virDomainEventGraphicsSubject; -typedef virDomainEventGraphicsSubject *virDomainEventGraphicsSubjectPtr; - - -/** - * virConnectDomainEventGraphicsCallback: - * @conn: connection object - * @dom: domain on which the event occurred - * @phase: the phase of the connection - * @local: the local server address - * @remote: the remote client address - * @authScheme: the authentication scheme activated - * @subject: the authenticated subject (user) - * @opaque: application specified data - * - * The callback signature to use when registering for an event of type - * VIR_DOMAIN_EVENT_ID_GRAPHICS with virConnectDomainEventRegisterAny() - */ -typedef void (*virConnectDomainEventGraphicsCallback)(virConnectPtr conn, - virDomainPtr dom, - int phase, - const virDomainEventGraphicsAddress *local, - const virDomainEventGraphicsAddress *remote, - const char *authScheme, - const virDomainEventGraphicsSubject *subject, - void *opaque); - -/** - * virConnectDomainEventBlockJobStatus: - * - * Tracks status of a virDomainBlockPull(), virDomainBlockRebase(), - * virDomainBlockCopy(), or virDomainBlockCommit() operation - */ -typedef enum { - VIR_DOMAIN_BLOCK_JOB_COMPLETED = 0, - VIR_DOMAIN_BLOCK_JOB_FAILED = 1, - VIR_DOMAIN_BLOCK_JOB_CANCELED = 2, - VIR_DOMAIN_BLOCK_JOB_READY = 3, - -#ifdef VIR_ENUM_SENTINELS - VIR_DOMAIN_BLOCK_JOB_LAST -#endif -} virConnectDomainEventBlockJobStatus; - -/** - * virConnectDomainEventBlockJobCallback: - * @conn: connection object - * @dom: domain on which the event occurred - * @disk: name associated with the affected disk (filename or target - * device, depending on how the callback was registered) - * @type: type of block job (virDomainBlockJobType) - * @status: status of the operation (virConnectDomainEventBlockJobStatus) - * @opaque: application specified data - * - * 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"). - */ -typedef void (*virConnectDomainEventBlockJobCallback)(virConnectPtr conn, - virDomainPtr dom, - const char *disk, - int type, - int status, - void *opaque); - -/** - * virConnectDomainEventDiskChangeReason: - * - * The reason describing why this callback is called - */ -typedef enum { - VIR_DOMAIN_EVENT_DISK_CHANGE_MISSING_ON_START = 0, /* oldSrcPath is set */ - VIR_DOMAIN_EVENT_DISK_DROP_MISSING_ON_START = 1, - -#ifdef VIR_ENUM_SENTINELS - VIR_DOMAIN_EVENT_DISK_CHANGE_LAST -#endif -} virConnectDomainEventDiskChangeReason; - -/** - * virConnectDomainEventDiskChangeCallback: - * @conn: connection object - * @dom: domain on which the event occurred - * @oldSrcPath: old source path - * @newSrcPath: new source path - * @devAlias: device alias name - * @reason: reason why this callback was called; any of - * virConnectDomainEventDiskChangeReason - * @opaque: application specified data - * - * 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() - */ -typedef void (*virConnectDomainEventDiskChangeCallback)(virConnectPtr conn, - virDomainPtr dom, - const char *oldSrcPath, - const char *newSrcPath, - const char *devAlias, - int reason, - void *opaque); - -/** - * virConnectDomainEventTrayChangeReason: - * - * The reason describing why the callback was called - */ -typedef enum { - VIR_DOMAIN_EVENT_TRAY_CHANGE_OPEN = 0, - VIR_DOMAIN_EVENT_TRAY_CHANGE_CLOSE, - -#ifdef VIR_ENUM_SENTINELS - VIR_DOMAIN_EVENT_TRAY_CHANGE_LAST -#endif -} virDomainEventTrayChangeReason; - -/** - * virConnectDomainEventTrayChangeCallback: - * @conn: connection object - * @dom: domain on which the event occurred - * @devAlias: device alias - * @reason: why the tray status was changed? - * @opaque: application specified data - * - * 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() - */ -typedef void (*virConnectDomainEventTrayChangeCallback)(virConnectPtr conn, - virDomainPtr dom, - const char *devAlias, - int reason, - void *opaque); - -/** - * virConnectDomainEventPMWakeupCallback: - * @conn: connection object - * @dom: domain on which the event occurred - * @reason: reason why the callback was called, unused currently, - * always passes 0 - * @opaque: application specified data - * - * 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() - */ -typedef void (*virConnectDomainEventPMWakeupCallback)(virConnectPtr conn, - virDomainPtr dom, - int reason, - void *opaque); - -/** - * virConnectDomainEventPMSuspendCallback: - * @conn: connection object - * @dom: domain on which the event occurred - * @reason: reason why the callback was called, unused currently, - * always passes 0 - * @opaque: application specified data - * - * 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() - */ -typedef void (*virConnectDomainEventPMSuspendCallback)(virConnectPtr conn, - virDomainPtr dom, - int reason, - void *opaque); - - -/** - * virConnectDomainEventBalloonChangeCallback: - * @conn: connection object - * @dom: domain on which the event occurred - * @actual: the new balloon level measured in kibibytes(blocks of 1024 bytes) - * @opaque: application specified data - * - * The callback signature to use when registering for an event of type - * VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE with virConnectDomainEventRegisterAny() - */ -typedef void (*virConnectDomainEventBalloonChangeCallback)(virConnectPtr conn, - virDomainPtr dom, - unsigned long long actual, - void *opaque); - -/** - * virConnectDomainEventPMSuspendDiskCallback: - * @conn: connection object - * @dom: domain on which the event occurred - * @reason: reason why the callback was called, unused currently, - * always passes 0 - * @opaque: application specified data - * - * 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() - */ -typedef void (*virConnectDomainEventPMSuspendDiskCallback)(virConnectPtr conn, - virDomainPtr dom, - int reason, - void *opaque); - -/** - * virConnectDomainEventDeviceRemovedCallback: - * @conn: connection object - * @dom: domain on which the event occurred - * @devAlias: device alias - * @opaque: application specified data - * - * 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() - */ -typedef void (*virConnectDomainEventDeviceRemovedCallback)(virConnectPtr conn, - virDomainPtr dom, - const char *devAlias, - void *opaque); - -/** - * 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. - */ -#define VIR_DOMAIN_TUNABLE_CPU_VCPUPIN "cputune.vcpupin%u" - -/** - * VIR_DOMAIN_TUNABLE_CPU_EMULATORPIN: - * - * Macro represents formatted pinning for emulator process, - * as VIR_TYPED_PARAM_STRING. - */ -#define VIR_DOMAIN_TUNABLE_CPU_EMULATORPIN "cputune.emulatorpin" - -/** - * 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. - */ -#define VIR_DOMAIN_TUNABLE_CPU_CPU_SHARES "cputune.cpu_shares" - -/** - * 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. - */ -#define VIR_DOMAIN_TUNABLE_CPU_VCPU_PERIOD "cputune.vcpu_period" - -/** - * 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. - */ -#define VIR_DOMAIN_TUNABLE_CPU_VCPU_QUOTA "cputune.vcpu_quota" - -/** - * 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. - */ -#define VIR_DOMAIN_TUNABLE_CPU_EMULATOR_PERIOD "cputune.emulator_period" - -/** - * 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. - */ -#define VIR_DOMAIN_TUNABLE_CPU_EMULATOR_QUOTA "cputune.emulator_quota" - -/** - * VIR_DOMAIN_TUNABLE_BLKDEV_DISK: - * - * Macro represents the name of guest disk for which the values are updated, - * as VIR_TYPED_PARAM_STRING. - */ -#define VIR_DOMAIN_TUNABLE_BLKDEV_DISK "blkdeviotune.disk" - -/** - * VIR_DOMAIN_TUNABLE_BLKDEV_TOTAL_BYTES_SEC: - * - * Marco represents the total throughput limit in bytes per second, - * as VIR_TYPED_PARAM_ULLONG. - */ -#define VIR_DOMAIN_TUNABLE_BLKDEV_TOTAL_BYTES_SEC "blkdeviotune.total_bytes_sec" - -/** - * VIR_DOMAIN_TUNABLE_BLKDEV_READ_BYTES_SEC: - * - * Marco represents the read throughput limit in bytes per second, - * as VIR_TYPED_PARAM_ULLONG. - */ -#define VIR_DOMAIN_TUNABLE_BLKDEV_READ_BYTES_SEC "blkdeviotune.read_bytes_sec" - -/** - * VIR_DOMAIN_TUNABLE_BLKDEV_WRITE_BYTES_SEC: - * - * Macro represents the write throughput limit in bytes per second, - * as VIR_TYPED_PARAM_ULLONG. - */ -#define VIR_DOMAIN_TUNABLE_BLKDEV_WRITE_BYTES_SEC "blkdeviotune.write_bytes_sec" - -/** - * VIR_DOMAIN_TUNABLE_BLKDEV_TOTAL_IOPS_SEC: - * - * Macro represents the total I/O operations per second, - * as VIR_TYPED_PARAM_ULLONG. - */ -#define VIR_DOMAIN_TUNABLE_BLKDEV_TOTAL_IOPS_SEC "blkdeviotune.total_iops_sec" - -/** - * VIR_DOMAIN_TUNABLE_BLKDEV_READ_IOPS_SEC: - * - * Macro represents the read I/O operations per second, - * as VIR_TYPED_PARAM_ULLONG. - */ -#define VIR_DOMAIN_TUNABLE_BLKDEV_READ_IOPS_SEC "blkdeviotune.read_iops_sec" - -/** - * VIR_DOMAIN_TUNABLE_BLKDEV_WRITE_IOPS_SEC: - * - * Macro represents the write I/O operations per second, - * as VIR_TYPED_PARAM_ULLONG. - */ -#define VIR_DOMAIN_TUNABLE_BLKDEV_WRITE_IOPS_SEC "blkdeviotune.write_iops_sec" - -/** - * virConnectDomainEventTunableCallback: - * @conn: connection object - * @dom: domain on which the event occurred - * @params: changed tunable values stored as array of virTypedParameter - * @nparams: size of the array - * @opaque: application specified data - * - * 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() - */ -typedef void (*virConnectDomainEventTunableCallback)(virConnectPtr conn, - virDomainPtr dom, - virTypedParameterPtr params, - int nparams, - void *opaque); - - -/** - * VIR_DOMAIN_EVENT_CALLBACK: - * - * Used to cast the event specific callback into the generic one - * for use for virConnectDomainEventRegisterAny() - */ -#define VIR_DOMAIN_EVENT_CALLBACK(cb) ((virConnectDomainEventGenericCallback)(cb)) - - -/** - * virDomainEventID: - * - * An enumeration of supported eventId parameters for - * virConnectDomainEventRegisterAny(). Each event id determines which - * signature of callback function will be used. - */ -typedef enum { - 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 */ - -#ifdef VIR_ENUM_SENTINELS - VIR_DOMAIN_EVENT_ID_LAST - /* - * 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. - */ -#endif -} virDomainEventID; - - -/* Use VIR_DOMAIN_EVENT_CALLBACK() to cast the 'cb' parameter */ -int virConnectDomainEventRegisterAny(virConnectPtr conn, - virDomainPtr dom, /* Optional, to filter */ - int eventID, - virConnectDomainEventGenericCallback cb, - void *opaque, - virFreeCallback freecb); - -int virConnectDomainEventDeregisterAny(virConnectPtr conn, - int callbackID); - - -/** - * virDomainConsoleFlags - * - * Since 0.9.10 - */ -typedef enum { - - VIR_DOMAIN_CONSOLE_FORCE = (1 << 0), /* abort a (possibly) active console - connection to force a new - connection */ - VIR_DOMAIN_CONSOLE_SAFE = (1 << 1), /* check if the console driver supports - safe console operations */ -} virDomainConsoleFlags; - -int virDomainOpenConsole(virDomainPtr dom, - const char *dev_name, - virStreamPtr st, - unsigned int flags); - -/** - * virDomainChannelFlags - * - * Since 1.0.2 - */ -typedef enum { - VIR_DOMAIN_CHANNEL_FORCE = (1 << 0), /* abort a (possibly) active channel - connection to force a new - connection */ -} virDomainChannelFlags; - -int virDomainOpenChannel(virDomainPtr dom, - const char *name, - virStreamPtr st, - unsigned int flags); - -typedef enum { - VIR_DOMAIN_OPEN_GRAPHICS_SKIPAUTH = (1 << 0), -} virDomainOpenGraphicsFlags; - -int virDomainOpenGraphics(virDomainPtr dom, - unsigned int idx, - int fd, - unsigned int flags); + VIR_CONNECT_BASELINE_CPU_EXPAND_FEATURES = (1 << 0), /* show all features */ +} virConnectBaselineCPUFlags; -int virDomainOpenGraphicsFD(virDomainPtr dom, - unsigned int idx, +char *virConnectBaselineCPU(virConnectPtr conn, + const char **xmlCPUs, + unsigned int ncpus, unsigned int flags); -int virDomainInjectNMI(virDomainPtr domain, unsigned int flags); - -int virDomainFSTrim(virDomainPtr dom, - const char *mountPoint, - unsigned long long minimum, - unsigned int flags); - -int virDomainFSFreeze(virDomainPtr dom, - const char **mountpoints, - unsigned int nmountpoints, - unsigned int flags); - -int virDomainFSThaw(virDomainPtr dom, - const char **mountpoints, - unsigned int nmountpoints, - unsigned int flags); - -int virDomainGetTime(virDomainPtr dom, - long long *seconds, - unsigned int *nseconds, - unsigned int flags); - -typedef enum { - VIR_DOMAIN_TIME_SYNC = (1 << 0), /* Re-sync domain time from domain's RTC */ -} virDomainSetTimeFlags; - -int virDomainSetTime(virDomainPtr dom, - long long seconds, - unsigned int nseconds, - unsigned int flags); int virNodeGetFreePages(virConnectPtr conn, unsigned int npages, @@ -4277,142 +945,9 @@ int virNodeAllocPages(virConnectPtr conn, int startCell, unsigned int cellCount, unsigned int flags); -/** - * virSchedParameterType: - * - * A scheduler parameter field type. Provided for backwards - * compatibility; virTypedParameterType is the preferred enum since - * 0.9.2. - */ -typedef enum { - VIR_DOMAIN_SCHED_FIELD_INT = VIR_TYPED_PARAM_INT, - VIR_DOMAIN_SCHED_FIELD_UINT = VIR_TYPED_PARAM_UINT, - VIR_DOMAIN_SCHED_FIELD_LLONG = VIR_TYPED_PARAM_LLONG, - VIR_DOMAIN_SCHED_FIELD_ULLONG = VIR_TYPED_PARAM_ULLONG, - VIR_DOMAIN_SCHED_FIELD_DOUBLE = VIR_TYPED_PARAM_DOUBLE, - VIR_DOMAIN_SCHED_FIELD_BOOLEAN = VIR_TYPED_PARAM_BOOLEAN, -} virSchedParameterType; - -/** - * 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. - */ -#define VIR_DOMAIN_SCHED_FIELD_LENGTH VIR_TYPED_PARAM_FIELD_LENGTH - -/** - * virSchedParameter: - * - * a virSchedParameter is the set of scheduler parameters. - * Provided for backwards compatibility; virTypedParameter is the - * preferred alias since 0.9.2. - */ -#define _virSchedParameter _virTypedParameter -typedef struct _virTypedParameter virSchedParameter; - -/** - * virSchedParameterPtr: - * - * a virSchedParameterPtr is a pointer to a virSchedParameter structure. - * Provided for backwards compatibility; virTypedParameterPtr is the - * preferred alias since 0.9.2. - */ -typedef virSchedParameter *virSchedParameterPtr; - -/** - * virBlkioParameterType: - * - * A blkio parameter field type. Provided for backwards - * compatibility; virTypedParameterType is the preferred enum since - * 0.9.2. - */ -typedef enum { - VIR_DOMAIN_BLKIO_PARAM_INT = VIR_TYPED_PARAM_INT, - VIR_DOMAIN_BLKIO_PARAM_UINT = VIR_TYPED_PARAM_UINT, - VIR_DOMAIN_BLKIO_PARAM_LLONG = VIR_TYPED_PARAM_LLONG, - VIR_DOMAIN_BLKIO_PARAM_ULLONG = VIR_TYPED_PARAM_ULLONG, - VIR_DOMAIN_BLKIO_PARAM_DOUBLE = VIR_TYPED_PARAM_DOUBLE, - VIR_DOMAIN_BLKIO_PARAM_BOOLEAN = VIR_TYPED_PARAM_BOOLEAN, -} virBlkioParameterType; - -/** - * 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. - */ -#define VIR_DOMAIN_BLKIO_FIELD_LENGTH VIR_TYPED_PARAM_FIELD_LENGTH - -/** - * virBlkioParameter: - * - * a virBlkioParameter is the set of blkio parameters. - * Provided for backwards compatibility; virTypedParameter is the - * preferred alias since 0.9.2. - */ -#define _virBlkioParameter _virTypedParameter -typedef struct _virTypedParameter virBlkioParameter; - -/** - * virBlkioParameterPtr: - * - * a virBlkioParameterPtr is a pointer to a virBlkioParameter structure. - * Provided for backwards compatibility; virTypedParameterPtr is the - * preferred alias since 0.9.2. - */ -typedef virBlkioParameter *virBlkioParameterPtr; - -/** - * virMemoryParameterType: - * - * A memory parameter field type. Provided for backwards - * compatibility; virTypedParameterType is the preferred enum since - * 0.9.2. - */ -typedef enum { - VIR_DOMAIN_MEMORY_PARAM_INT = VIR_TYPED_PARAM_INT, - VIR_DOMAIN_MEMORY_PARAM_UINT = VIR_TYPED_PARAM_UINT, - VIR_DOMAIN_MEMORY_PARAM_LLONG = VIR_TYPED_PARAM_LLONG, - VIR_DOMAIN_MEMORY_PARAM_ULLONG = VIR_TYPED_PARAM_ULLONG, - VIR_DOMAIN_MEMORY_PARAM_DOUBLE = VIR_TYPED_PARAM_DOUBLE, - VIR_DOMAIN_MEMORY_PARAM_BOOLEAN = VIR_TYPED_PARAM_BOOLEAN, -} virMemoryParameterType; - -/** - * 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. - */ -#define VIR_DOMAIN_MEMORY_FIELD_LENGTH VIR_TYPED_PARAM_FIELD_LENGTH - -/** - * virMemoryParameter: - * - * a virMemoryParameter is the set of scheduler parameters. - * Provided for backwards compatibility; virTypedParameter is the - * preferred alias since 0.9.2. - */ -#define _virMemoryParameter _virTypedParameter -typedef struct _virTypedParameter virMemoryParameter; - -/** - * virMemoryParameterPtr: - * - * a virMemoryParameterPtr is a pointer to a virMemoryParameter structure. - * Provided for backwards compatibility; virTypedParameterPtr is the - * preferred alias since 0.9.2. - */ -typedef virMemoryParameter *virMemoryParameterPtr; - -/* Add new interfaces to the appropriate sections earlier in this - * file; the end of the file is reserved for deprecated names. */ #define __VIR_LIBVIRT_H_INCLUDES__ +#include <libvirt/libvirt-domain.h> #include <libvirt/libvirt-domain-snapshot.h> #include <libvirt/libvirt-event.h> #include <libvirt/libvirt-interface.h> -- 2.1.0