Skip to content

Instantly share code, notes, and snippets.

@Laeeth

Laeeth/libvirt.di

Created April 2, 2018 14:35
Show Gist options
  • Save Laeeth/0266ea4f6d359877bd90f1354953876f to your computer and use it in GitHub Desktop.
Save Laeeth/0266ea4f6d359877bd90f1354953876f to your computer and use it in GitHub Desktop.
Download ZIP
converted libvirt
Raw
libvirt.di
import core.stdc.config;
import core.stdc.stdarg: va_list;
struct struct___locale_data { int dummy; }
typedef unsigned char __u_char;
typedef unsigned short int __u_short;
typedef unsigned int __u_int;
typedef unsigned long int __u_long;
typedef signed char __int8_t;
typedef unsigned char __uint8_t;
typedef signed short int __int16_t;
typedef unsigned short int __uint16_t;
typedef signed int __int32_t;
typedef unsigned int __uint32_t;
typedef signed long int __int64_t;
typedef unsigned long int __uint64_t;
typedef long int __quad_t;
typedef unsigned long int __u_quad_t;
typedef long int __intmax_t;
typedef unsigned long int __uintmax_t;
typedef unsigned long int __dev_t;
typedef unsigned int __uid_t;
typedef unsigned int __gid_t;
typedef unsigned long int __ino_t;
typedef unsigned long int __ino64_t;
typedef unsigned int __mode_t;
typedef unsigned long int __nlink_t;
typedef long int __off_t;
typedef long int __off64_t;
typedef int __pid_t;
typedef struct { int __val[2]; } __fsid_t;
typedef long int __clock_t;
typedef unsigned long int __rlim_t;
typedef unsigned long int __rlim64_t;
typedef unsigned int __id_t;
typedef long int __time_t;
typedef unsigned int __useconds_t;
typedef long int __suseconds_t;
typedef int __daddr_t;
typedef int __key_t;
typedef int __clockid_t;
typedef void * __timer_t;
typedef long int __blksize_t;
typedef long int __blkcnt_t;
typedef long int __blkcnt64_t;
typedef unsigned long int __fsblkcnt_t;
typedef unsigned long int __fsblkcnt64_t;
typedef unsigned long int __fsfilcnt_t;
typedef unsigned long int __fsfilcnt64_t;
typedef long int __fsword_t;
typedef long int __ssize_t;
typedef long int __syscall_slong_t;
typedef unsigned long int __syscall_ulong_t;
typedef __off64_t __loff_t;
typedef __quad_t *__qaddr_t;
typedef char *__caddr_t;
typedef long int __intptr_t;
typedef unsigned int __socklen_t;
typedef int __sig_atomic_t;
typedef __u_char u_char;
typedef __u_short u_short;
typedef __u_int u_int;
typedef __u_long u_long;
typedef __quad_t quad_t;
typedef __u_quad_t u_quad_t;
typedef __fsid_t fsid_t;
typedef __loff_t loff_t;
typedef __ino_t ino_t;
typedef __dev_t dev_t;
typedef __gid_t gid_t;
typedef __mode_t mode_t;
typedef __nlink_t nlink_t;
typedef __uid_t uid_t;
typedef __off_t off_t;
typedef __pid_t pid_t;
typedef __id_t id_t;
typedef __ssize_t ssize_t;
typedef __daddr_t daddr_t;
typedef __caddr_t caddr_t;
typedef __key_t key_t;
typedef __clock_t clock_t;
typedef __clockid_t clockid_t;
typedef __time_t time_t;
typedef __timer_t timer_t;
typedef long unsigned int size_t;
typedef unsigned long int ulong;
typedef unsigned short int ushort;
typedef unsigned int uint;
typedef __int8_t int8_t;
typedef __int16_t int16_t;
typedef __int32_t int32_t;
typedef __int64_t int64_t;
typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__)));
typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__)));
typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__)));
typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__)));
typedef int register_t __attribute__ ((__mode__ (__word__)));
static __inline unsigned int
__bswap_32 (unsigned int __bsx)
{
return __builtin_bswap32 (__bsx);
}
static __inline __uint64_t
__bswap_64 (__uint64_t __bsx)
{
return __builtin_bswap64 (__bsx);
}
static __inline __uint16_t
__uint16_identity (__uint16_t __x)
{
return __x;
}
static __inline __uint32_t
__uint32_identity (__uint32_t __x)
{
return __x;
}
static __inline __uint64_t
__uint64_identity (__uint64_t __x)
{
return __x;
}
typedef struct
{
unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
} __sigset_t;
typedef __sigset_t sigset_t;
struct timeval
{
__time_t tv_sec;
__suseconds_t tv_usec;
};
struct timespec
{
__time_t tv_sec;
__syscall_slong_t tv_nsec;
};
typedef __suseconds_t suseconds_t;
typedef long int __fd_mask;
typedef struct
{
__fd_mask __fds_bits[1024 / (8 * (int) sizeof (__fd_mask))];
} fd_set;
typedef __fd_mask fd_mask;
extern int select (int __nfds, fd_set *__restrict __readfds,
fd_set *__restrict __writefds,
fd_set *__restrict __exceptfds,
struct timeval *__restrict __timeout);
extern int pselect (int __nfds, fd_set *__restrict __readfds,
fd_set *__restrict __writefds,
fd_set *__restrict __exceptfds,
const struct timespec *__restrict __timeout,
const __sigset_t *__restrict __sigmask);
extern unsigned int gnu_dev_major (__dev_t __dev) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
extern unsigned int gnu_dev_minor (__dev_t __dev) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
extern __dev_t gnu_dev_makedev (unsigned int __major, unsigned int __minor) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
typedef __blksize_t blksize_t;
typedef __blkcnt_t blkcnt_t;
typedef __fsblkcnt_t fsblkcnt_t;
typedef __fsfilcnt_t fsfilcnt_t;
struct __pthread_rwlock_arch_t
{
unsigned int __readers;
unsigned int __writers;
unsigned int __wrphase_futex;
unsigned int __writers_futex;
unsigned int __pad3;
unsigned int __pad4;
int __cur_writer;
int __shared;
signed char __rwelision;
unsigned char __pad1[7];
unsigned long int __pad2;
unsigned int __flags;
};
typedef struct __pthread_internal_list
{
struct __pthread_internal_list *__prev;
struct __pthread_internal_list *__next;
} __pthread_list_t;
struct __pthread_mutex_s
{
int __lock ;
unsigned int __count;
int __owner;
unsigned int __nusers;
int __kind;
short __spins; short __elision;
__pthread_list_t __list;
};
struct __pthread_cond_s
{
__extension__ union
{
__extension__ unsigned long long int __wseq;
struct
{
unsigned int __low;
unsigned int __high;
} __wseq32;
};
__extension__ union
{
__extension__ unsigned long long int __g1_start;
struct
{
unsigned int __low;
unsigned int __high;
} __g1_start32;
};
unsigned int __g_refs[2] ;
unsigned int __g_size[2];
unsigned int __g1_orig_size;
unsigned int __wrefs;
unsigned int __g_signals[2];
};
typedef unsigned long int pthread_t;
typedef union
{
char __size[4];
int __align;
} pthread_mutexattr_t;
typedef union
{
char __size[4];
int __align;
} pthread_condattr_t;
typedef unsigned int pthread_key_t;
typedef int pthread_once_t;
union pthread_attr_t
{
char __size[56];
long int __align;
};
typedef union pthread_attr_t pthread_attr_t;
typedef union
{
struct __pthread_mutex_s __data;
char __size[40];
long int __align;
} pthread_mutex_t;
typedef union
{
struct __pthread_cond_s __data;
char __size[48];
__extension__ long long int __align;
} pthread_cond_t;
typedef union
{
struct __pthread_rwlock_arch_t __data;
char __size[56];
long int __align;
} pthread_rwlock_t;
typedef union
{
char __size[8];
long int __align;
} pthread_rwlockattr_t;
typedef volatile int pthread_spinlock_t;
typedef union
{
char __size[32];
long int __align;
} pthread_barrier_t;
typedef union
{
char __size[4];
int __align;
} pthread_barrierattr_t;
typedef void (*virFreeCallback)(void *opaque);
typedef enum {
VIR_CONNECT_CLOSE_REASON_ERROR = 0,
VIR_CONNECT_CLOSE_REASON_EOF = 1,
VIR_CONNECT_CLOSE_REASON_KEEPALIVE = 2,
VIR_CONNECT_CLOSE_REASON_CLIENT = 3,
} virConnectCloseReason;
typedef enum {
VIR_TYPED_PARAM_INT = 1,
VIR_TYPED_PARAM_UINT = 2,
VIR_TYPED_PARAM_LLONG = 3,
VIR_TYPED_PARAM_ULLONG = 4,
VIR_TYPED_PARAM_DOUBLE = 5,
VIR_TYPED_PARAM_BOOLEAN = 6,
VIR_TYPED_PARAM_STRING = 7,
} virTypedParameterType;
typedef enum {
VIR_TYPED_PARAM_STRING_OKAY = 1 << 2,
} virTypedParameterFlags;
typedef struct _virTypedParameter virTypedParameter;
struct _virTypedParameter {
char field[80];
int type;
union {
int i;
unsigned int ui;
long long int l;
unsigned long long int ul;
double d;
char b;
char *s;
} value;
};
typedef virTypedParameter *virTypedParameterPtr;
virTypedParameterPtr virTypedParamsGet(virTypedParameterPtr params,
int nparams,
const char *name);
int virTypedParamsGetInt(virTypedParameterPtr params,
int nparams,
const char *name,
int *value);
int virTypedParamsGetUInt(virTypedParameterPtr params,
int nparams,
const char *name,
unsigned int *value);
int virTypedParamsGetLLong(virTypedParameterPtr params,
int nparams,
const char *name,
long long *value);
int virTypedParamsGetULLong(virTypedParameterPtr params,
int nparams,
const char *name,
unsigned long long *value);
int virTypedParamsGetDouble(virTypedParameterPtr params,
int nparams,
const char *name,
double *value);
int virTypedParamsGetBoolean(virTypedParameterPtr params,
int nparams,
const char *name,
int *value);
int virTypedParamsGetString(virTypedParameterPtr params,
int nparams,
const char *name,
const char **value);
int virTypedParamsAddInt(virTypedParameterPtr *params,
int *nparams,
int *maxparams,
const char *name,
int value);
int virTypedParamsAddUInt(virTypedParameterPtr *params,
int *nparams,
int *maxparams,
const char *name,
unsigned int value);
int virTypedParamsAddLLong(virTypedParameterPtr *params,
int *nparams,
int *maxparams,
const char *name,
long long value);
int virTypedParamsAddULLong(virTypedParameterPtr *params,
int *nparams,
int *maxparams,
const char *name,
unsigned long long value);
int virTypedParamsAddDouble(virTypedParameterPtr *params,
int *nparams,
int *maxparams,
const char *name,
double value);
int virTypedParamsAddBoolean(virTypedParameterPtr *params,
int *nparams,
int *maxparams,
const char *name,
int value);
int virTypedParamsAddString(virTypedParameterPtr *params,
int *nparams,
int *maxparams,
const char *name,
const char *value);
int virTypedParamsAddStringList(virTypedParameterPtr *params,
int *nparams,
int *maxparams,
const char *name,
const char **values);
int virTypedParamsAddFromString(virTypedParameterPtr *params,
int *nparams,
int *maxparams,
const char *name,
int type,
const char *value);
void virTypedParamsClear(virTypedParameterPtr params,
int nparams);
void virTypedParamsFree(virTypedParameterPtr params,
int nparams);
typedef struct _virConnect virConnect;
typedef virConnect *virConnectPtr;
typedef enum {
VIR_NODE_SUSPEND_TARGET_MEM = 0,
VIR_NODE_SUSPEND_TARGET_DISK = 1,
VIR_NODE_SUSPEND_TARGET_HYBRID = 2,
} virNodeSuspendTarget;
typedef struct _virStream virStream;
typedef virStream *virStreamPtr;
typedef struct _virSecurityLabel virSecurityLabel;
struct _virSecurityLabel {
char label[(4096 + 1)];
int enforcing;
};
typedef virSecurityLabel *virSecurityLabelPtr;
typedef struct _virSecurityModel virSecurityModel;
struct _virSecurityModel {
char model[(256 + 1)];
char doi[(256 + 1)];
};
typedef virSecurityModel *virSecurityModelPtr;
typedef struct _virNodeInfo virNodeInfo;
struct _virNodeInfo {
char model[32];
unsigned long memory;
unsigned int cpus;
unsigned int mhz;
unsigned int nodes;
unsigned int sockets;
unsigned int cores;
unsigned int threads;
};
typedef enum {
VIR_NODE_CPU_STATS_ALL_CPUS = -1,
} virNodeGetCPUStatsAllCPUs;
typedef struct _virNodeCPUStats virNodeCPUStats;
struct _virNodeCPUStats {
char field[80];
unsigned long long value;
};
typedef enum {
VIR_NODE_MEMORY_STATS_ALL_CELLS = -1,
} virNodeGetMemoryStatsAllCells;
typedef struct _virNodeMemoryStats virNodeMemoryStats;
struct _virNodeMemoryStats {
char field[80];
unsigned long long value;
};
int virNodeGetMemoryParameters(virConnectPtr conn,
virTypedParameterPtr params,
int *nparams,
unsigned int flags);
int virNodeSetMemoryParameters(virConnectPtr conn,
virTypedParameterPtr params,
int nparams,
unsigned int flags);
int virNodeGetCPUMap(virConnectPtr conn,
unsigned char **cpumap,
unsigned int *online,
unsigned int flags);
typedef virNodeInfo *virNodeInfoPtr;
typedef virNodeCPUStats *virNodeCPUStatsPtr;
typedef virNodeMemoryStats *virNodeMemoryStatsPtr;
typedef enum {
VIR_CONNECT_RO = (1 << 0),
VIR_CONNECT_NO_ALIASES = (1 << 1),
} virConnectFlags;
typedef enum {
VIR_CRED_USERNAME = 1,
VIR_CRED_AUTHNAME = 2,
VIR_CRED_LANGUAGE = 3,
VIR_CRED_CNONCE = 4,
VIR_CRED_PASSPHRASE = 5,
VIR_CRED_ECHOPROMPT = 6,
VIR_CRED_NOECHOPROMPT = 7,
VIR_CRED_REALM = 8,
VIR_CRED_EXTERNAL = 9,
} virConnectCredentialType;
struct _virConnectCredential {
int type;
const char *prompt;
const char *challenge;
const char *defresult;
char *result;
unsigned int resultlen;
};
typedef struct _virConnectCredential virConnectCredential;
typedef virConnectCredential *virConnectCredentialPtr;
typedef int (*virConnectAuthCallbackPtr)(virConnectCredentialPtr cred,
unsigned int ncred,
void *cbdata);
struct _virConnectAuth {
int *credtype;
unsigned int ncredtype;
virConnectAuthCallbackPtr cb;
void *cbdata;
};
typedef struct _virConnectAuth virConnectAuth;
typedef virConnectAuth *virConnectAuthPtr;
extern virConnectAuthPtr virConnectAuthPtrDefault;
int virGetVersion (unsigned long *libVer,
const char *type,
unsigned long *typeVer);
int virInitialize (void);
virConnectPtr virConnectOpen (const char *name);
virConnectPtr virConnectOpenReadOnly (const char *name);
virConnectPtr virConnectOpenAuth (const char *name,
virConnectAuthPtr auth,
unsigned int flags);
int virConnectRef (virConnectPtr conn);
int virConnectClose (virConnectPtr conn);
const char * virConnectGetType (virConnectPtr conn);
int virConnectGetVersion (virConnectPtr conn,
unsigned long *hvVer);
int virConnectGetLibVersion (virConnectPtr conn,
unsigned long *libVer);
char * virConnectGetHostname (virConnectPtr conn);
char * virConnectGetURI (virConnectPtr conn);
char * virConnectGetSysinfo (virConnectPtr conn,
unsigned int flags);
int virConnectSetKeepAlive(virConnectPtr conn,
int interval,
unsigned int count);
typedef void (*virConnectCloseFunc)(virConnectPtr conn,
int reason,
void *opaque);
int virConnectRegisterCloseCallback(virConnectPtr conn,
virConnectCloseFunc cb,
void *opaque,
virFreeCallback freecb);
int virConnectUnregisterCloseCallback(virConnectPtr conn,
virConnectCloseFunc cb);
int virConnectGetMaxVcpus (virConnectPtr conn,
const char *type);
int virNodeGetInfo (virConnectPtr conn,
virNodeInfoPtr info);
char * virConnectGetCapabilities (virConnectPtr conn);
int virNodeGetCPUStats (virConnectPtr conn,
int cpuNum,
virNodeCPUStatsPtr params,
int *nparams,
unsigned int flags);
int virNodeGetMemoryStats (virConnectPtr conn,
int cellNum,
virNodeMemoryStatsPtr params,
int *nparams,
unsigned int flags);
unsigned long long virNodeGetFreeMemory (virConnectPtr conn);
int virNodeGetSecurityModel (virConnectPtr conn,
virSecurityModelPtr secmodel);
int virNodeSuspendForDuration (virConnectPtr conn,
unsigned int target,
unsigned long long duration,
unsigned int flags);
int virNodeGetCellsFreeMemory(virConnectPtr conn,
unsigned long long *freeMems,
int startCell,
int maxCells);
int virConnectIsEncrypted(virConnectPtr conn);
int virConnectIsSecure(virConnectPtr conn);
int virConnectIsAlive(virConnectPtr conn);
typedef enum {
VIR_CPU_COMPARE_ERROR = -1,
VIR_CPU_COMPARE_INCOMPATIBLE = 0,
VIR_CPU_COMPARE_IDENTICAL = 1,
VIR_CPU_COMPARE_SUPERSET = 2,
} virCPUCompareResult;
typedef enum {
VIR_CONNECT_COMPARE_CPU_FAIL_INCOMPATIBLE = (1 << 0),
} virConnectCompareCPUFlags;
int virConnectCompareCPU(virConnectPtr conn,
const char *xmlDesc,
unsigned int flags);
int virConnectGetCPUModelNames(virConnectPtr conn,
const char *arch,
char ***models,
unsigned int flags);
typedef enum {
VIR_CONNECT_BASELINE_CPU_EXPAND_FEATURES = (1 << 0),
VIR_CONNECT_BASELINE_CPU_MIGRATABLE = (1 << 1),
} virConnectBaselineCPUFlags;
char *virConnectBaselineCPU(virConnectPtr conn,
const char **xmlCPUs,
unsigned int ncpus,
unsigned int flags);
int virNodeGetFreePages(virConnectPtr conn,
unsigned int npages,
unsigned int *pages,
int startcell,
unsigned int cellcount,
unsigned long long *counts,
unsigned int flags);
typedef enum {
VIR_NODE_ALLOC_PAGES_ADD = 0,
VIR_NODE_ALLOC_PAGES_SET = (1 << 0),
} virNodeAllocPagesFlags;
int virNodeAllocPages(virConnectPtr conn,
unsigned int npages,
unsigned int *pageSizes,
unsigned long long *pageCounts,
int startCell,
unsigned int cellCount,
unsigned int flags);
typedef struct _virDomain virDomain;
typedef virDomain *virDomainPtr;
typedef enum {
VIR_DOMAIN_NOSTATE = 0,
VIR_DOMAIN_RUNNING = 1,
VIR_DOMAIN_BLOCKED = 2,
VIR_DOMAIN_PAUSED = 3,
VIR_DOMAIN_SHUTDOWN= 4,
VIR_DOMAIN_SHUTOFF = 5,
VIR_DOMAIN_CRASHED = 6,
VIR_DOMAIN_PMSUSPENDED = 7,
} virDomainState;
typedef enum {
VIR_DOMAIN_NOSTATE_UNKNOWN = 0,
} virDomainNostateReason;
typedef enum {
VIR_DOMAIN_RUNNING_UNKNOWN = 0,
VIR_DOMAIN_RUNNING_BOOTED = 1,
VIR_DOMAIN_RUNNING_MIGRATED = 2,
VIR_DOMAIN_RUNNING_RESTORED = 3,
VIR_DOMAIN_RUNNING_FROM_SNAPSHOT = 4,
VIR_DOMAIN_RUNNING_UNPAUSED = 5,
VIR_DOMAIN_RUNNING_MIGRATION_CANCELED = 6,
VIR_DOMAIN_RUNNING_SAVE_CANCELED = 7,
VIR_DOMAIN_RUNNING_WAKEUP = 8,
VIR_DOMAIN_RUNNING_CRASHED = 9,
VIR_DOMAIN_RUNNING_POSTCOPY = 10,
} virDomainRunningReason;
typedef enum {
VIR_DOMAIN_BLOCKED_UNKNOWN = 0,
} virDomainBlockedReason;
typedef enum {
VIR_DOMAIN_PAUSED_UNKNOWN = 0,
VIR_DOMAIN_PAUSED_USER = 1,
VIR_DOMAIN_PAUSED_MIGRATION = 2,
VIR_DOMAIN_PAUSED_SAVE = 3,
VIR_DOMAIN_PAUSED_DUMP = 4,
VIR_DOMAIN_PAUSED_IOERROR = 5,
VIR_DOMAIN_PAUSED_WATCHDOG = 6,
VIR_DOMAIN_PAUSED_FROM_SNAPSHOT = 7,
VIR_DOMAIN_PAUSED_SHUTTING_DOWN = 8,
VIR_DOMAIN_PAUSED_SNAPSHOT = 9,
VIR_DOMAIN_PAUSED_CRASHED = 10,
VIR_DOMAIN_PAUSED_STARTING_UP = 11,
VIR_DOMAIN_PAUSED_POSTCOPY = 12,
VIR_DOMAIN_PAUSED_POSTCOPY_FAILED = 13,
} virDomainPausedReason;
typedef enum {
VIR_DOMAIN_SHUTDOWN_UNKNOWN = 0,
VIR_DOMAIN_SHUTDOWN_USER = 1,
} virDomainShutdownReason;
typedef enum {
VIR_DOMAIN_SHUTOFF_UNKNOWN = 0,
VIR_DOMAIN_SHUTOFF_SHUTDOWN = 1,
VIR_DOMAIN_SHUTOFF_DESTROYED = 2,
VIR_DOMAIN_SHUTOFF_CRASHED = 3,
VIR_DOMAIN_SHUTOFF_MIGRATED = 4,
VIR_DOMAIN_SHUTOFF_SAVED = 5,
VIR_DOMAIN_SHUTOFF_FAILED = 6,
VIR_DOMAIN_SHUTOFF_FROM_SNAPSHOT = 7,
} virDomainShutoffReason;
typedef enum {
VIR_DOMAIN_CRASHED_UNKNOWN = 0,
VIR_DOMAIN_CRASHED_PANICKED = 1,
} virDomainCrashedReason;
typedef enum {
VIR_DOMAIN_PMSUSPENDED_UNKNOWN = 0,
} virDomainPMSuspendedReason;
typedef enum {
VIR_DOMAIN_PMSUSPENDED_DISK_UNKNOWN = 0,
} virDomainPMSuspendedDiskReason;
typedef enum {
VIR_DOMAIN_CONTROL_OK = 0,
VIR_DOMAIN_CONTROL_JOB = 1,
VIR_DOMAIN_CONTROL_OCCUPIED = 2,
VIR_DOMAIN_CONTROL_ERROR = 3,
} virDomainControlState;
typedef enum {
VIR_DOMAIN_CONTROL_ERROR_REASON_NONE = 0,
VIR_DOMAIN_CONTROL_ERROR_REASON_UNKNOWN = 1,
VIR_DOMAIN_CONTROL_ERROR_REASON_MONITOR = 2,
VIR_DOMAIN_CONTROL_ERROR_REASON_INTERNAL = 3,
} virDomainControlErrorReason;
typedef struct _virDomainControlInfo virDomainControlInfo;
struct _virDomainControlInfo {
unsigned int state;
unsigned int details;
unsigned long long stateTime;
};
typedef virDomainControlInfo *virDomainControlInfoPtr;
typedef enum {
VIR_DOMAIN_AFFECT_CURRENT = 0,
VIR_DOMAIN_AFFECT_LIVE = 1 << 0,
VIR_DOMAIN_AFFECT_CONFIG = 1 << 1,
} virDomainModificationImpact;
typedef struct _virDomainInfo virDomainInfo;
struct _virDomainInfo {
unsigned char state;
unsigned long maxMem;
unsigned long memory;
unsigned short nrVirtCpu;
unsigned long long cpuTime;
};
typedef virDomainInfo *virDomainInfoPtr;
typedef enum {
VIR_DOMAIN_NONE = 0,
VIR_DOMAIN_START_PAUSED = 1 << 0,
VIR_DOMAIN_START_AUTODESTROY = 1 << 1,
VIR_DOMAIN_START_BYPASS_CACHE = 1 << 2,
VIR_DOMAIN_START_FORCE_BOOT = 1 << 3,
VIR_DOMAIN_START_VALIDATE = 1 << 4,
} virDomainCreateFlags;
int virDomainGetSchedulerParameters (virDomainPtr domain,
virTypedParameterPtr params,
int *nparams);
int virDomainGetSchedulerParametersFlags (virDomainPtr domain,
virTypedParameterPtr params,
int *nparams,
unsigned int flags);
int virDomainSetSchedulerParameters (virDomainPtr domain,
virTypedParameterPtr params,
int nparams);
int virDomainSetSchedulerParametersFlags (virDomainPtr domain,
virTypedParameterPtr params,
int nparams,
unsigned int flags);
typedef struct _virDomainBlockStats virDomainBlockStatsStruct;
struct _virDomainBlockStats {
long long rd_req;
long long rd_bytes;
long long wr_req;
long long wr_bytes;
long long errs;
};
typedef virDomainBlockStatsStruct *virDomainBlockStatsPtr;
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;
};
typedef virDomainInterfaceStatsStruct *virDomainInterfaceStatsPtr;
typedef enum {
VIR_DOMAIN_MEMORY_STAT_SWAP_IN = 0,
VIR_DOMAIN_MEMORY_STAT_SWAP_OUT = 1,
VIR_DOMAIN_MEMORY_STAT_MAJOR_FAULT = 2,
VIR_DOMAIN_MEMORY_STAT_MINOR_FAULT = 3,
VIR_DOMAIN_MEMORY_STAT_UNUSED = 4,
VIR_DOMAIN_MEMORY_STAT_AVAILABLE = 5,
VIR_DOMAIN_MEMORY_STAT_ACTUAL_BALLOON = 6,
VIR_DOMAIN_MEMORY_STAT_RSS = 7,
VIR_DOMAIN_MEMORY_STAT_USABLE = 8,
VIR_DOMAIN_MEMORY_STAT_LAST_UPDATE = 9,
VIR_DOMAIN_MEMORY_STAT_NR = 10,
} virDomainMemoryStatTags;
typedef struct _virDomainMemoryStat virDomainMemoryStatStruct;
struct _virDomainMemoryStat {
int tag;
unsigned long long val;
};
typedef virDomainMemoryStatStruct *virDomainMemoryStatPtr;
typedef enum {
VIR_DUMP_CRASH = (1 << 0),
VIR_DUMP_LIVE = (1 << 1),
VIR_DUMP_BYPASS_CACHE = (1 << 2),
VIR_DUMP_RESET = (1 << 3),
VIR_DUMP_MEMORY_ONLY = (1 << 4),
} virDomainCoreDumpFlags;
typedef enum {
VIR_DOMAIN_CORE_DUMP_FORMAT_RAW,
VIR_DOMAIN_CORE_DUMP_FORMAT_KDUMP_ZLIB,
VIR_DOMAIN_CORE_DUMP_FORMAT_KDUMP_LZO,
VIR_DOMAIN_CORE_DUMP_FORMAT_KDUMP_SNAPPY,
} virDomainCoreDumpFormat;
typedef enum {
VIR_MIGRATE_LIVE = (1 << 0),
VIR_MIGRATE_PEER2PEER = (1 << 1),
VIR_MIGRATE_TUNNELLED = (1 << 2),
VIR_MIGRATE_PERSIST_DEST = (1 << 3),
VIR_MIGRATE_UNDEFINE_SOURCE = (1 << 4),
VIR_MIGRATE_PAUSED = (1 << 5),
VIR_MIGRATE_NON_SHARED_DISK = (1 << 6),
VIR_MIGRATE_NON_SHARED_INC = (1 << 7),
VIR_MIGRATE_CHANGE_PROTECTION = (1 << 8),
VIR_MIGRATE_UNSAFE = (1 << 9),
VIR_MIGRATE_OFFLINE = (1 << 10),
VIR_MIGRATE_COMPRESSED = (1 << 11),
VIR_MIGRATE_ABORT_ON_ERROR = (1 << 12),
VIR_MIGRATE_AUTO_CONVERGE = (1 << 13),
VIR_MIGRATE_RDMA_PIN_ALL = (1 << 14),
VIR_MIGRATE_POSTCOPY = (1 << 15),
VIR_MIGRATE_TLS = (1 << 16),
} virDomainMigrateFlags;
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 virDomainMigrateGetMaxDowntime(virDomainPtr domain,
unsigned long long *downtime,
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);
int virDomainMigrateStartPostCopy(virDomainPtr domain,
unsigned int flags);
char * virConnectGetDomainCapabilities(virConnectPtr conn,
const char *emulatorbin,
const char *arch,
const char *machine,
const char *virttype,
unsigned int flags);
int virConnectListDomains (virConnectPtr conn,
int *ids,
int maxids);
int virConnectNumOfDomains (virConnectPtr conn);
virConnectPtr virDomainGetConnect (virDomainPtr domain);
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,
VIR_DOMAIN_SHUTDOWN_ACPI_POWER_BTN = (1 << 0),
VIR_DOMAIN_SHUTDOWN_GUEST_AGENT = (1 << 1),
VIR_DOMAIN_SHUTDOWN_INITCTL = (1 << 2),
VIR_DOMAIN_SHUTDOWN_SIGNAL = (1 << 3),
VIR_DOMAIN_SHUTDOWN_PARAVIRT = (1 << 4),
} virDomainShutdownFlagValues;
int virDomainShutdown (virDomainPtr domain);
int virDomainShutdownFlags (virDomainPtr domain,
unsigned int flags);
typedef enum {
VIR_DOMAIN_REBOOT_DEFAULT = 0,
VIR_DOMAIN_REBOOT_ACPI_POWER_BTN = (1 << 0),
VIR_DOMAIN_REBOOT_GUEST_AGENT = (1 << 1),
VIR_DOMAIN_REBOOT_INITCTL = (1 << 2),
VIR_DOMAIN_REBOOT_SIGNAL = (1 << 3),
VIR_DOMAIN_REBOOT_PARAVIRT = (1 << 4),
} virDomainRebootFlagValues;
int virDomainReboot (virDomainPtr domain,
unsigned int flags);
int virDomainReset (virDomainPtr domain,
unsigned int flags);
int virDomainDestroy (virDomainPtr domain);
typedef enum {
VIR_DOMAIN_DESTROY_DEFAULT = 0,
VIR_DOMAIN_DESTROY_GRACEFUL = 1 << 0,
} virDomainDestroyFlagsValues;
int virDomainDestroyFlags (virDomainPtr domain,
unsigned int flags);
int virDomainRef (virDomainPtr domain);
int virDomainFree (virDomainPtr domain);
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);
typedef enum {
VIR_DOMAIN_SAVE_BYPASS_CACHE = 1 << 0,
VIR_DOMAIN_SAVE_RUNNING = 1 << 1,
VIR_DOMAIN_SAVE_PAUSED = 1 << 2,
} 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);
int virDomainManagedSave (virDomainPtr dom,
unsigned int flags);
int virDomainHasManagedSaveImage(virDomainPtr dom,
unsigned int flags);
int virDomainManagedSaveRemove(virDomainPtr dom,
unsigned int flags);
char * virDomainManagedSaveGetXMLDesc(virDomainPtr domain,
unsigned int flags);
int virDomainManagedSaveDefineXML(virDomainPtr domain,
const char *dxml,
unsigned int flags);
int virDomainCoreDump (virDomainPtr domain,
const char *to,
unsigned int flags);
int virDomainCoreDumpWithFormat (virDomainPtr domain,
const char *to,
unsigned int dumpformat,
unsigned int flags);
char * virDomainScreenshot (virDomainPtr domain,
virStreamPtr stream,
unsigned int screen,
unsigned int flags);
int virDomainGetInfo (virDomainPtr domain,
virDomainInfoPtr info);
int virDomainGetState (virDomainPtr domain,
int *state,
int *reason,
unsigned int flags);
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);
char * virDomainGetSchedulerType(virDomainPtr domain,
int *nparams);
int virDomainSetBlkioParameters(virDomainPtr domain,
virTypedParameterPtr params,
int nparams, unsigned int flags);
int virDomainGetBlkioParameters(virDomainPtr domain,
virTypedParameterPtr params,
int *nparams, unsigned int flags);
int virDomainSetMemoryParameters(virDomainPtr domain,
virTypedParameterPtr params,
int nparams, unsigned int flags);
int virDomainGetMemoryParameters(virDomainPtr domain,
virTypedParameterPtr params,
int *nparams, unsigned int flags);
typedef enum {
VIR_DOMAIN_MEM_CURRENT = VIR_DOMAIN_AFFECT_CURRENT,
VIR_DOMAIN_MEM_LIVE = VIR_DOMAIN_AFFECT_LIVE,
VIR_DOMAIN_MEM_CONFIG = VIR_DOMAIN_AFFECT_CONFIG,
VIR_DOMAIN_MEM_MAXIMUM = (1 << 2),
} virDomainMemoryModFlags;
typedef enum {
VIR_DOMAIN_NUMATUNE_MEM_STRICT = 0,
VIR_DOMAIN_NUMATUNE_MEM_PREFERRED = 1,
VIR_DOMAIN_NUMATUNE_MEM_INTERLEAVE = 2,
} virDomainNumatuneMemMode;
int virDomainSetNumaParameters(virDomainPtr domain,
virTypedParameterPtr params,
int nparams, unsigned int flags);
int virDomainGetNumaParameters(virDomainPtr domain,
virTypedParameterPtr params,
int *nparams, unsigned int flags);
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,
VIR_DOMAIN_METADATA_TITLE = 1,
VIR_DOMAIN_METADATA_ELEMENT = 2,
} 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);
typedef enum {
VIR_DOMAIN_XML_SECURE = (1 << 0),
VIR_DOMAIN_XML_INACTIVE = (1 << 1),
VIR_DOMAIN_XML_UPDATE_CPU = (1 << 2),
VIR_DOMAIN_XML_MIGRATABLE = (1 << 3),
} 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 *device,
virDomainInterfaceStatsPtr stats,
size_t size);
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);
int virDomainBlockPeek (virDomainPtr dom,
const char *disk,
unsigned long long offset,
size_t size,
void *buffer,
unsigned int flags);
typedef enum {
VIR_DOMAIN_BLOCK_RESIZE_BYTES = 1 << 0,
} virDomainBlockResizeFlags;
int virDomainBlockResize (virDomainPtr dom,
const char *disk,
unsigned long long size,
unsigned int flags);
typedef struct _virDomainBlockInfo virDomainBlockInfo;
typedef virDomainBlockInfo *virDomainBlockInfoPtr;
struct _virDomainBlockInfo {
unsigned long long capacity;
unsigned long long allocation;
unsigned long long physical;
};
int virDomainGetBlockInfo(virDomainPtr dom,
const char *disk,
virDomainBlockInfoPtr info,
unsigned int flags);
int virDomainMemoryStats (virDomainPtr dom,
virDomainMemoryStatPtr stats,
unsigned int nr_stats,
unsigned int flags);
typedef enum {
VIR_MEMORY_VIRTUAL = 1 << 0,
VIR_MEMORY_PHYSICAL = 1 << 1,
} virDomainMemoryFlags;
int virDomainMemoryPeek (virDomainPtr dom,
unsigned long long start,
size_t size,
void *buffer,
unsigned int flags);
typedef enum {
VIR_DOMAIN_DEFINE_VALIDATE = (1 << 0),
} virDomainDefineFlags;
virDomainPtr virDomainDefineXML (virConnectPtr conn,
const char *xml);
virDomainPtr virDomainDefineXMLFlags (virConnectPtr conn,
const char *xml,
unsigned int flags);
int virDomainUndefine (virDomainPtr domain);
typedef enum {
VIR_DOMAIN_UNDEFINE_MANAGED_SAVE = (1 << 0),
VIR_DOMAIN_UNDEFINE_SNAPSHOTS_METADATA = (1 << 1),
VIR_DOMAIN_UNDEFINE_NVRAM = (1 << 2),
VIR_DOMAIN_UNDEFINE_KEEP_NVRAM = (1 << 3),
} virDomainUndefineFlagsValues;
int virDomainUndefineFlags (virDomainPtr domain,
unsigned int flags);
int virConnectNumOfDefinedDomains (virConnectPtr conn);
int virConnectListDefinedDomains (virConnectPtr conn,
char **const names,
int maxnames);
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);
typedef enum {
VIR_VCPU_OFFLINE = 0,
VIR_VCPU_RUNNING = 1,
VIR_VCPU_BLOCKED = 2,
} virVcpuState;
typedef struct _virVcpuInfo virVcpuInfo;
struct _virVcpuInfo {
unsigned int number;
int state;
unsigned long long cpuTime;
int cpu;
};
typedef virVcpuInfo *virVcpuInfoPtr;
typedef enum {
VIR_DOMAIN_VCPU_CURRENT = VIR_DOMAIN_AFFECT_CURRENT,
VIR_DOMAIN_VCPU_LIVE = VIR_DOMAIN_AFFECT_LIVE,
VIR_DOMAIN_VCPU_CONFIG = VIR_DOMAIN_AFFECT_CONFIG,
VIR_DOMAIN_VCPU_MAXIMUM = (1 << 2),
VIR_DOMAIN_VCPU_GUEST = (1 << 3),
VIR_DOMAIN_VCPU_HOTPLUGGABLE = (1 << 4),
} 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);
typedef struct _virDomainIOThreadInfo virDomainIOThreadInfo;
typedef virDomainIOThreadInfo *virDomainIOThreadInfoPtr;
struct _virDomainIOThreadInfo {
unsigned int iothread_id;
unsigned char *cpumap;
int cpumaplen;
};
void virDomainIOThreadInfoFree(virDomainIOThreadInfoPtr info);
int virDomainGetIOThreadInfo(virDomainPtr domain,
virDomainIOThreadInfoPtr **info,
unsigned int flags);
int virDomainPinIOThread(virDomainPtr domain,
unsigned int iothread_id,
unsigned char *cpumap,
int maplen,
unsigned int flags);
int virDomainAddIOThread(virDomainPtr domain,
unsigned int iothread_id,
unsigned int flags);
int virDomainDelIOThread(virDomainPtr domain,
unsigned int iothread_id,
unsigned int flags);
int virDomainGetVcpus (virDomainPtr domain,
virVcpuInfoPtr info,
int maxinfo,
unsigned char *cpumaps,
int maplen);
typedef enum {
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,
VIR_DOMAIN_DEVICE_MODIFY_FORCE = (1 << 2),
} 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),
VIR_DOMAIN_STATS_CPU_TOTAL = (1 << 1),
VIR_DOMAIN_STATS_BALLOON = (1 << 2),
VIR_DOMAIN_STATS_VCPU = (1 << 3),
VIR_DOMAIN_STATS_INTERFACE = (1 << 4),
VIR_DOMAIN_STATS_BLOCK = (1 << 5),
VIR_DOMAIN_STATS_PERF = (1 << 6),
} 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_BACKING = 1 << 30,
VIR_CONNECT_GET_ALL_DOMAINS_STATS_ENFORCE_STATS = 1U << 31,
} 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);
int virDomainGetPerfEvents(virDomainPtr dom,
virTypedParameterPtr *params,
int *nparams,
unsigned int flags);
int virDomainSetPerfEvents(virDomainPtr dom,
virTypedParameterPtr params,
int nparams,
unsigned int flags);
typedef enum {
VIR_DOMAIN_BLOCK_JOB_TYPE_UNKNOWN = 0,
VIR_DOMAIN_BLOCK_JOB_TYPE_PULL = 1,
VIR_DOMAIN_BLOCK_JOB_TYPE_COPY = 2,
VIR_DOMAIN_BLOCK_JOB_TYPE_COMMIT = 3,
VIR_DOMAIN_BLOCK_JOB_TYPE_ACTIVE_COMMIT = 4,
} virDomainBlockJobType;
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);
typedef enum {
VIR_DOMAIN_BLOCK_JOB_INFO_BANDWIDTH_BYTES = 1 << 0,
} virDomainBlockJobInfoFlags;
typedef unsigned long long virDomainBlockJobCursor;
typedef struct _virDomainBlockJobInfo virDomainBlockJobInfo;
struct _virDomainBlockJobInfo {
int type;
unsigned long bandwidth;
virDomainBlockJobCursor cur;
virDomainBlockJobCursor end;
};
typedef virDomainBlockJobInfo *virDomainBlockJobInfoPtr;
int virDomainGetBlockJobInfo(virDomainPtr dom, const char *disk,
virDomainBlockJobInfoPtr info,
unsigned int flags);
typedef enum {
VIR_DOMAIN_BLOCK_JOB_SPEED_BANDWIDTH_BYTES = 1 << 0,
} virDomainBlockJobSetSpeedFlags;
int virDomainBlockJobSetSpeed(virDomainPtr dom, const char *disk,
unsigned long bandwidth, unsigned int flags);
typedef enum {
VIR_DOMAIN_BLOCK_PULL_BANDWIDTH_BYTES = 1 << 6,
} virDomainBlockPullFlags;
int virDomainBlockPull(virDomainPtr dom, const char *disk,
unsigned long bandwidth, unsigned int flags);
typedef enum {
VIR_DOMAIN_BLOCK_REBASE_SHALLOW = 1 << 0,
VIR_DOMAIN_BLOCK_REBASE_REUSE_EXT = 1 << 1,
VIR_DOMAIN_BLOCK_REBASE_COPY_RAW = 1 << 2,
VIR_DOMAIN_BLOCK_REBASE_COPY = 1 << 3,
VIR_DOMAIN_BLOCK_REBASE_RELATIVE = 1 << 4,
VIR_DOMAIN_BLOCK_REBASE_COPY_DEV = 1 << 5,
VIR_DOMAIN_BLOCK_REBASE_BANDWIDTH_BYTES = 1 << 6,
} virDomainBlockRebaseFlags;
int virDomainBlockRebase(virDomainPtr dom, const char *disk,
const char *base, unsigned long bandwidth,
unsigned int flags);
typedef enum {
VIR_DOMAIN_BLOCK_COPY_SHALLOW = 1 << 0,
VIR_DOMAIN_BLOCK_COPY_REUSE_EXT = 1 << 1,
VIR_DOMAIN_BLOCK_COPY_TRANSIENT_JOB = 1 << 2,
} virDomainBlockCopyFlags;
int virDomainBlockCopy(virDomainPtr dom, const char *disk,
const char *destxml,
virTypedParameterPtr params,
int nparams,
unsigned int flags);
typedef enum {
VIR_DOMAIN_BLOCK_COMMIT_SHALLOW = 1 << 0,
VIR_DOMAIN_BLOCK_COMMIT_DELETE = 1 << 1,
VIR_DOMAIN_BLOCK_COMMIT_ACTIVE = 1 << 2,
VIR_DOMAIN_BLOCK_COMMIT_RELATIVE = 1 << 3,
VIR_DOMAIN_BLOCK_COMMIT_BANDWIDTH_BYTES = 1 << 4,
} virDomainBlockCommitFlags;
int virDomainBlockCommit(virDomainPtr dom, const char *disk, const char *base,
const char *top, unsigned long bandwidth,
unsigned int flags);
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);
typedef enum {
VIR_DOMAIN_DISK_ERROR_NONE = 0,
VIR_DOMAIN_DISK_ERROR_UNSPEC = 1,
VIR_DOMAIN_DISK_ERROR_NO_SPACE = 2,
} virDomainDiskErrorCode;
typedef struct _virDomainDiskError virDomainDiskError;
typedef virDomainDiskError *virDomainDiskErrorPtr;
struct _virDomainDiskError {
char *disk;
int error;
};
int virDomainGetDiskErrors(virDomainPtr dom,
virDomainDiskErrorPtr errors,
unsigned int maxerrors,
unsigned int flags);
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_QNUM = 9,
} virKeycodeSet;
int virDomainSendKey(virDomainPtr domain,
unsigned int codeset,
unsigned int holdtime,
unsigned int *keycodes,
int nkeycodes,
unsigned int flags);
typedef enum {
VIR_DOMAIN_PROCESS_SIGNAL_NOP = 0,
VIR_DOMAIN_PROCESS_SIGNAL_HUP = 1,
VIR_DOMAIN_PROCESS_SIGNAL_INT = 2,
VIR_DOMAIN_PROCESS_SIGNAL_QUIT = 3,
VIR_DOMAIN_PROCESS_SIGNAL_ILL = 4,
VIR_DOMAIN_PROCESS_SIGNAL_TRAP = 5,
VIR_DOMAIN_PROCESS_SIGNAL_ABRT = 6,
VIR_DOMAIN_PROCESS_SIGNAL_BUS = 7,
VIR_DOMAIN_PROCESS_SIGNAL_FPE = 8,
VIR_DOMAIN_PROCESS_SIGNAL_KILL = 9,
VIR_DOMAIN_PROCESS_SIGNAL_USR1 = 10,
VIR_DOMAIN_PROCESS_SIGNAL_SEGV = 11,
VIR_DOMAIN_PROCESS_SIGNAL_USR2 = 12,
VIR_DOMAIN_PROCESS_SIGNAL_PIPE = 13,
VIR_DOMAIN_PROCESS_SIGNAL_ALRM = 14,
VIR_DOMAIN_PROCESS_SIGNAL_TERM = 15,
VIR_DOMAIN_PROCESS_SIGNAL_STKFLT = 16,
VIR_DOMAIN_PROCESS_SIGNAL_CHLD = 17,
VIR_DOMAIN_PROCESS_SIGNAL_CONT = 18,
VIR_DOMAIN_PROCESS_SIGNAL_STOP = 19,
VIR_DOMAIN_PROCESS_SIGNAL_TSTP = 20,
VIR_DOMAIN_PROCESS_SIGNAL_TTIN = 21,
VIR_DOMAIN_PROCESS_SIGNAL_TTOU = 22,
VIR_DOMAIN_PROCESS_SIGNAL_URG = 23,
VIR_DOMAIN_PROCESS_SIGNAL_XCPU = 24,
VIR_DOMAIN_PROCESS_SIGNAL_XFSZ = 25,
VIR_DOMAIN_PROCESS_SIGNAL_VTALRM = 26,
VIR_DOMAIN_PROCESS_SIGNAL_PROF = 27,
VIR_DOMAIN_PROCESS_SIGNAL_WINCH = 28,
VIR_DOMAIN_PROCESS_SIGNAL_POLL = 29,
VIR_DOMAIN_PROCESS_SIGNAL_PWR = 30,
VIR_DOMAIN_PROCESS_SIGNAL_SYS = 31,
VIR_DOMAIN_PROCESS_SIGNAL_RT0 = 32,
VIR_DOMAIN_PROCESS_SIGNAL_RT1 = 33,
VIR_DOMAIN_PROCESS_SIGNAL_RT2 = 34,
VIR_DOMAIN_PROCESS_SIGNAL_RT3 = 35,
VIR_DOMAIN_PROCESS_SIGNAL_RT4 = 36,
VIR_DOMAIN_PROCESS_SIGNAL_RT5 = 37,
VIR_DOMAIN_PROCESS_SIGNAL_RT6 = 38,
VIR_DOMAIN_PROCESS_SIGNAL_RT7 = 39,
VIR_DOMAIN_PROCESS_SIGNAL_RT8 = 40,
VIR_DOMAIN_PROCESS_SIGNAL_RT9 = 41,
VIR_DOMAIN_PROCESS_SIGNAL_RT10 = 42,
VIR_DOMAIN_PROCESS_SIGNAL_RT11 = 43,
VIR_DOMAIN_PROCESS_SIGNAL_RT12 = 44,
VIR_DOMAIN_PROCESS_SIGNAL_RT13 = 45,
VIR_DOMAIN_PROCESS_SIGNAL_RT14 = 46,
VIR_DOMAIN_PROCESS_SIGNAL_RT15 = 47,
VIR_DOMAIN_PROCESS_SIGNAL_RT16 = 48,
VIR_DOMAIN_PROCESS_SIGNAL_RT17 = 49,
VIR_DOMAIN_PROCESS_SIGNAL_RT18 = 50,
VIR_DOMAIN_PROCESS_SIGNAL_RT19 = 51,
VIR_DOMAIN_PROCESS_SIGNAL_RT20 = 52,
VIR_DOMAIN_PROCESS_SIGNAL_RT21 = 53,
VIR_DOMAIN_PROCESS_SIGNAL_RT22 = 54,
VIR_DOMAIN_PROCESS_SIGNAL_RT23 = 55,
VIR_DOMAIN_PROCESS_SIGNAL_RT24 = 56,
VIR_DOMAIN_PROCESS_SIGNAL_RT25 = 57,
VIR_DOMAIN_PROCESS_SIGNAL_RT26 = 58,
VIR_DOMAIN_PROCESS_SIGNAL_RT27 = 59,
VIR_DOMAIN_PROCESS_SIGNAL_RT28 = 60,
VIR_DOMAIN_PROCESS_SIGNAL_RT29 = 61,
VIR_DOMAIN_PROCESS_SIGNAL_RT30 = 62,
VIR_DOMAIN_PROCESS_SIGNAL_RT31 = 63,
VIR_DOMAIN_PROCESS_SIGNAL_RT32 = 64,
} virDomainProcessSignal;
int virDomainSendProcessSignal(virDomainPtr domain,
long long pid_value,
unsigned int signum,
unsigned int flags);
virDomainPtr virDomainCreateLinux (virConnectPtr conn,
const char *xmlDesc,
unsigned int flags);
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,
} virDomainEventType;
typedef enum {
VIR_DOMAIN_EVENT_DEFINED_ADDED = 0,
VIR_DOMAIN_EVENT_DEFINED_UPDATED = 1,
VIR_DOMAIN_EVENT_DEFINED_RENAMED = 2,
VIR_DOMAIN_EVENT_DEFINED_FROM_SNAPSHOT = 3,
} virDomainEventDefinedDetailType;
typedef enum {
VIR_DOMAIN_EVENT_UNDEFINED_REMOVED = 0,
VIR_DOMAIN_EVENT_UNDEFINED_RENAMED = 1,
} virDomainEventUndefinedDetailType;
typedef enum {
VIR_DOMAIN_EVENT_STARTED_BOOTED = 0,
VIR_DOMAIN_EVENT_STARTED_MIGRATED = 1,
VIR_DOMAIN_EVENT_STARTED_RESTORED = 2,
VIR_DOMAIN_EVENT_STARTED_FROM_SNAPSHOT = 3,
VIR_DOMAIN_EVENT_STARTED_WAKEUP = 4,
} virDomainEventStartedDetailType;
typedef enum {
VIR_DOMAIN_EVENT_SUSPENDED_PAUSED = 0,
VIR_DOMAIN_EVENT_SUSPENDED_MIGRATED = 1,
VIR_DOMAIN_EVENT_SUSPENDED_IOERROR = 2,
VIR_DOMAIN_EVENT_SUSPENDED_WATCHDOG = 3,
VIR_DOMAIN_EVENT_SUSPENDED_RESTORED = 4,
VIR_DOMAIN_EVENT_SUSPENDED_FROM_SNAPSHOT = 5,
VIR_DOMAIN_EVENT_SUSPENDED_API_ERROR = 6,
VIR_DOMAIN_EVENT_SUSPENDED_POSTCOPY = 7,
VIR_DOMAIN_EVENT_SUSPENDED_POSTCOPY_FAILED = 8,
} virDomainEventSuspendedDetailType;
typedef enum {
VIR_DOMAIN_EVENT_RESUMED_UNPAUSED = 0,
VIR_DOMAIN_EVENT_RESUMED_MIGRATED = 1,
VIR_DOMAIN_EVENT_RESUMED_FROM_SNAPSHOT = 2,
VIR_DOMAIN_EVENT_RESUMED_POSTCOPY = 3,
} virDomainEventResumedDetailType;
typedef enum {
VIR_DOMAIN_EVENT_STOPPED_SHUTDOWN = 0,
VIR_DOMAIN_EVENT_STOPPED_DESTROYED = 1,
VIR_DOMAIN_EVENT_STOPPED_CRASHED = 2,
VIR_DOMAIN_EVENT_STOPPED_MIGRATED = 3,
VIR_DOMAIN_EVENT_STOPPED_SAVED = 4,
VIR_DOMAIN_EVENT_STOPPED_FAILED = 5,
VIR_DOMAIN_EVENT_STOPPED_FROM_SNAPSHOT = 6,
} virDomainEventStoppedDetailType;
typedef enum {
VIR_DOMAIN_EVENT_SHUTDOWN_FINISHED = 0,
VIR_DOMAIN_EVENT_SHUTDOWN_GUEST = 1,
VIR_DOMAIN_EVENT_SHUTDOWN_HOST = 2,
} virDomainEventShutdownDetailType;
typedef enum {
VIR_DOMAIN_EVENT_PMSUSPENDED_MEMORY = 0,
VIR_DOMAIN_EVENT_PMSUSPENDED_DISK = 1,
} virDomainEventPMSuspendedDetailType;
typedef enum {
VIR_DOMAIN_EVENT_CRASHED_PANICKED = 0,
} virDomainEventCrashedDetailType;
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,
VIR_DOMAIN_JOB_BOUNDED = 1,
VIR_DOMAIN_JOB_UNBOUNDED = 2,
VIR_DOMAIN_JOB_COMPLETED = 3,
VIR_DOMAIN_JOB_FAILED = 4,
VIR_DOMAIN_JOB_CANCELLED = 5,
} virDomainJobType;
typedef struct _virDomainJobInfo virDomainJobInfo;
typedef virDomainJobInfo *virDomainJobInfoPtr;
struct _virDomainJobInfo {
int type;
unsigned long long timeElapsed;
unsigned long long timeRemaining;
unsigned long long dataTotal;
unsigned long long dataProcessed;
unsigned long long dataRemaining;
unsigned long long memTotal;
unsigned long long memProcessed;
unsigned long long memRemaining;
unsigned long long fileTotal;
unsigned long long fileProcessed;
unsigned long long fileRemaining;
};
typedef enum {
VIR_DOMAIN_JOB_STATS_COMPLETED = 1 << 0,
} virDomainGetJobStatsFlags;
int virDomainGetJobInfo(virDomainPtr dom,
virDomainJobInfoPtr info);
int virDomainGetJobStats(virDomainPtr domain,
int *type,
virTypedParameterPtr *params,
int *nparams,
unsigned int flags);
int virDomainAbortJob(virDomainPtr dom);
typedef enum {
VIR_DOMAIN_JOB_OPERATION_UNKNOWN = 0,
VIR_DOMAIN_JOB_OPERATION_START = 1,
VIR_DOMAIN_JOB_OPERATION_SAVE = 2,
VIR_DOMAIN_JOB_OPERATION_RESTORE = 3,
VIR_DOMAIN_JOB_OPERATION_MIGRATION_IN = 4,
VIR_DOMAIN_JOB_OPERATION_MIGRATION_OUT = 5,
VIR_DOMAIN_JOB_OPERATION_SNAPSHOT = 6,
VIR_DOMAIN_JOB_OPERATION_SNAPSHOT_REVERT = 7,
VIR_DOMAIN_JOB_OPERATION_DUMP = 8,
} virDomainJobOperation;
typedef void (*virConnectDomainEventGenericCallback)(virConnectPtr conn,
virDomainPtr dom,
void *opaque);
typedef void (*virConnectDomainEventRTCChangeCallback)(virConnectPtr conn,
virDomainPtr dom,
long long utcoffset,
void *opaque);
typedef enum {
VIR_DOMAIN_EVENT_WATCHDOG_NONE = 0,
VIR_DOMAIN_EVENT_WATCHDOG_PAUSE,
VIR_DOMAIN_EVENT_WATCHDOG_RESET,
VIR_DOMAIN_EVENT_WATCHDOG_POWEROFF,
VIR_DOMAIN_EVENT_WATCHDOG_SHUTDOWN,
VIR_DOMAIN_EVENT_WATCHDOG_DEBUG,
VIR_DOMAIN_EVENT_WATCHDOG_INJECTNMI,
} virDomainEventWatchdogAction;
typedef void (*virConnectDomainEventWatchdogCallback)(virConnectPtr conn,
virDomainPtr dom,
int action,
void *opaque);
typedef enum {
VIR_DOMAIN_EVENT_IO_ERROR_NONE = 0,
VIR_DOMAIN_EVENT_IO_ERROR_PAUSE,
VIR_DOMAIN_EVENT_IO_ERROR_REPORT,
} virDomainEventIOErrorAction;
typedef void (*virConnectDomainEventIOErrorCallback)(virConnectPtr conn,
virDomainPtr dom,
const char *srcPath,
const char *devAlias,
int action,
void *opaque);
typedef void (*virConnectDomainEventIOErrorReasonCallback)(virConnectPtr conn,
virDomainPtr dom,
const char *srcPath,
const char *devAlias,
int action,
const char *reason,
void *opaque);
typedef enum {
VIR_DOMAIN_EVENT_GRAPHICS_CONNECT = 0,
VIR_DOMAIN_EVENT_GRAPHICS_INITIALIZE,
VIR_DOMAIN_EVENT_GRAPHICS_DISCONNECT,
} virDomainEventGraphicsPhase;
typedef enum {
VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_IPV4,
VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_IPV6,
VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_UNIX,
} virDomainEventGraphicsAddressType;
struct _virDomainEventGraphicsAddress {
int family;
char *node;
char *service;
};
typedef struct _virDomainEventGraphicsAddress virDomainEventGraphicsAddress;
typedef virDomainEventGraphicsAddress *virDomainEventGraphicsAddressPtr;
struct _virDomainEventGraphicsSubjectIdentity {
char *type;
char *name;
};
typedef struct _virDomainEventGraphicsSubjectIdentity virDomainEventGraphicsSubjectIdentity;
typedef virDomainEventGraphicsSubjectIdentity *virDomainEventGraphicsSubjectIdentityPtr;
struct _virDomainEventGraphicsSubject {
int nidentity;
virDomainEventGraphicsSubjectIdentityPtr identities;
};
typedef struct _virDomainEventGraphicsSubject virDomainEventGraphicsSubject;
typedef virDomainEventGraphicsSubject *virDomainEventGraphicsSubjectPtr;
typedef void (*virConnectDomainEventGraphicsCallback)(virConnectPtr conn,
virDomainPtr dom,
int phase,
const virDomainEventGraphicsAddress *local,
const virDomainEventGraphicsAddress *remote,
const char *authScheme,
const virDomainEventGraphicsSubject *subject,
void *opaque);
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,
} virConnectDomainEventBlockJobStatus;
typedef void (*virConnectDomainEventBlockJobCallback)(virConnectPtr conn,
virDomainPtr dom,
const char *disk,
int type,
int status,
void *opaque);
typedef enum {
VIR_DOMAIN_EVENT_DISK_CHANGE_MISSING_ON_START = 0,
VIR_DOMAIN_EVENT_DISK_DROP_MISSING_ON_START = 1,
} virConnectDomainEventDiskChangeReason;
typedef void (*virConnectDomainEventDiskChangeCallback)(virConnectPtr conn,
virDomainPtr dom,
const char *oldSrcPath,
const char *newSrcPath,
const char *devAlias,
int reason,
void *opaque);
typedef enum {
VIR_DOMAIN_EVENT_TRAY_CHANGE_OPEN = 0,
VIR_DOMAIN_EVENT_TRAY_CHANGE_CLOSE,
} virDomainEventTrayChangeReason;
typedef void (*virConnectDomainEventTrayChangeCallback)(virConnectPtr conn,
virDomainPtr dom,
const char *devAlias,
int reason,
void *opaque);
typedef void (*virConnectDomainEventPMWakeupCallback)(virConnectPtr conn,
virDomainPtr dom,
int reason,
void *opaque);
typedef void (*virConnectDomainEventPMSuspendCallback)(virConnectPtr conn,
virDomainPtr dom,
int reason,
void *opaque);
typedef void (*virConnectDomainEventBalloonChangeCallback)(virConnectPtr conn,
virDomainPtr dom,
unsigned long long actual,
void *opaque);
typedef void (*virConnectDomainEventPMSuspendDiskCallback)(virConnectPtr conn,
virDomainPtr dom,
int reason,
void *opaque);
typedef void (*virConnectDomainEventDeviceRemovedCallback)(virConnectPtr conn,
virDomainPtr dom,
const char *devAlias,
void *opaque);
typedef void (*virConnectDomainEventDeviceAddedCallback)(virConnectPtr conn,
virDomainPtr dom,
const char *devAlias,
void *opaque);
typedef void (*virConnectDomainEventDeviceRemovalFailedCallback)(virConnectPtr conn,
virDomainPtr dom,
const char *devAlias,
void *opaque);
typedef void (*virConnectDomainEventMetadataChangeCallback)(virConnectPtr conn,
virDomainPtr dom,
int type,
const char *nsuri,
void *opaque);
typedef void (*virConnectDomainEventMigrationIterationCallback)(virConnectPtr conn,
virDomainPtr dom,
int iteration,
void *opaque);
typedef void (*virConnectDomainEventJobCompletedCallback)(virConnectPtr conn,
virDomainPtr dom,
virTypedParameterPtr params,
int nparams,
void *opaque);
typedef void (*virConnectDomainEventTunableCallback)(virConnectPtr conn,
virDomainPtr dom,
virTypedParameterPtr params,
int nparams,
void *opaque);
typedef enum {
VIR_CONNECT_DOMAIN_EVENT_AGENT_LIFECYCLE_STATE_CONNECTED = 1,
VIR_CONNECT_DOMAIN_EVENT_AGENT_LIFECYCLE_STATE_DISCONNECTED = 2,
} virConnectDomainEventAgentLifecycleState;
typedef enum {
VIR_CONNECT_DOMAIN_EVENT_AGENT_LIFECYCLE_REASON_UNKNOWN = 0,
VIR_CONNECT_DOMAIN_EVENT_AGENT_LIFECYCLE_REASON_DOMAIN_STARTED = 1,
VIR_CONNECT_DOMAIN_EVENT_AGENT_LIFECYCLE_REASON_CHANNEL = 2,
} virConnectDomainEventAgentLifecycleReason;
typedef void (*virConnectDomainEventAgentLifecycleCallback)(virConnectPtr conn,
virDomainPtr dom,
int state,
int reason,
void *opaque);
typedef void (*virConnectDomainEventBlockThresholdCallback)(virConnectPtr conn,
virDomainPtr dom,
const char *dev,
const char *path,
unsigned long long threshold,
unsigned long long excess,
void *opaque);
typedef enum {
VIR_DOMAIN_EVENT_ID_LIFECYCLE = 0,
VIR_DOMAIN_EVENT_ID_REBOOT = 1,
VIR_DOMAIN_EVENT_ID_RTC_CHANGE = 2,
VIR_DOMAIN_EVENT_ID_WATCHDOG = 3,
VIR_DOMAIN_EVENT_ID_IO_ERROR = 4,
VIR_DOMAIN_EVENT_ID_GRAPHICS = 5,
VIR_DOMAIN_EVENT_ID_IO_ERROR_REASON = 6,
VIR_DOMAIN_EVENT_ID_CONTROL_ERROR = 7,
VIR_DOMAIN_EVENT_ID_BLOCK_JOB = 8,
VIR_DOMAIN_EVENT_ID_DISK_CHANGE = 9,
VIR_DOMAIN_EVENT_ID_TRAY_CHANGE = 10,
VIR_DOMAIN_EVENT_ID_PMWAKEUP = 11,
VIR_DOMAIN_EVENT_ID_PMSUSPEND = 12,
VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE = 13,
VIR_DOMAIN_EVENT_ID_PMSUSPEND_DISK = 14,
VIR_DOMAIN_EVENT_ID_DEVICE_REMOVED = 15,
VIR_DOMAIN_EVENT_ID_BLOCK_JOB_2 = 16,
VIR_DOMAIN_EVENT_ID_TUNABLE = 17,
VIR_DOMAIN_EVENT_ID_AGENT_LIFECYCLE = 18,
VIR_DOMAIN_EVENT_ID_DEVICE_ADDED = 19,
VIR_DOMAIN_EVENT_ID_MIGRATION_ITERATION = 20,
VIR_DOMAIN_EVENT_ID_JOB_COMPLETED = 21,
VIR_DOMAIN_EVENT_ID_DEVICE_REMOVAL_FAILED = 22,
VIR_DOMAIN_EVENT_ID_METADATA_CHANGE = 23,
VIR_DOMAIN_EVENT_ID_BLOCK_THRESHOLD = 24,
} virDomainEventID;
int virConnectDomainEventRegisterAny(virConnectPtr conn,
virDomainPtr dom,
int eventID,
virConnectDomainEventGenericCallback cb,
void *opaque,
virFreeCallback freecb);
int virConnectDomainEventDeregisterAny(virConnectPtr conn,
int callbackID);
typedef enum {
VIR_DOMAIN_CONSOLE_FORCE = (1 << 0),
VIR_DOMAIN_CONSOLE_SAFE = (1 << 1),
} virDomainConsoleFlags;
int virDomainOpenConsole(virDomainPtr dom,
const char *dev_name,
virStreamPtr st,
unsigned int flags);
typedef enum {
VIR_DOMAIN_CHANNEL_FORCE = (1 << 0),
} 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);
typedef struct _virDomainFSInfo virDomainFSInfo;
typedef virDomainFSInfo *virDomainFSInfoPtr;
struct _virDomainFSInfo {
char *mountpoint;
char *name;
char *fstype;
size_t ndevAlias;
char **devAlias;
};
void virDomainFSInfoFree(virDomainFSInfoPtr info);
int virDomainGetFSInfo(virDomainPtr dom,
virDomainFSInfoPtr **info,
unsigned int flags);
int virDomainGetTime(virDomainPtr dom,
long long *seconds,
unsigned int *nseconds,
unsigned int flags);
typedef enum {
VIR_DOMAIN_TIME_SYNC = (1 << 0),
} virDomainSetTimeFlags;
int virDomainSetTime(virDomainPtr dom,
long long seconds,
unsigned int nseconds,
unsigned int flags);
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;
typedef struct _virTypedParameter virSchedParameter;
typedef virSchedParameter *virSchedParameterPtr;
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;
typedef struct _virTypedParameter virBlkioParameter;
typedef virBlkioParameter *virBlkioParameterPtr;
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;
typedef struct _virTypedParameter virMemoryParameter;
typedef virMemoryParameter *virMemoryParameterPtr;
typedef enum {
VIR_DOMAIN_INTERFACE_ADDRESSES_SRC_LEASE = 0,
VIR_DOMAIN_INTERFACE_ADDRESSES_SRC_AGENT = 1,
VIR_DOMAIN_INTERFACE_ADDRESSES_SRC_ARP = 2,
} virDomainInterfaceAddressesSource;
typedef struct _virDomainInterfaceIPAddress virDomainIPAddress;
typedef virDomainIPAddress *virDomainIPAddressPtr;
struct _virDomainInterfaceIPAddress {
int type;
char *addr;
unsigned int prefix;
};
typedef struct _virDomainInterface virDomainInterface;
typedef virDomainInterface *virDomainInterfacePtr;
struct _virDomainInterface {
char *name;
char *hwaddr;
unsigned int naddrs;
virDomainIPAddressPtr addrs;
};
int virDomainInterfaceAddresses(virDomainPtr dom,
virDomainInterfacePtr **ifaces,
unsigned int source,
unsigned int flags);
void virDomainInterfaceFree(virDomainInterfacePtr iface);
typedef enum {
VIR_DOMAIN_PASSWORD_ENCRYPTED = 1 << 0,
} virDomainSetUserPasswordFlags;
int virDomainSetUserPassword(virDomainPtr dom,
const char *user,
const char *password,
unsigned int flags);
int virDomainRename(virDomainPtr dom,
const char *new_name,
unsigned int flags);
int virDomainGetGuestVcpus(virDomainPtr domain,
virTypedParameterPtr *params,
unsigned int *nparams,
unsigned int flags);
int virDomainSetGuestVcpus(virDomainPtr domain,
const char *cpumap,
int state,
unsigned int flags);
int virDomainSetVcpu(virDomainPtr domain,
const char *vcpumap,
int state,
unsigned int flags);
int virDomainSetBlockThreshold(virDomainPtr domain,
const char *dev,
unsigned long long threshold,
unsigned int flags);
typedef enum {
VIR_DOMAIN_LIFECYCLE_POWEROFF = 0,
VIR_DOMAIN_LIFECYCLE_REBOOT = 1,
VIR_DOMAIN_LIFECYCLE_CRASH = 2,
} virDomainLifecycle;
typedef enum {
VIR_DOMAIN_LIFECYCLE_ACTION_DESTROY = 0,
VIR_DOMAIN_LIFECYCLE_ACTION_RESTART = 1,
VIR_DOMAIN_LIFECYCLE_ACTION_RESTART_RENAME = 2,
VIR_DOMAIN_LIFECYCLE_ACTION_PRESERVE = 3,
VIR_DOMAIN_LIFECYCLE_ACTION_COREDUMP_DESTROY = 4,
VIR_DOMAIN_LIFECYCLE_ACTION_COREDUMP_RESTART = 5,
} virDomainLifecycleAction;
int virDomainSetLifecycleAction(virDomainPtr domain,
unsigned int type,
unsigned int action,
unsigned int flags);
typedef struct _virDomainSnapshot virDomainSnapshot;
typedef virDomainSnapshot *virDomainSnapshotPtr;
const char *virDomainSnapshotGetName(virDomainSnapshotPtr snapshot);
virDomainPtr virDomainSnapshotGetDomain(virDomainSnapshotPtr snapshot);
virConnectPtr virDomainSnapshotGetConnect(virDomainSnapshotPtr snapshot);
typedef enum {
VIR_DOMAIN_SNAPSHOT_CREATE_REDEFINE = (1 << 0),
VIR_DOMAIN_SNAPSHOT_CREATE_CURRENT = (1 << 1),
VIR_DOMAIN_SNAPSHOT_CREATE_NO_METADATA = (1 << 2),
VIR_DOMAIN_SNAPSHOT_CREATE_HALT = (1 << 3),
VIR_DOMAIN_SNAPSHOT_CREATE_DISK_ONLY = (1 << 4),
VIR_DOMAIN_SNAPSHOT_CREATE_REUSE_EXT = (1 << 5),
VIR_DOMAIN_SNAPSHOT_CREATE_QUIESCE = (1 << 6),
VIR_DOMAIN_SNAPSHOT_CREATE_ATOMIC = (1 << 7),
VIR_DOMAIN_SNAPSHOT_CREATE_LIVE = (1 << 8),
} virDomainSnapshotCreateFlags;
virDomainSnapshotPtr virDomainSnapshotCreateXML(virDomainPtr domain,
const char *xmlDesc,
unsigned int flags);
char *virDomainSnapshotGetXMLDesc(virDomainSnapshotPtr snapshot,
unsigned int flags);
typedef enum {
VIR_DOMAIN_SNAPSHOT_LIST_ROOTS = (1 << 0),
VIR_DOMAIN_SNAPSHOT_LIST_DESCENDANTS = (1 << 0),
VIR_DOMAIN_SNAPSHOT_LIST_LEAVES = (1 << 2),
VIR_DOMAIN_SNAPSHOT_LIST_NO_LEAVES = (1 << 3),
VIR_DOMAIN_SNAPSHOT_LIST_METADATA = (1 << 1),
VIR_DOMAIN_SNAPSHOT_LIST_NO_METADATA = (1 << 4),
VIR_DOMAIN_SNAPSHOT_LIST_INACTIVE = (1 << 5),
VIR_DOMAIN_SNAPSHOT_LIST_ACTIVE = (1 << 6),
VIR_DOMAIN_SNAPSHOT_LIST_DISK_ONLY = (1 << 7),
VIR_DOMAIN_SNAPSHOT_LIST_INTERNAL = (1 << 8),
VIR_DOMAIN_SNAPSHOT_LIST_EXTERNAL = (1 << 9),
} virDomainSnapshotListFlags;
int virDomainSnapshotNum(virDomainPtr domain, unsigned int flags);
int virDomainSnapshotListNames(virDomainPtr domain, char **names, int nameslen,
unsigned int flags);
int virDomainListAllSnapshots(virDomainPtr domain,
virDomainSnapshotPtr **snaps,
unsigned int flags);
int virDomainSnapshotNumChildren(virDomainSnapshotPtr snapshot,
unsigned int flags);
int virDomainSnapshotListChildrenNames(virDomainSnapshotPtr snapshot,
char **names, int nameslen,
unsigned int flags);
int virDomainSnapshotListAllChildren(virDomainSnapshotPtr snapshot,
virDomainSnapshotPtr **snaps,
unsigned int flags);
virDomainSnapshotPtr virDomainSnapshotLookupByName(virDomainPtr domain,
const char *name,
unsigned int flags);
int virDomainHasCurrentSnapshot(virDomainPtr domain, unsigned int flags);
virDomainSnapshotPtr virDomainSnapshotCurrent(virDomainPtr domain,
unsigned int flags);
virDomainSnapshotPtr virDomainSnapshotGetParent(virDomainSnapshotPtr snapshot,
unsigned int flags);
int virDomainSnapshotIsCurrent(virDomainSnapshotPtr snapshot,
unsigned int flags);
int virDomainSnapshotHasMetadata(virDomainSnapshotPtr snapshot,
unsigned int flags);
typedef enum {
VIR_DOMAIN_SNAPSHOT_REVERT_RUNNING = 1 << 0,
VIR_DOMAIN_SNAPSHOT_REVERT_PAUSED = 1 << 1,
VIR_DOMAIN_SNAPSHOT_REVERT_FORCE = 1 << 2,
} virDomainSnapshotRevertFlags;
int virDomainRevertToSnapshot(virDomainSnapshotPtr snapshot,
unsigned int flags);
typedef enum {
VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN = (1 << 0),
VIR_DOMAIN_SNAPSHOT_DELETE_METADATA_ONLY = (1 << 1),
VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN_ONLY = (1 << 2),
} virDomainSnapshotDeleteFlags;
int virDomainSnapshotDelete(virDomainSnapshotPtr snapshot,
unsigned int flags);
int virDomainSnapshotRef(virDomainSnapshotPtr snapshot);
int virDomainSnapshotFree(virDomainSnapshotPtr snapshot);
typedef enum {
VIR_EVENT_HANDLE_READABLE = (1 << 0),
VIR_EVENT_HANDLE_WRITABLE = (1 << 1),
VIR_EVENT_HANDLE_ERROR = (1 << 2),
VIR_EVENT_HANDLE_HANGUP = (1 << 3),
} virEventHandleType;
typedef void (*virEventHandleCallback)(int watch, int fd, int events, void *opaque);
typedef int (*virEventAddHandleFunc)(int fd, int event,
virEventHandleCallback cb,
void *opaque,
virFreeCallback ff);
typedef void (*virEventUpdateHandleFunc)(int watch, int event);
typedef int (*virEventRemoveHandleFunc)(int watch);
typedef void (*virEventTimeoutCallback)(int timer, void *opaque);
typedef int (*virEventAddTimeoutFunc)(int timeout,
virEventTimeoutCallback cb,
void *opaque,
virFreeCallback ff);
typedef void (*virEventUpdateTimeoutFunc)(int timer, int timeout);
typedef int (*virEventRemoveTimeoutFunc)(int timer);
void virEventRegisterImpl(virEventAddHandleFunc addHandle,
virEventUpdateHandleFunc updateHandle,
virEventRemoveHandleFunc removeHandle,
virEventAddTimeoutFunc addTimeout,
virEventUpdateTimeoutFunc updateTimeout,
virEventRemoveTimeoutFunc removeTimeout);
int virEventRegisterDefaultImpl(void);
int virEventRunDefaultImpl(void);
int virEventAddHandle(int fd, int events,
virEventHandleCallback cb,
void *opaque,
virFreeCallback ff);
void virEventUpdateHandle(int watch, int events);
int virEventRemoveHandle(int watch);
int virEventAddTimeout(int frequency,
virEventTimeoutCallback cb,
void *opaque,
virFreeCallback ff);
void virEventUpdateTimeout(int timer, int frequency);
int virEventRemoveTimeout(int timer);
typedef struct _virInterface virInterface;
typedef virInterface *virInterfacePtr;
virConnectPtr virInterfaceGetConnect (virInterfacePtr iface);
int virConnectNumOfInterfaces (virConnectPtr conn);
int virConnectListInterfaces (virConnectPtr conn,
char **const names,
int maxnames);
int virConnectNumOfDefinedInterfaces (virConnectPtr conn);
int virConnectListDefinedInterfaces (virConnectPtr conn,
char **const names,
int maxnames);
typedef enum {
VIR_CONNECT_LIST_INTERFACES_INACTIVE = 1 << 0,
VIR_CONNECT_LIST_INTERFACES_ACTIVE = 1 << 1,
} virConnectListAllInterfacesFlags;
int virConnectListAllInterfaces (virConnectPtr conn,
virInterfacePtr **ifaces,
unsigned int flags);
virInterfacePtr virInterfaceLookupByName (virConnectPtr conn,
const char *name);
virInterfacePtr virInterfaceLookupByMACString (virConnectPtr conn,
const char *mac);
const char* virInterfaceGetName (virInterfacePtr iface);
const char* virInterfaceGetMACString (virInterfacePtr iface);
typedef enum {
VIR_INTERFACE_XML_INACTIVE = 1 << 0
} virInterfaceXMLFlags;
char * virInterfaceGetXMLDesc (virInterfacePtr iface,
unsigned int flags);
virInterfacePtr virInterfaceDefineXML (virConnectPtr conn,
const char *xmlDesc,
unsigned int flags);
int virInterfaceUndefine (virInterfacePtr iface);
int virInterfaceCreate (virInterfacePtr iface,
unsigned int flags);
int virInterfaceDestroy (virInterfacePtr iface,
unsigned int flags);
int virInterfaceRef (virInterfacePtr iface);
int virInterfaceFree (virInterfacePtr iface);
int virInterfaceChangeBegin (virConnectPtr conn,
unsigned int flags);
int virInterfaceChangeCommit (virConnectPtr conn,
unsigned int flags);
int virInterfaceChangeRollback(virConnectPtr conn,
unsigned int flags);
int virInterfaceIsActive(virInterfacePtr iface);
typedef enum {
VIR_NETWORK_XML_INACTIVE = (1 << 0),
} virNetworkXMLFlags;
typedef struct _virNetwork virNetwork;
typedef virNetwork *virNetworkPtr;
virConnectPtr virNetworkGetConnect (virNetworkPtr network);
int virConnectNumOfNetworks (virConnectPtr conn);
int virConnectListNetworks (virConnectPtr conn,
char **const names,
int maxnames);
int virConnectNumOfDefinedNetworks (virConnectPtr conn);
int virConnectListDefinedNetworks (virConnectPtr conn,
char **const names,
int maxnames);
typedef enum {
VIR_CONNECT_LIST_NETWORKS_INACTIVE = 1 << 0,
VIR_CONNECT_LIST_NETWORKS_ACTIVE = 1 << 1,
VIR_CONNECT_LIST_NETWORKS_PERSISTENT = 1 << 2,
VIR_CONNECT_LIST_NETWORKS_TRANSIENT = 1 << 3,
VIR_CONNECT_LIST_NETWORKS_AUTOSTART = 1 << 4,
VIR_CONNECT_LIST_NETWORKS_NO_AUTOSTART = 1 << 5,
} virConnectListAllNetworksFlags;
int virConnectListAllNetworks (virConnectPtr conn,
virNetworkPtr **nets,
unsigned int flags);
virNetworkPtr virNetworkLookupByName (virConnectPtr conn,
const char *name);
virNetworkPtr virNetworkLookupByUUID (virConnectPtr conn,
const unsigned char *uuid);
virNetworkPtr virNetworkLookupByUUIDString (virConnectPtr conn,
const char *uuid);
virNetworkPtr virNetworkCreateXML (virConnectPtr conn,
const char *xmlDesc);
virNetworkPtr virNetworkDefineXML (virConnectPtr conn,
const char *xmlDesc);
int virNetworkUndefine (virNetworkPtr network);
typedef enum {
VIR_NETWORK_UPDATE_COMMAND_NONE = 0,
VIR_NETWORK_UPDATE_COMMAND_MODIFY = 1,
VIR_NETWORK_UPDATE_COMMAND_DELETE = 2,
VIR_NETWORK_UPDATE_COMMAND_ADD_LAST = 3,
VIR_NETWORK_UPDATE_COMMAND_ADD_FIRST = 4,
} virNetworkUpdateCommand;
typedef enum {
VIR_NETWORK_SECTION_NONE = 0,
VIR_NETWORK_SECTION_BRIDGE = 1,
VIR_NETWORK_SECTION_DOMAIN = 2,
VIR_NETWORK_SECTION_IP = 3,
VIR_NETWORK_SECTION_IP_DHCP_HOST = 4,
VIR_NETWORK_SECTION_IP_DHCP_RANGE = 5,
VIR_NETWORK_SECTION_FORWARD = 6,
VIR_NETWORK_SECTION_FORWARD_INTERFACE = 7,
VIR_NETWORK_SECTION_FORWARD_PF = 8,
VIR_NETWORK_SECTION_PORTGROUP = 9,
VIR_NETWORK_SECTION_DNS_HOST = 10,
VIR_NETWORK_SECTION_DNS_TXT = 11,
VIR_NETWORK_SECTION_DNS_SRV = 12,
} virNetworkUpdateSection;
typedef enum {
VIR_NETWORK_UPDATE_AFFECT_CURRENT = 0,
VIR_NETWORK_UPDATE_AFFECT_LIVE = 1 << 0,
VIR_NETWORK_UPDATE_AFFECT_CONFIG = 1 << 1,
} virNetworkUpdateFlags;
int virNetworkUpdate(virNetworkPtr network,
unsigned int command,
unsigned int section,
int parentIndex,
const char *xml,
unsigned int flags);
int virNetworkCreate (virNetworkPtr network);
int virNetworkDestroy (virNetworkPtr network);
int virNetworkRef (virNetworkPtr network);
int virNetworkFree (virNetworkPtr network);
const char* virNetworkGetName (virNetworkPtr network);
int virNetworkGetUUID (virNetworkPtr network,
unsigned char *uuid);
int virNetworkGetUUIDString (virNetworkPtr network,
char *buf);
char * virNetworkGetXMLDesc (virNetworkPtr network,
unsigned int flags);
char * virNetworkGetBridgeName (virNetworkPtr network);
int virNetworkGetAutostart (virNetworkPtr network,
int *autostart);
int virNetworkSetAutostart (virNetworkPtr network,
int autostart);
int virNetworkIsActive(virNetworkPtr net);
int virNetworkIsPersistent(virNetworkPtr net);
typedef enum {
VIR_NETWORK_EVENT_DEFINED = 0,
VIR_NETWORK_EVENT_UNDEFINED = 1,
VIR_NETWORK_EVENT_STARTED = 2,
VIR_NETWORK_EVENT_STOPPED = 3,
} virNetworkEventLifecycleType;
typedef void (*virConnectNetworkEventLifecycleCallback)(virConnectPtr conn,
virNetworkPtr net,
int event,
int detail,
void *opaque);
typedef enum {
VIR_NETWORK_EVENT_ID_LIFECYCLE = 0,
} virNetworkEventID;
typedef enum {
VIR_IP_ADDR_TYPE_IPV4,
VIR_IP_ADDR_TYPE_IPV6,
} virIPAddrType;
typedef struct _virNetworkDHCPLease virNetworkDHCPLease;
typedef virNetworkDHCPLease *virNetworkDHCPLeasePtr;
struct _virNetworkDHCPLease {
char *iface;
long long expirytime;
int type;
char *mac;
char *iaid;
char *ipaddr;
unsigned int prefix;
char *hostname;
char *clientid;
};
void virNetworkDHCPLeaseFree(virNetworkDHCPLeasePtr lease);
int virNetworkGetDHCPLeases(virNetworkPtr network,
const char *mac,
virNetworkDHCPLeasePtr **leases,
unsigned int flags);
typedef void (*virConnectNetworkEventGenericCallback)(virConnectPtr conn,
virNetworkPtr net,
void *opaque);
int virConnectNetworkEventRegisterAny(virConnectPtr conn,
virNetworkPtr net,
int eventID,
virConnectNetworkEventGenericCallback cb,
void *opaque,
virFreeCallback freecb);
int virConnectNetworkEventDeregisterAny(virConnectPtr conn,
int callbackID);
typedef struct _virNodeDevice virNodeDevice;
typedef virNodeDevice *virNodeDevicePtr;
int virNodeNumOfDevices (virConnectPtr conn,
const char *cap,
unsigned int flags);
int virNodeListDevices (virConnectPtr conn,
const char *cap,
char **const names,
int maxnames,
unsigned int flags);
typedef enum {
VIR_CONNECT_LIST_NODE_DEVICES_CAP_SYSTEM = 1 << 0,
VIR_CONNECT_LIST_NODE_DEVICES_CAP_PCI_DEV = 1 << 1,
VIR_CONNECT_LIST_NODE_DEVICES_CAP_USB_DEV = 1 << 2,
VIR_CONNECT_LIST_NODE_DEVICES_CAP_USB_INTERFACE = 1 << 3,
VIR_CONNECT_LIST_NODE_DEVICES_CAP_NET = 1 << 4,
VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI_HOST = 1 << 5,
VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI_TARGET = 1 << 6,
VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI = 1 << 7,
VIR_CONNECT_LIST_NODE_DEVICES_CAP_STORAGE = 1 << 8,
VIR_CONNECT_LIST_NODE_DEVICES_CAP_FC_HOST = 1 << 9,
VIR_CONNECT_LIST_NODE_DEVICES_CAP_VPORTS = 1 << 10,
VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI_GENERIC = 1 << 11,
VIR_CONNECT_LIST_NODE_DEVICES_CAP_DRM = 1 << 12,
VIR_CONNECT_LIST_NODE_DEVICES_CAP_MDEV_TYPES = 1 << 13,
VIR_CONNECT_LIST_NODE_DEVICES_CAP_MDEV = 1 << 14,
VIR_CONNECT_LIST_NODE_DEVICES_CAP_CCW_DEV = 1 << 15,
} virConnectListAllNodeDeviceFlags;
int virConnectListAllNodeDevices (virConnectPtr conn,
virNodeDevicePtr **devices,
unsigned int flags);
virNodeDevicePtr virNodeDeviceLookupByName (virConnectPtr conn,
const char *name);
virNodeDevicePtr virNodeDeviceLookupSCSIHostByWWN (virConnectPtr conn,
const char *wwnn,
const char *wwpn,
unsigned int flags);
const char * virNodeDeviceGetName (virNodeDevicePtr dev);
const char * virNodeDeviceGetParent (virNodeDevicePtr dev);
int virNodeDeviceNumOfCaps (virNodeDevicePtr dev);
int virNodeDeviceListCaps (virNodeDevicePtr dev,
char **const names,
int maxnames);
char * virNodeDeviceGetXMLDesc (virNodeDevicePtr dev,
unsigned int flags);
int virNodeDeviceRef (virNodeDevicePtr dev);
int virNodeDeviceFree (virNodeDevicePtr dev);
int virNodeDeviceDettach (virNodeDevicePtr dev);
int virNodeDeviceDetachFlags(virNodeDevicePtr dev,
const char *driverName,
unsigned int flags);
int virNodeDeviceReAttach (virNodeDevicePtr dev);
int virNodeDeviceReset (virNodeDevicePtr dev);
virNodeDevicePtr virNodeDeviceCreateXML (virConnectPtr conn,
const char *xmlDesc,
unsigned int flags);
int virNodeDeviceDestroy (virNodeDevicePtr dev);
typedef enum {
VIR_NODE_DEVICE_EVENT_ID_LIFECYCLE = 0,
VIR_NODE_DEVICE_EVENT_ID_UPDATE = 1,
} virNodeDeviceEventID;
typedef void (*virConnectNodeDeviceEventGenericCallback)(virConnectPtr conn,
virNodeDevicePtr dev,
void *opaque);
int virConnectNodeDeviceEventRegisterAny(virConnectPtr conn,
virNodeDevicePtr dev,
int eventID,
virConnectNodeDeviceEventGenericCallback cb,
void *opaque,
virFreeCallback freecb);
int virConnectNodeDeviceEventDeregisterAny(virConnectPtr conn,
int callbackID);
typedef enum {
VIR_NODE_DEVICE_EVENT_CREATED = 0,
VIR_NODE_DEVICE_EVENT_DELETED = 1,
} virNodeDeviceEventLifecycleType;
typedef void (*virConnectNodeDeviceEventLifecycleCallback)(virConnectPtr conn,
virNodeDevicePtr dev,
int event,
int detail,
void *opaque);
typedef struct _virNWFilter virNWFilter;
typedef virNWFilter *virNWFilterPtr;
int virConnectNumOfNWFilters (virConnectPtr conn);
int virConnectListNWFilters (virConnectPtr conn,
char **const names,
int maxnames);
int virConnectListAllNWFilters(virConnectPtr conn,
virNWFilterPtr **filters,
unsigned int flags);
virNWFilterPtr virNWFilterLookupByName (virConnectPtr conn,
const char *name);
virNWFilterPtr virNWFilterLookupByUUID (virConnectPtr conn,
const unsigned char *uuid);
virNWFilterPtr virNWFilterLookupByUUIDString (virConnectPtr conn,
const char *uuid);
virNWFilterPtr virNWFilterDefineXML (virConnectPtr conn,
const char *xmlDesc);
int virNWFilterUndefine (virNWFilterPtr nwfilter);
int virNWFilterRef (virNWFilterPtr nwfilter);
int virNWFilterFree (virNWFilterPtr nwfilter);
const char* virNWFilterGetName (virNWFilterPtr nwfilter);
int virNWFilterGetUUID (virNWFilterPtr nwfilter,
unsigned char *uuid);
int virNWFilterGetUUIDString (virNWFilterPtr nwfilter,
char *buf);
char * virNWFilterGetXMLDesc (virNWFilterPtr nwfilter,
unsigned int flags);
typedef struct _virSecret virSecret;
typedef virSecret *virSecretPtr;
typedef enum {
VIR_SECRET_USAGE_TYPE_NONE = 0,
VIR_SECRET_USAGE_TYPE_VOLUME = 1,
VIR_SECRET_USAGE_TYPE_CEPH = 2,
VIR_SECRET_USAGE_TYPE_ISCSI = 3,
VIR_SECRET_USAGE_TYPE_TLS = 4,
} virSecretUsageType;
virConnectPtr virSecretGetConnect (virSecretPtr secret);
int virConnectNumOfSecrets (virConnectPtr conn);
int virConnectListSecrets (virConnectPtr conn,
char **uuids,
int maxuuids);
typedef enum {
VIR_CONNECT_LIST_SECRETS_EPHEMERAL = 1 << 0,
VIR_CONNECT_LIST_SECRETS_NO_EPHEMERAL = 1 << 1,
VIR_CONNECT_LIST_SECRETS_PRIVATE = 1 << 2,
VIR_CONNECT_LIST_SECRETS_NO_PRIVATE = 1 << 3,
} virConnectListAllSecretsFlags;
int virConnectListAllSecrets(virConnectPtr conn,
virSecretPtr **secrets,
unsigned int flags);
virSecretPtr virSecretLookupByUUID(virConnectPtr conn,
const unsigned char *uuid);
virSecretPtr virSecretLookupByUUIDString(virConnectPtr conn,
const char *uuid);
virSecretPtr virSecretLookupByUsage(virConnectPtr conn,
int usageType,
const char *usageID);
virSecretPtr virSecretDefineXML (virConnectPtr conn,
const char *xml,
unsigned int flags);
int virSecretGetUUID (virSecretPtr secret,
unsigned char *buf);
int virSecretGetUUIDString (virSecretPtr secret,
char *buf);
int virSecretGetUsageType (virSecretPtr secret);
const char * virSecretGetUsageID (virSecretPtr secret);
char * virSecretGetXMLDesc (virSecretPtr secret,
unsigned int flags);
int virSecretSetValue (virSecretPtr secret,
const unsigned char *value,
size_t value_size,
unsigned int flags);
unsigned char * virSecretGetValue (virSecretPtr secret,
size_t *value_size,
unsigned int flags);
int virSecretUndefine (virSecretPtr secret);
int virSecretRef (virSecretPtr secret);
int virSecretFree (virSecretPtr secret);
typedef enum {
VIR_SECRET_EVENT_ID_LIFECYCLE = 0,
VIR_SECRET_EVENT_ID_VALUE_CHANGED = 1,
} virSecretEventID;
typedef void (*virConnectSecretEventGenericCallback)(virConnectPtr conn,
virSecretPtr secret,
void *opaque);
int virConnectSecretEventRegisterAny(virConnectPtr conn,
virSecretPtr secret,
int eventID,
virConnectSecretEventGenericCallback cb,
void *opaque,
virFreeCallback freecb);
int virConnectSecretEventDeregisterAny(virConnectPtr conn,
int callbackID);
typedef enum {
VIR_SECRET_EVENT_DEFINED = 0,
VIR_SECRET_EVENT_UNDEFINED = 1,
} virSecretEventLifecycleType;
typedef void (*virConnectSecretEventLifecycleCallback)(virConnectPtr conn,
virSecretPtr secret,
int event,
int detail,
void *opaque);
typedef struct _virStoragePool virStoragePool;
typedef virStoragePool *virStoragePoolPtr;
typedef enum {
VIR_STORAGE_POOL_INACTIVE = 0,
VIR_STORAGE_POOL_BUILDING = 1,
VIR_STORAGE_POOL_RUNNING = 2,
VIR_STORAGE_POOL_DEGRADED = 3,
VIR_STORAGE_POOL_INACCESSIBLE = 4,
} virStoragePoolState;
typedef enum {
VIR_STORAGE_POOL_BUILD_NEW = 0,
VIR_STORAGE_POOL_BUILD_REPAIR = (1 << 0),
VIR_STORAGE_POOL_BUILD_RESIZE = (1 << 1),
VIR_STORAGE_POOL_BUILD_NO_OVERWRITE = (1 << 2),
VIR_STORAGE_POOL_BUILD_OVERWRITE = (1 << 3),
} virStoragePoolBuildFlags;
typedef enum {
VIR_STORAGE_POOL_DELETE_NORMAL = 0,
VIR_STORAGE_POOL_DELETE_ZEROED = 1 << 0,
} virStoragePoolDeleteFlags;
typedef enum {
VIR_STORAGE_POOL_CREATE_NORMAL = 0,
VIR_STORAGE_POOL_CREATE_WITH_BUILD = 1 << 0,
VIR_STORAGE_POOL_CREATE_WITH_BUILD_OVERWRITE = 1 << 1,
VIR_STORAGE_POOL_CREATE_WITH_BUILD_NO_OVERWRITE = 1 << 2,
} virStoragePoolCreateFlags;
typedef struct _virStoragePoolInfo virStoragePoolInfo;
struct _virStoragePoolInfo {
int state;
unsigned long long capacity;
unsigned long long allocation;
unsigned long long available;
};
typedef virStoragePoolInfo *virStoragePoolInfoPtr;
typedef struct _virStorageVol virStorageVol;
typedef virStorageVol *virStorageVolPtr;
typedef enum {
VIR_STORAGE_VOL_FILE = 0,
VIR_STORAGE_VOL_BLOCK = 1,
VIR_STORAGE_VOL_DIR = 2,
VIR_STORAGE_VOL_NETWORK = 3,
VIR_STORAGE_VOL_NETDIR = 4,
VIR_STORAGE_VOL_PLOOP = 5,
} virStorageVolType;
typedef enum {
VIR_STORAGE_VOL_DELETE_NORMAL = 0,
VIR_STORAGE_VOL_DELETE_ZEROED = 1 << 0,
VIR_STORAGE_VOL_DELETE_WITH_SNAPSHOTS = 1 << 1,
} virStorageVolDeleteFlags;
typedef enum {
VIR_STORAGE_VOL_WIPE_ALG_ZERO = 0,
VIR_STORAGE_VOL_WIPE_ALG_NNSA = 1,
VIR_STORAGE_VOL_WIPE_ALG_DOD = 2,
VIR_STORAGE_VOL_WIPE_ALG_BSI = 3,
VIR_STORAGE_VOL_WIPE_ALG_GUTMANN = 4,
VIR_STORAGE_VOL_WIPE_ALG_SCHNEIER = 5,
VIR_STORAGE_VOL_WIPE_ALG_PFITZNER7 = 6,
VIR_STORAGE_VOL_WIPE_ALG_PFITZNER33 = 7,
VIR_STORAGE_VOL_WIPE_ALG_RANDOM = 8,
VIR_STORAGE_VOL_WIPE_ALG_TRIM = 9,
} virStorageVolWipeAlgorithm;
typedef enum {
VIR_STORAGE_VOL_USE_ALLOCATION = 0,
VIR_STORAGE_VOL_GET_PHYSICAL = 1 << 0,
} virStorageVolInfoFlags;
typedef struct _virStorageVolInfo virStorageVolInfo;
struct _virStorageVolInfo {
int type;
unsigned long long capacity;
unsigned long long allocation;
};
typedef virStorageVolInfo *virStorageVolInfoPtr;
typedef enum {
VIR_STORAGE_XML_INACTIVE = (1 << 0),
} virStorageXMLFlags;
virConnectPtr virStoragePoolGetConnect (virStoragePoolPtr pool);
int virConnectNumOfStoragePools (virConnectPtr conn);
int virConnectListStoragePools (virConnectPtr conn,
char **const names,
int maxnames);
int virConnectNumOfDefinedStoragePools(virConnectPtr conn);
int virConnectListDefinedStoragePools(virConnectPtr conn,
char **const names,
int maxnames);
typedef enum {
VIR_CONNECT_LIST_STORAGE_POOLS_INACTIVE = 1 << 0,
VIR_CONNECT_LIST_STORAGE_POOLS_ACTIVE = 1 << 1,
VIR_CONNECT_LIST_STORAGE_POOLS_PERSISTENT = 1 << 2,
VIR_CONNECT_LIST_STORAGE_POOLS_TRANSIENT = 1 << 3,
VIR_CONNECT_LIST_STORAGE_POOLS_AUTOSTART = 1 << 4,
VIR_CONNECT_LIST_STORAGE_POOLS_NO_AUTOSTART = 1 << 5,
VIR_CONNECT_LIST_STORAGE_POOLS_DIR = 1 << 6,
VIR_CONNECT_LIST_STORAGE_POOLS_FS = 1 << 7,
VIR_CONNECT_LIST_STORAGE_POOLS_NETFS = 1 << 8,
VIR_CONNECT_LIST_STORAGE_POOLS_LOGICAL = 1 << 9,
VIR_CONNECT_LIST_STORAGE_POOLS_DISK = 1 << 10,
VIR_CONNECT_LIST_STORAGE_POOLS_ISCSI = 1 << 11,
VIR_CONNECT_LIST_STORAGE_POOLS_SCSI = 1 << 12,
VIR_CONNECT_LIST_STORAGE_POOLS_MPATH = 1 << 13,
VIR_CONNECT_LIST_STORAGE_POOLS_RBD = 1 << 14,
VIR_CONNECT_LIST_STORAGE_POOLS_SHEEPDOG = 1 << 15,
VIR_CONNECT_LIST_STORAGE_POOLS_GLUSTER = 1 << 16,
VIR_CONNECT_LIST_STORAGE_POOLS_ZFS = 1 << 17,
VIR_CONNECT_LIST_STORAGE_POOLS_VSTORAGE = 1 << 18,
} virConnectListAllStoragePoolsFlags;
int virConnectListAllStoragePools(virConnectPtr conn,
virStoragePoolPtr **pools,
unsigned int flags);
char * virConnectFindStoragePoolSources(virConnectPtr conn,
const char *type,
const char *srcSpec,
unsigned int flags);
virStoragePoolPtr virStoragePoolLookupByName (virConnectPtr conn,
const char *name);
virStoragePoolPtr virStoragePoolLookupByUUID (virConnectPtr conn,
const unsigned char *uuid);
virStoragePoolPtr virStoragePoolLookupByUUIDString(virConnectPtr conn,
const char *uuid);
virStoragePoolPtr virStoragePoolLookupByVolume (virStorageVolPtr vol);
virStoragePoolPtr virStoragePoolLookupByTargetPath(virConnectPtr conn,
const char *path);
virStoragePoolPtr virStoragePoolCreateXML (virConnectPtr conn,
const char *xmlDesc,
unsigned int flags);
virStoragePoolPtr virStoragePoolDefineXML (virConnectPtr conn,
const char *xmlDesc,
unsigned int flags);
int virStoragePoolBuild (virStoragePoolPtr pool,
unsigned int flags);
int virStoragePoolUndefine (virStoragePoolPtr pool);
int virStoragePoolCreate (virStoragePoolPtr pool,
unsigned int flags);
int virStoragePoolDestroy (virStoragePoolPtr pool);
int virStoragePoolDelete (virStoragePoolPtr pool,
unsigned int flags);
int virStoragePoolRef (virStoragePoolPtr pool);
int virStoragePoolFree (virStoragePoolPtr pool);
int virStoragePoolRefresh (virStoragePoolPtr pool,
unsigned int flags);
const char* virStoragePoolGetName (virStoragePoolPtr pool);
int virStoragePoolGetUUID (virStoragePoolPtr pool,
unsigned char *uuid);
int virStoragePoolGetUUIDString (virStoragePoolPtr pool,
char *buf);
int virStoragePoolGetInfo (virStoragePoolPtr vol,
virStoragePoolInfoPtr info);
char * virStoragePoolGetXMLDesc (virStoragePoolPtr pool,
unsigned int flags);
int virStoragePoolGetAutostart (virStoragePoolPtr pool,
int *autostart);
int virStoragePoolSetAutostart (virStoragePoolPtr pool,
int autostart);
int virStoragePoolNumOfVolumes (virStoragePoolPtr pool);
int virStoragePoolListVolumes (virStoragePoolPtr pool,
char **const names,
int maxnames);
int virStoragePoolListAllVolumes (virStoragePoolPtr pool,
virStorageVolPtr **vols,
unsigned int flags);
virConnectPtr virStorageVolGetConnect (virStorageVolPtr vol);
virStorageVolPtr virStorageVolLookupByName (virStoragePoolPtr pool,
const char *name);
virStorageVolPtr virStorageVolLookupByKey (virConnectPtr conn,
const char *key);
virStorageVolPtr virStorageVolLookupByPath (virConnectPtr conn,
const char *path);
const char* virStorageVolGetName (virStorageVolPtr vol);
const char* virStorageVolGetKey (virStorageVolPtr vol);
typedef enum {
VIR_STORAGE_VOL_CREATE_PREALLOC_METADATA = 1 << 0,
VIR_STORAGE_VOL_CREATE_REFLINK = 1 << 1,
} virStorageVolCreateFlags;
virStorageVolPtr virStorageVolCreateXML (virStoragePoolPtr pool,
const char *xmldesc,
unsigned int flags);
virStorageVolPtr virStorageVolCreateXMLFrom (virStoragePoolPtr pool,
const char *xmldesc,
virStorageVolPtr clonevol,
unsigned int flags);
typedef enum {
VIR_STORAGE_VOL_DOWNLOAD_SPARSE_STREAM = 1 << 0,
} virStorageVolDownloadFlags;
int virStorageVolDownload (virStorageVolPtr vol,
virStreamPtr stream,
unsigned long long offset,
unsigned long long length,
unsigned int flags);
typedef enum {
VIR_STORAGE_VOL_UPLOAD_SPARSE_STREAM = 1 << 0,
} virStorageVolUploadFlags;
int virStorageVolUpload (virStorageVolPtr vol,
virStreamPtr stream,
unsigned long long offset,
unsigned long long length,
unsigned int flags);
int virStorageVolDelete (virStorageVolPtr vol,
unsigned int flags);
int virStorageVolWipe (virStorageVolPtr vol,
unsigned int flags);
int virStorageVolWipePattern (virStorageVolPtr vol,
unsigned int algorithm,
unsigned int flags);
int virStorageVolRef (virStorageVolPtr vol);
int virStorageVolFree (virStorageVolPtr vol);
int virStorageVolGetInfo (virStorageVolPtr vol,
virStorageVolInfoPtr info);
int virStorageVolGetInfoFlags (virStorageVolPtr vol,
virStorageVolInfoPtr info,
unsigned int flags);
char * virStorageVolGetXMLDesc (virStorageVolPtr pool,
unsigned int flags);
char * virStorageVolGetPath (virStorageVolPtr vol);
typedef enum {
VIR_STORAGE_VOL_RESIZE_ALLOCATE = 1 << 0,
VIR_STORAGE_VOL_RESIZE_DELTA = 1 << 1,
VIR_STORAGE_VOL_RESIZE_SHRINK = 1 << 2,
} virStorageVolResizeFlags;
int virStorageVolResize (virStorageVolPtr vol,
unsigned long long capacity,
unsigned int flags);
int virStoragePoolIsActive(virStoragePoolPtr pool);
int virStoragePoolIsPersistent(virStoragePoolPtr pool);
typedef enum {
VIR_STORAGE_POOL_EVENT_ID_LIFECYCLE = 0,
VIR_STORAGE_POOL_EVENT_ID_REFRESH = 1,
} virStoragePoolEventID;
typedef void (*virConnectStoragePoolEventGenericCallback)(virConnectPtr conn,
virStoragePoolPtr pool,
void *opaque);
int virConnectStoragePoolEventRegisterAny(virConnectPtr conn,
virStoragePoolPtr pool,
int eventID,
virConnectStoragePoolEventGenericCallback cb,
void *opaque,
virFreeCallback freecb);
int virConnectStoragePoolEventDeregisterAny(virConnectPtr conn,
int callbackID);
typedef enum {
VIR_STORAGE_POOL_EVENT_DEFINED = 0,
VIR_STORAGE_POOL_EVENT_UNDEFINED = 1,
VIR_STORAGE_POOL_EVENT_STARTED = 2,
VIR_STORAGE_POOL_EVENT_STOPPED = 3,
VIR_STORAGE_POOL_EVENT_CREATED = 4,
VIR_STORAGE_POOL_EVENT_DELETED = 5,
} virStoragePoolEventLifecycleType;
typedef void (*virConnectStoragePoolEventLifecycleCallback)(virConnectPtr conn,
virStoragePoolPtr pool,
int event,
int detail,
void *opaque);
typedef enum {
VIR_STREAM_NONBLOCK = (1 << 0),
} virStreamFlags;
virStreamPtr virStreamNew(virConnectPtr conn,
unsigned int flags);
int virStreamRef(virStreamPtr st);
int virStreamSend(virStreamPtr st,
const char *data,
size_t nbytes);
int virStreamRecv(virStreamPtr st,
char *data,
size_t nbytes);
typedef enum {
VIR_STREAM_RECV_STOP_AT_HOLE = (1 << 0),
} virStreamRecvFlagsValues;
int virStreamRecvFlags(virStreamPtr st,
char *data,
size_t nbytes,
unsigned int flags);
int virStreamSendHole(virStreamPtr st,
long long length,
unsigned int flags);
int virStreamRecvHole(virStreamPtr,
long long *length,
unsigned int flags);
typedef int (*virStreamSourceFunc)(virStreamPtr st,
char *data,
size_t nbytes,
void *opaque);
int virStreamSendAll(virStreamPtr st,
virStreamSourceFunc handler,
void *opaque);
typedef int (*virStreamSourceHoleFunc)(virStreamPtr st,
int *inData,
long long *length,
void *opaque);
typedef int (*virStreamSourceSkipFunc)(virStreamPtr st,
long long length,
void *opaque);
int virStreamSparseSendAll(virStreamPtr st,
virStreamSourceFunc handler,
virStreamSourceHoleFunc holeHandler,
virStreamSourceSkipFunc skipHandler,
void *opaque);
typedef int (*virStreamSinkFunc)(virStreamPtr st,
const char *data,
size_t nbytes,
void *opaque);
int virStreamRecvAll(virStreamPtr st,
virStreamSinkFunc handler,
void *opaque);
typedef int (*virStreamSinkHoleFunc)(virStreamPtr st,
long long length,
void *opaque);
int virStreamSparseRecvAll(virStreamPtr stream,
virStreamSinkFunc handler,
virStreamSinkHoleFunc holeHandler,
void *opaque);
typedef enum {
VIR_STREAM_EVENT_READABLE = (1 << 0),
VIR_STREAM_EVENT_WRITABLE = (1 << 1),
VIR_STREAM_EVENT_ERROR = (1 << 2),
VIR_STREAM_EVENT_HANGUP = (1 << 3),
} virStreamEventType;
typedef void (*virStreamEventCallback)(virStreamPtr stream, int events, void *opaque);
int virStreamEventAddCallback(virStreamPtr stream,
int events,
virStreamEventCallback cb,
void *opaque,
virFreeCallback ff);
int virStreamEventUpdateCallback(virStreamPtr stream,
int events);
int virStreamEventRemoveCallback(virStreamPtr stream);
int virStreamFinish(virStreamPtr st);
int virStreamAbort(virStreamPtr st);
int virStreamFree(virStreamPtr st);
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment