mirror of
https://gitlab.com/libvirt/libvirt.git
synced 2024-12-25 23:25:24 +00:00
5cc370aa36
VIR_DOMAIN_MEMORY_PARAM_UNLIMITED uses INT64_MAX but stdint.h was not and should not be included. Therefore, libvirt.h was not self-contained. Instead of including stdint.h specify the value directly.
2510 lines
90 KiB
C
2510 lines
90 KiB
C
/* -*- c -*-
|
|
* libvirt.h:
|
|
* Summary: core interfaces for the libvirt library
|
|
* Description: Provides the interfaces of the libvirt library to handle
|
|
* virtualized domains
|
|
*
|
|
* Copy: Copyright (C) 2005-2006, 2010-2011 Red Hat, Inc.
|
|
*
|
|
* See COPYING.LIB for the License of this software
|
|
*
|
|
* Author: Daniel Veillard <veillard@redhat.com>
|
|
*/
|
|
|
|
#ifndef __VIR_VIRLIB_H__
|
|
#define __VIR_VIRLIB_H__
|
|
|
|
#include <sys/types.h>
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#ifndef VIR_DEPRECATED
|
|
/* The feature is present in gcc-3.1 and newer. */
|
|
# if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1)
|
|
# define VIR_DEPRECATED __attribute__((__deprecated__))
|
|
# else
|
|
# define VIR_DEPRECATED /* nothing */
|
|
# endif
|
|
#endif /* VIR_DEPRECATED */
|
|
|
|
#ifdef WIN32
|
|
# ifdef LIBVIRT_STATIC
|
|
# define VIR_EXPORT_VAR extern
|
|
# else
|
|
# ifdef IN_LIBVIRT
|
|
# define VIR_EXPORT_VAR __declspec(dllexport)
|
|
# else
|
|
# define VIR_EXPORT_VAR __declspec(dllimport) extern
|
|
# endif
|
|
# endif
|
|
#else
|
|
# define VIR_EXPORT_VAR extern
|
|
#endif
|
|
|
|
/**
|
|
* virConnect:
|
|
*
|
|
* a virConnect is a private structure representing a connection to
|
|
* the Hypervisor.
|
|
*/
|
|
typedef struct _virConnect virConnect;
|
|
|
|
/**
|
|
* virConnectPtr:
|
|
*
|
|
* a virConnectPtr is pointer to a virConnect private structure, this is the
|
|
* type used to reference a connection to the Hypervisor in the API.
|
|
*/
|
|
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 */
|
|
} virDomainState;
|
|
|
|
/**
|
|
* 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 */
|
|
} virDomainCreateFlags;
|
|
|
|
|
|
|
|
/**
|
|
* virStream:
|
|
*
|
|
* a virStream is a private structure representing a data stream.
|
|
*/
|
|
typedef struct _virStream virStream;
|
|
|
|
/**
|
|
* virStreamPtr:
|
|
*
|
|
* a virStreamPtr is pointer to a virStream private structure, this is the
|
|
* type used to reference a data stream in the API.
|
|
*/
|
|
typedef virStream *virStreamPtr;
|
|
|
|
|
|
/**
|
|
* VIR_SECURITY_LABEL_BUFLEN:
|
|
*
|
|
* Macro providing the maximum length of the virSecurityLabel label string.
|
|
* Note that this value is based on that used by Labeled NFS.
|
|
*/
|
|
#define VIR_SECURITY_LABEL_BUFLEN (4096 + 1)
|
|
|
|
/**
|
|
* virSecurityLabel:
|
|
*
|
|
* a virSecurityLabel is a structure filled by virDomainGetSecurityLabel(),
|
|
* providing the security label and associated attributes for the specified
|
|
* domain.
|
|
*
|
|
*/
|
|
typedef struct _virSecurityLabel {
|
|
char label[VIR_SECURITY_LABEL_BUFLEN]; /* security label string */
|
|
int enforcing; /* 1 if security policy is being enforced for domain */
|
|
} virSecurityLabel;
|
|
|
|
/**
|
|
* virSecurityLabelPtr:
|
|
*
|
|
* a virSecurityLabelPtr is a pointer to a virSecurityLabel.
|
|
*/
|
|
typedef virSecurityLabel *virSecurityLabelPtr;
|
|
|
|
/**
|
|
* VIR_SECURITY_MODEL_BUFLEN:
|
|
*
|
|
* Macro providing the maximum length of the virSecurityModel model string.
|
|
*/
|
|
#define VIR_SECURITY_MODEL_BUFLEN (256 + 1)
|
|
|
|
/**
|
|
* VIR_SECURITY_DOI_BUFLEN:
|
|
*
|
|
* Macro providing the maximum length of the virSecurityModel doi string.
|
|
*/
|
|
#define VIR_SECURITY_DOI_BUFLEN (256 + 1)
|
|
|
|
/**
|
|
* virSecurityModel:
|
|
*
|
|
* a virSecurityModel is a structure filled by virNodeGetSecurityModel(),
|
|
* providing the per-hypervisor security model and DOI attributes for the
|
|
* specified domain.
|
|
*
|
|
*/
|
|
typedef struct _virSecurityModel {
|
|
char model[VIR_SECURITY_MODEL_BUFLEN]; /* security model string */
|
|
char doi[VIR_SECURITY_DOI_BUFLEN]; /* domain of interpetation */
|
|
} virSecurityModel;
|
|
|
|
/**
|
|
* virSecurityModelPtr:
|
|
*
|
|
* a virSecurityModelPtr is a pointer to a virSecurityModel.
|
|
*/
|
|
typedef virSecurityModel *virSecurityModelPtr;
|
|
|
|
/**
|
|
* virNodeInfoPtr:
|
|
*
|
|
* a virNodeInfo is a structure filled by virNodeGetInfo() and providing
|
|
* the information for the Node.
|
|
*/
|
|
|
|
typedef struct _virNodeInfo virNodeInfo;
|
|
|
|
struct _virNodeInfo {
|
|
char model[32]; /* string indicating the CPU model */
|
|
unsigned long memory;/* memory size in kilobytes */
|
|
unsigned int cpus; /* the number of active CPUs */
|
|
unsigned int mhz; /* expected CPU frequency */
|
|
unsigned int nodes; /* the number of NUMA cell, 1 for unusual NUMA
|
|
topologies or uniform memory access; check
|
|
capabilities XML for the actual NUMA topology */
|
|
unsigned int sockets;/* number of CPU sockets per node if nodes > 1,
|
|
total number of CPU sockets otherwise */
|
|
unsigned int cores; /* number of cores per socket */
|
|
unsigned int threads;/* number of threads per core */
|
|
};
|
|
|
|
|
|
/**
|
|
* virDomainSchedParameterType:
|
|
*
|
|
* A scheduler parameter field type
|
|
*/
|
|
typedef enum {
|
|
VIR_DOMAIN_SCHED_FIELD_INT = 1, /* integer case */
|
|
VIR_DOMAIN_SCHED_FIELD_UINT = 2, /* unsigned integer case */
|
|
VIR_DOMAIN_SCHED_FIELD_LLONG = 3, /* long long case */
|
|
VIR_DOMAIN_SCHED_FIELD_ULLONG = 4, /* unsigned long long case */
|
|
VIR_DOMAIN_SCHED_FIELD_DOUBLE = 5, /* double case */
|
|
VIR_DOMAIN_SCHED_FIELD_BOOLEAN = 6 /* boolean(character) case */
|
|
} virSchedParameterType;
|
|
|
|
/**
|
|
* VIR_DOMAIN_SCHED_FIELD_LENGTH:
|
|
*
|
|
* Macro providing the field length of virSchedParameter
|
|
*/
|
|
|
|
#define VIR_DOMAIN_SCHED_FIELD_LENGTH 80
|
|
|
|
/**
|
|
* virDomainSchedParameter:
|
|
*
|
|
* a virDomainSchedParameter is the set of scheduler parameters
|
|
*/
|
|
|
|
typedef struct _virSchedParameter virSchedParameter;
|
|
|
|
struct _virSchedParameter {
|
|
char field[VIR_DOMAIN_SCHED_FIELD_LENGTH]; /* parameter name */
|
|
int type; /* parameter type */
|
|
union {
|
|
int i; /* data for integer case */
|
|
unsigned int ui; /* data for unsigned integer case */
|
|
long long int l; /* data for long long integer case */
|
|
unsigned long long int ul; /* data for unsigned long long integer case */
|
|
double d; /* data for double case */
|
|
char b; /* data for char case */
|
|
} value; /* parameter value */
|
|
};
|
|
|
|
/**
|
|
* virSchedParameterPtr:
|
|
*
|
|
* a virSchedParameterPtr is a pointer to a virSchedParameter structure.
|
|
*/
|
|
|
|
typedef virSchedParameter *virSchedParameterPtr;
|
|
|
|
/*
|
|
* Fetch scheduler parameters, caller allocates 'params' field of size 'nparams'
|
|
*/
|
|
int virDomainGetSchedulerParameters (virDomainPtr domain,
|
|
virSchedParameterPtr params,
|
|
int *nparams);
|
|
|
|
/*
|
|
* Change scheduler parameters
|
|
*/
|
|
int virDomainSetSchedulerParameters (virDomainPtr domain,
|
|
virSchedParameterPtr params,
|
|
int nparams);
|
|
|
|
/**
|
|
* 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;
|
|
|
|
/**
|
|
* 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,
|
|
|
|
/*
|
|
* 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 = 6,
|
|
} 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 */
|
|
} virDomainCoreDumpFlags;
|
|
|
|
/* 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) */
|
|
|
|
} virDomainMigrateFlags;
|
|
|
|
/* Domain migration. */
|
|
virDomainPtr virDomainMigrate (virDomainPtr domain, virConnectPtr dconn,
|
|
unsigned long flags, const char *dname,
|
|
const char *uri, unsigned long bandwidth);
|
|
|
|
int virDomainMigrateToURI (virDomainPtr domain, const char *duri,
|
|
unsigned long flags, const char *dname,
|
|
unsigned long bandwidth);
|
|
|
|
int virDomainMigrateSetMaxDowntime (virDomainPtr domain,
|
|
unsigned long long downtime,
|
|
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;
|
|
|
|
/**
|
|
* virConnectFlags
|
|
*
|
|
* Flags when opening a connection to a hypervisor
|
|
*/
|
|
typedef enum {
|
|
VIR_CONNECT_RO = 1, /* A readonly connection */
|
|
} 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 */
|
|
|
|
/* More may be added - expect the unexpected */
|
|
} 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 can not 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@
|
|
|
|
int virGetVersion (unsigned long *libVer,
|
|
const char *type,
|
|
unsigned long *typeVer);
|
|
|
|
/*
|
|
* Connection and disconnections to the Hypervisor
|
|
*/
|
|
int virInitialize (void);
|
|
|
|
virConnectPtr virConnectOpen (const char *name);
|
|
virConnectPtr virConnectOpenReadOnly (const char *name);
|
|
virConnectPtr virConnectOpenAuth (const char *name,
|
|
virConnectAuthPtr auth,
|
|
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);
|
|
|
|
|
|
/*
|
|
* Capabilities of the connection / driver.
|
|
*/
|
|
|
|
int virConnectGetMaxVcpus (virConnectPtr conn,
|
|
const char *type);
|
|
int virNodeGetInfo (virConnectPtr conn,
|
|
virNodeInfoPtr info);
|
|
char * virConnectGetCapabilities (virConnectPtr conn);
|
|
|
|
unsigned long long virNodeGetFreeMemory (virConnectPtr conn);
|
|
|
|
int virNodeGetSecurityModel (virConnectPtr conn,
|
|
virSecurityModelPtr secmodel);
|
|
|
|
/*
|
|
* 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 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);
|
|
|
|
int virDomainShutdown (virDomainPtr domain);
|
|
int virDomainReboot (virDomainPtr domain,
|
|
unsigned int flags);
|
|
int virDomainDestroy (virDomainPtr domain);
|
|
int virDomainRef (virDomainPtr domain);
|
|
int virDomainFree (virDomainPtr domain);
|
|
|
|
/*
|
|
* Domain suspend/resume
|
|
*/
|
|
int virDomainSuspend (virDomainPtr domain);
|
|
int virDomainResume (virDomainPtr domain);
|
|
|
|
/*
|
|
* Domain save/restore
|
|
*/
|
|
int virDomainSave (virDomainPtr domain,
|
|
const char *to);
|
|
int virDomainRestore (virConnectPtr conn,
|
|
const char *from);
|
|
|
|
/*
|
|
* 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,
|
|
int flags);
|
|
|
|
/*
|
|
* Domain runtime information
|
|
*/
|
|
int virDomainGetInfo (virDomainPtr domain,
|
|
virDomainInfoPtr info);
|
|
|
|
/*
|
|
* Return scheduler type in effect 'sedf', 'credit', 'linux'
|
|
*/
|
|
char * virDomainGetSchedulerType(virDomainPtr domain,
|
|
int *nparams);
|
|
/**
|
|
* virDomainBlkioParameterType:
|
|
*
|
|
* A blkio parameter field type
|
|
*/
|
|
typedef enum {
|
|
VIR_DOMAIN_BLKIO_PARAM_INT = 1, /* integer case */
|
|
VIR_DOMAIN_BLKIO_PARAM_UINT = 2, /* unsigned integer case */
|
|
VIR_DOMAIN_BLKIO_PARAM_LLONG = 3, /* long long case */
|
|
VIR_DOMAIN_BLKIO_PARAM_ULLONG = 4, /* unsigned long long case */
|
|
VIR_DOMAIN_BLKIO_PARAM_DOUBLE = 5, /* double case */
|
|
VIR_DOMAIN_BLKIO_PARAM_BOOLEAN = 6 /* boolean(character) case */
|
|
} virBlkioParameterType;
|
|
|
|
/**
|
|
* VIR_DOMAIN_BLKIO_FIELD_LENGTH:
|
|
*
|
|
* Macro providing the field length of virBlkioParameter
|
|
*/
|
|
|
|
#define VIR_DOMAIN_BLKIO_FIELD_LENGTH 80
|
|
|
|
/**
|
|
* VIR_DOMAIN_BLKIO_WEIGHT:
|
|
*
|
|
* Macro for the Blkio tunable weight: it represents the io weight
|
|
* the guest can use.
|
|
*/
|
|
|
|
#define VIR_DOMAIN_BLKIO_WEIGHT "weight"
|
|
|
|
/**
|
|
* virDomainBlkioParameter:
|
|
*
|
|
* a virDomainBlkioParameter is the set of blkio parameters
|
|
*/
|
|
|
|
typedef struct _virBlkioParameter virBlkioParameter;
|
|
|
|
struct _virBlkioParameter {
|
|
char field[VIR_DOMAIN_BLKIO_FIELD_LENGTH]; /* parameter name */
|
|
int type; /* parameter type */
|
|
union {
|
|
int i; /* data for integer case */
|
|
unsigned int ui; /* data for unsigned integer case */
|
|
long long int l; /* data for long long integer case */
|
|
unsigned long long int ul; /* data for unsigned long long integer case */
|
|
double d; /* data for double case */
|
|
char b; /* data for char case */
|
|
} value; /* parameter value */
|
|
};
|
|
|
|
/**
|
|
* virBlkioParameterPtr:
|
|
*
|
|
* a virBlkioParameterPtr is a pointer to a virBlkioParameter structure.
|
|
*/
|
|
|
|
typedef virBlkioParameter *virBlkioParameterPtr;
|
|
|
|
/* Set Blkio tunables for the domain*/
|
|
int virDomainSetBlkioParameters(virDomainPtr domain,
|
|
virBlkioParameterPtr params,
|
|
int nparams, unsigned int flags);
|
|
int virDomainGetBlkioParameters(virDomainPtr domain,
|
|
virBlkioParameterPtr params,
|
|
int *nparams, unsigned int flags);
|
|
|
|
/**
|
|
* virDomainMemoryParameterType:
|
|
*
|
|
* A memory parameter field type
|
|
*/
|
|
typedef enum {
|
|
VIR_DOMAIN_MEMORY_PARAM_INT = 1, /* integer case */
|
|
VIR_DOMAIN_MEMORY_PARAM_UINT = 2, /* unsigned integer case */
|
|
VIR_DOMAIN_MEMORY_PARAM_LLONG = 3, /* long long case */
|
|
VIR_DOMAIN_MEMORY_PARAM_ULLONG = 4, /* unsigned long long case */
|
|
VIR_DOMAIN_MEMORY_PARAM_DOUBLE = 5, /* double case */
|
|
VIR_DOMAIN_MEMORY_PARAM_BOOLEAN = 6 /* boolean(character) case */
|
|
} virMemoryParameterType;
|
|
|
|
/**
|
|
* VIR_DOMAIN_MEMORY_FIELD_LENGTH:
|
|
*
|
|
* Macro providing the field length of virMemoryParameter
|
|
*/
|
|
|
|
#define VIR_DOMAIN_MEMORY_FIELD_LENGTH 80
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
|
|
#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.
|
|
*/
|
|
|
|
#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.
|
|
*/
|
|
|
|
#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
|
|
* the guest can use.
|
|
*/
|
|
|
|
#define VIR_DOMAIN_MEMORY_SWAP_HARD_LIMIT "swap_hard_limit"
|
|
|
|
/**
|
|
* virDomainMemoryParameter:
|
|
*
|
|
* a virDomainMemoryParameter is the set of scheduler parameters
|
|
*/
|
|
|
|
typedef struct _virMemoryParameter virMemoryParameter;
|
|
|
|
struct _virMemoryParameter {
|
|
char field[VIR_DOMAIN_MEMORY_FIELD_LENGTH]; /* parameter name */
|
|
int type; /* parameter type */
|
|
union {
|
|
int i; /* data for integer case */
|
|
unsigned int ui; /* data for unsigned integer case */
|
|
long long int l; /* data for long long integer case */
|
|
unsigned long long int ul; /* data for unsigned long long integer case */
|
|
double d; /* data for double case */
|
|
char b; /* data for char case */
|
|
} value; /* parameter value */
|
|
};
|
|
|
|
/**
|
|
* virMemoryParameterPtr:
|
|
*
|
|
* a virMemoryParameterPtr is a pointer to a virMemoryParameter structure.
|
|
*/
|
|
|
|
typedef virMemoryParameter *virMemoryParameterPtr;
|
|
|
|
/* Set memory tunables for the domain*/
|
|
int virDomainSetMemoryParameters(virDomainPtr domain,
|
|
virMemoryParameterPtr params,
|
|
int nparams, unsigned int flags);
|
|
int virDomainGetMemoryParameters(virDomainPtr domain,
|
|
virMemoryParameterPtr params,
|
|
int *nparams, unsigned int flags);
|
|
|
|
/* Memory size modification flags. */
|
|
typedef enum {
|
|
VIR_DOMAIN_MEM_LIVE = (1 << 0), /* affect active domain */
|
|
VIR_DOMAIN_MEM_CONFIG = (1 << 1), /* affect next boot */
|
|
} virDomainMemoryModFlags;
|
|
|
|
|
|
/*
|
|
* 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 virDomainGetMaxVcpus (virDomainPtr domain);
|
|
int virDomainGetSecurityLabel (virDomainPtr domain,
|
|
virSecurityLabelPtr seclabel);
|
|
|
|
/*
|
|
* 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 */
|
|
} virDomainXMLFlags;
|
|
|
|
char * virDomainGetXMLDesc (virDomainPtr domain,
|
|
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 *path,
|
|
virDomainBlockStatsPtr stats,
|
|
size_t size);
|
|
int virDomainInterfaceStats (virDomainPtr dom,
|
|
const char *path,
|
|
virDomainInterfaceStatsPtr stats,
|
|
size_t size);
|
|
int virDomainMemoryStats (virDomainPtr dom,
|
|
virDomainMemoryStatPtr stats,
|
|
unsigned int nr_stats,
|
|
unsigned int flags);
|
|
int virDomainBlockPeek (virDomainPtr dom,
|
|
const char *path,
|
|
unsigned long long offset,
|
|
size_t size,
|
|
void *buffer,
|
|
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
|
|
* * 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 *path,
|
|
virDomainBlockInfoPtr info,
|
|
unsigned int flags);
|
|
|
|
/* Memory peeking flags. */
|
|
typedef enum {
|
|
VIR_MEMORY_VIRTUAL = 1, /* addresses are virtual addresses */
|
|
VIR_MEMORY_PHYSICAL = 2, /* 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);
|
|
int virConnectNumOfDefinedDomains (virConnectPtr conn);
|
|
int virConnectListDefinedDomains (virConnectPtr conn,
|
|
char **const names,
|
|
int maxnames);
|
|
int virDomainCreate (virDomainPtr domain);
|
|
int virDomainCreateWithFlags (virDomainPtr domain,
|
|
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 */
|
|
} 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 {
|
|
/* Must choose at least one of these two bits; SetVcpus can choose both */
|
|
VIR_DOMAIN_VCPU_LIVE = (1 << 0), /* Affect active domain */
|
|
VIR_DOMAIN_VCPU_CONFIG = (1 << 1), /* Affect next boot */
|
|
|
|
/* Additional flags to be bit-wise OR'd in */
|
|
VIR_DOMAIN_VCPU_MAXIMUM = (1 << 2), /* Max rather than current count */
|
|
} 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);
|
|
|
|
/**
|
|
* 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.
|
|
* USE_CPU macro set 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.
|
|
* USE_CPU macro reset 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_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) \
|
|
(cpumaps[((vcpu)*(maplen))+((cpu)/8)] & (1<<((cpu)%8)))
|
|
|
|
/**
|
|
* 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 extract the cpumap of
|
|
* the specified vcpu from cpumaps array and copy it into cpumap to be used
|
|
* later by virDomainPinVcpu() API.
|
|
*/
|
|
#define VIR_COPY_CPUMAP(cpumaps,maplen,vcpu,cpumap) \
|
|
memcpy(cpumap, &(cpumaps[(vcpu)*(maplen)]), (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 {
|
|
|
|
VIR_DOMAIN_DEVICE_MODIFY_CURRENT = 0, /* Modify device allocation based on current domain state */
|
|
VIR_DOMAIN_DEVICE_MODIFY_LIVE = (1 << 0), /* Modify live device allocation */
|
|
VIR_DOMAIN_DEVICE_MODIFY_CONFIG = (1 << 1), /* Modify persisted device allocation */
|
|
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);
|
|
|
|
/*
|
|
* NUMA support
|
|
*/
|
|
|
|
int virNodeGetCellsFreeMemory(virConnectPtr conn,
|
|
unsigned long long *freeMems,
|
|
int startCell,
|
|
int maxCells);
|
|
|
|
/*
|
|
* Virtual Networks API
|
|
*/
|
|
|
|
/**
|
|
* virNetwork:
|
|
*
|
|
* a virNetwork is a private structure representing a virtual network.
|
|
*/
|
|
typedef struct _virNetwork virNetwork;
|
|
|
|
/**
|
|
* virNetworkPtr:
|
|
*
|
|
* a virNetworkPtr is pointer to a virNetwork private structure, this is the
|
|
* type used to reference a virtual network in the API.
|
|
*/
|
|
typedef virNetwork *virNetworkPtr;
|
|
|
|
/*
|
|
* Get connection from network.
|
|
*/
|
|
virConnectPtr virNetworkGetConnect (virNetworkPtr network);
|
|
|
|
/*
|
|
* List active networks
|
|
*/
|
|
int virConnectNumOfNetworks (virConnectPtr conn);
|
|
int virConnectListNetworks (virConnectPtr conn,
|
|
char **const names,
|
|
int maxnames);
|
|
|
|
/*
|
|
* List inactive networks
|
|
*/
|
|
int virConnectNumOfDefinedNetworks (virConnectPtr conn);
|
|
int virConnectListDefinedNetworks (virConnectPtr conn,
|
|
char **const names,
|
|
int maxnames);
|
|
|
|
/*
|
|
* Lookup network by name or uuid
|
|
*/
|
|
virNetworkPtr virNetworkLookupByName (virConnectPtr conn,
|
|
const char *name);
|
|
virNetworkPtr virNetworkLookupByUUID (virConnectPtr conn,
|
|
const unsigned char *uuid);
|
|
virNetworkPtr virNetworkLookupByUUIDString (virConnectPtr conn,
|
|
const char *uuid);
|
|
|
|
/*
|
|
* Create active transient network
|
|
*/
|
|
virNetworkPtr virNetworkCreateXML (virConnectPtr conn,
|
|
const char *xmlDesc);
|
|
|
|
/*
|
|
* Define inactive persistent network
|
|
*/
|
|
virNetworkPtr virNetworkDefineXML (virConnectPtr conn,
|
|
const char *xmlDesc);
|
|
|
|
/*
|
|
* Delete persistent network
|
|
*/
|
|
int virNetworkUndefine (virNetworkPtr network);
|
|
|
|
/*
|
|
* Activate persistent network
|
|
*/
|
|
int virNetworkCreate (virNetworkPtr network);
|
|
|
|
/*
|
|
* Network destroy/free
|
|
*/
|
|
int virNetworkDestroy (virNetworkPtr network);
|
|
int virNetworkRef (virNetworkPtr network);
|
|
int virNetworkFree (virNetworkPtr network);
|
|
|
|
/*
|
|
* Network information
|
|
*/
|
|
const char* virNetworkGetName (virNetworkPtr network);
|
|
int virNetworkGetUUID (virNetworkPtr network,
|
|
unsigned char *uuid);
|
|
int virNetworkGetUUIDString (virNetworkPtr network,
|
|
char *buf);
|
|
char * virNetworkGetXMLDesc (virNetworkPtr network,
|
|
int flags);
|
|
char * virNetworkGetBridgeName (virNetworkPtr network);
|
|
|
|
int virNetworkGetAutostart (virNetworkPtr network,
|
|
int *autostart);
|
|
int virNetworkSetAutostart (virNetworkPtr network,
|
|
int autostart);
|
|
|
|
/*
|
|
* Physical host interface configuration API
|
|
*/
|
|
|
|
/**
|
|
* virInterface:
|
|
*
|
|
* a virInterface is a private structure representing a virtual interface.
|
|
*/
|
|
typedef struct _virInterface virInterface;
|
|
|
|
/**
|
|
* virInterfacePtr:
|
|
*
|
|
* a virInterfacePtr is pointer to a virInterface private structure, this is the
|
|
* type used to reference a virtual interface in the API.
|
|
*/
|
|
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);
|
|
|
|
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 /* dump inactive interface information */
|
|
} 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);
|
|
|
|
/**
|
|
* virStoragePool:
|
|
*
|
|
* a virStoragePool is a private structure representing a storage pool
|
|
*/
|
|
typedef struct _virStoragePool virStoragePool;
|
|
|
|
/**
|
|
* virStoragePoolPtr:
|
|
*
|
|
* a virStoragePoolPtr is pointer to a virStoragePool private structure, this is the
|
|
* type used to reference a storage pool in the API.
|
|
*/
|
|
typedef virStoragePool *virStoragePoolPtr;
|
|
|
|
|
|
typedef enum {
|
|
VIR_STORAGE_POOL_INACTIVE = 0, /* Not running */
|
|
VIR_STORAGE_POOL_BUILDING = 1, /* Initializing pool, not available */
|
|
VIR_STORAGE_POOL_RUNNING = 2, /* Running normally */
|
|
VIR_STORAGE_POOL_DEGRADED = 3, /* Running degraded */
|
|
VIR_STORAGE_POOL_INACCESSIBLE = 4, /* Running, but not accessible */
|
|
} virStoragePoolState;
|
|
|
|
|
|
typedef enum {
|
|
VIR_STORAGE_POOL_BUILD_NEW = 0, /* Regular build from scratch */
|
|
VIR_STORAGE_POOL_BUILD_REPAIR = 1, /* Repair / reinitialize */
|
|
VIR_STORAGE_POOL_BUILD_RESIZE = 2 /* Extend existing pool */
|
|
} virStoragePoolBuildFlags;
|
|
|
|
typedef enum {
|
|
VIR_STORAGE_POOL_DELETE_NORMAL = 0, /* Delete metadata only (fast) */
|
|
VIR_STORAGE_POOL_DELETE_ZEROED = 1, /* Clear all data to zeros (slow) */
|
|
} virStoragePoolDeleteFlags;
|
|
|
|
typedef struct _virStoragePoolInfo virStoragePoolInfo;
|
|
|
|
struct _virStoragePoolInfo {
|
|
int state; /* virStoragePoolState flags */
|
|
unsigned long long capacity; /* Logical size bytes */
|
|
unsigned long long allocation; /* Current allocation bytes */
|
|
unsigned long long available; /* Remaining free space bytes */
|
|
};
|
|
|
|
typedef virStoragePoolInfo *virStoragePoolInfoPtr;
|
|
|
|
|
|
/**
|
|
* virStorageVol:
|
|
*
|
|
* a virStorageVol is a private structure representing a storage volume
|
|
*/
|
|
typedef struct _virStorageVol virStorageVol;
|
|
|
|
/**
|
|
* virStorageVolPtr:
|
|
*
|
|
* a virStorageVolPtr is pointer to a virStorageVol private structure, this is the
|
|
* type used to reference a storage volume in the API.
|
|
*/
|
|
typedef virStorageVol *virStorageVolPtr;
|
|
|
|
|
|
typedef enum {
|
|
VIR_STORAGE_VOL_FILE = 0, /* Regular file based volumes */
|
|
VIR_STORAGE_VOL_BLOCK = 1, /* Block based volumes */
|
|
} virStorageVolType;
|
|
|
|
typedef enum {
|
|
VIR_STORAGE_VOL_DELETE_NORMAL = 0, /* Delete metadata only (fast) */
|
|
VIR_STORAGE_VOL_DELETE_ZEROED = 1, /* Clear all data to zeros (slow) */
|
|
} virStorageVolDeleteFlags;
|
|
|
|
typedef struct _virStorageVolInfo virStorageVolInfo;
|
|
|
|
struct _virStorageVolInfo {
|
|
int type; /* virStorageVolType flags */
|
|
unsigned long long capacity; /* Logical size bytes */
|
|
unsigned long long allocation; /* Current allocation bytes */
|
|
};
|
|
|
|
typedef virStorageVolInfo *virStorageVolInfoPtr;
|
|
|
|
/*
|
|
* Get connection from pool.
|
|
*/
|
|
virConnectPtr virStoragePoolGetConnect (virStoragePoolPtr pool);
|
|
|
|
/*
|
|
* List active storage pools
|
|
*/
|
|
int virConnectNumOfStoragePools (virConnectPtr conn);
|
|
int virConnectListStoragePools (virConnectPtr conn,
|
|
char **const names,
|
|
int maxnames);
|
|
|
|
/*
|
|
* List inactive storage pools
|
|
*/
|
|
int virConnectNumOfDefinedStoragePools(virConnectPtr conn);
|
|
int virConnectListDefinedStoragePools(virConnectPtr conn,
|
|
char **const names,
|
|
int maxnames);
|
|
|
|
/*
|
|
* Query a host for storage pools of a particular type
|
|
*/
|
|
char * virConnectFindStoragePoolSources(virConnectPtr conn,
|
|
const char *type,
|
|
const char *srcSpec,
|
|
unsigned int flags);
|
|
|
|
/*
|
|
* Lookup pool by name or uuid
|
|
*/
|
|
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);
|
|
|
|
/*
|
|
* Creating/destroying pools
|
|
*/
|
|
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);
|
|
|
|
/*
|
|
* StoragePool information
|
|
*/
|
|
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);
|
|
|
|
/*
|
|
* List/lookup storage volumes within a pool
|
|
*/
|
|
int virStoragePoolNumOfVolumes (virStoragePoolPtr pool);
|
|
int virStoragePoolListVolumes (virStoragePoolPtr pool,
|
|
char **const names,
|
|
int maxnames);
|
|
|
|
virConnectPtr virStorageVolGetConnect (virStorageVolPtr vol);
|
|
|
|
/*
|
|
* Lookup volumes based on various attributes
|
|
*/
|
|
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);
|
|
|
|
virStorageVolPtr virStorageVolCreateXML (virStoragePoolPtr pool,
|
|
const char *xmldesc,
|
|
unsigned int flags);
|
|
virStorageVolPtr virStorageVolCreateXMLFrom (virStoragePoolPtr pool,
|
|
const char *xmldesc,
|
|
virStorageVolPtr clonevol,
|
|
unsigned int flags);
|
|
int virStorageVolDelete (virStorageVolPtr vol,
|
|
unsigned int flags);
|
|
int virStorageVolWipe (virStorageVolPtr vol,
|
|
unsigned int flags);
|
|
int virStorageVolRef (virStorageVolPtr vol);
|
|
int virStorageVolFree (virStorageVolPtr vol);
|
|
|
|
int virStorageVolGetInfo (virStorageVolPtr vol,
|
|
virStorageVolInfoPtr info);
|
|
char * virStorageVolGetXMLDesc (virStorageVolPtr pool,
|
|
unsigned int flags);
|
|
|
|
char * virStorageVolGetPath (virStorageVolPtr vol);
|
|
|
|
/*
|
|
* Deprecated calls
|
|
*/
|
|
virDomainPtr virDomainCreateLinux (virConnectPtr conn,
|
|
const char *xmlDesc,
|
|
unsigned int flags);
|
|
|
|
/*
|
|
* Host device enumeration
|
|
*/
|
|
|
|
/**
|
|
* virNodeDevice:
|
|
*
|
|
* A virNodeDevice contains a node (host) device details.
|
|
*/
|
|
|
|
typedef struct _virNodeDevice virNodeDevice;
|
|
|
|
/**
|
|
* virNodeDevicePtr:
|
|
*
|
|
* A virNodeDevicePtr is a pointer to a virNodeDevice structure. Get
|
|
* one via virNodeDeviceLookupByKey, virNodeDeviceLookupByName, or
|
|
* virNodeDeviceCreate. Be sure to Call virNodeDeviceFree when done
|
|
* using a virNodeDevicePtr obtained from any of the above functions to
|
|
* avoid leaking memory.
|
|
*/
|
|
|
|
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);
|
|
|
|
virNodeDevicePtr virNodeDeviceLookupByName (virConnectPtr conn,
|
|
const char *name);
|
|
|
|
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 virNodeDeviceReAttach (virNodeDevicePtr dev);
|
|
int virNodeDeviceReset (virNodeDevicePtr dev);
|
|
|
|
virNodeDevicePtr virNodeDeviceCreateXML (virConnectPtr conn,
|
|
const char *xmlDesc,
|
|
unsigned int flags);
|
|
|
|
int virNodeDeviceDestroy (virNodeDevicePtr dev);
|
|
|
|
/*
|
|
* 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,
|
|
} virDomainEventType;
|
|
|
|
/**
|
|
* virDomainEventDefinedDetailType:
|
|
*
|
|
* Details on the caused of the 'defined' lifecycle event
|
|
*/
|
|
typedef enum {
|
|
VIR_DOMAIN_EVENT_DEFINED_ADDED = 0, /* Newly created config file */
|
|
VIR_DOMAIN_EVENT_DEFINED_UPDATED = 1, /* Changed config file */
|
|
} virDomainEventDefinedDetailType;
|
|
|
|
/**
|
|
* virDomainEventUndefinedDetailType:
|
|
*
|
|
* Details on the caused of the 'undefined' lifecycle event
|
|
*/
|
|
typedef enum {
|
|
VIR_DOMAIN_EVENT_UNDEFINED_REMOVED = 0, /* Deleted the config file */
|
|
} virDomainEventUndefinedDetailType;
|
|
|
|
/**
|
|
* virDomainEventStartedDetailType:
|
|
*
|
|
* Details on the caused of the '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 */
|
|
} virDomainEventStartedDetailType;
|
|
|
|
/**
|
|
* virDomainEventSuspendedDetailType:
|
|
*
|
|
* Details on the caused of the '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 */
|
|
} virDomainEventSuspendedDetailType;
|
|
|
|
/**
|
|
* virDomainEventResumedDetailType:
|
|
*
|
|
* Details on the caused of the '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 */
|
|
} virDomainEventResumedDetailType;
|
|
|
|
/**
|
|
* virDomainEventStoppedDetailType:
|
|
*
|
|
* Details on the caused of the '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 */
|
|
} virDomainEventStoppedDetailType;
|
|
|
|
|
|
/**
|
|
* virConnectDomainEventCallback:
|
|
* @conn: virConnect connection
|
|
* @dom: The domain on which the event occured
|
|
* @event: The specfic virDomainEventType which occured
|
|
* @detail: event specific detail information
|
|
* @opaque: opaque user data
|
|
*
|
|
* A callback function to be registered, and called when a domain event occurs
|
|
*/
|
|
typedef int (*virConnectDomainEventCallback)(virConnectPtr conn,
|
|
virDomainPtr dom,
|
|
int event,
|
|
int detail,
|
|
void *opaque);
|
|
|
|
/*
|
|
* virFreeCallback:
|
|
* @opaque: opaque user data provided at registration
|
|
*
|
|
* Type for a domain event callback when the event is deregistered and
|
|
* need to be freed, @opaque is provided along with the callback at
|
|
* registration time
|
|
*/
|
|
typedef void (*virFreeCallback)(void *opaque);
|
|
|
|
int virConnectDomainEventRegister(virConnectPtr conn,
|
|
virConnectDomainEventCallback cb,
|
|
void *opaque,
|
|
virFreeCallback freecb);
|
|
|
|
int virConnectDomainEventDeregister(virConnectPtr conn,
|
|
virConnectDomainEventCallback cb);
|
|
|
|
/*
|
|
* Events Implementation
|
|
*/
|
|
|
|
/**
|
|
* virEventHandleType:
|
|
*
|
|
* a virEventHandleType is used similar to POLLxxx FD events, but is specific
|
|
* to libvirt. A client app must translate to, and from POLL events when using
|
|
* this construct.
|
|
*/
|
|
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;
|
|
|
|
/**
|
|
* virEventHandleCallback:
|
|
*
|
|
* @watch: watch on which the event occurred
|
|
* @fd: file handle on which the event occurred
|
|
* @events: bitset of events from virEventHandleType constants
|
|
* @opaque: user data registered with handle
|
|
*
|
|
* Callback for receiving file handle events. The callback will
|
|
* be invoked once for each event which is pending.
|
|
*/
|
|
typedef void (*virEventHandleCallback)(int watch, int fd, int events, void *opaque);
|
|
|
|
/**
|
|
* virEventAddHandleFunc:
|
|
* @fd: file descriptor to listen on
|
|
* @event: bitset of events on which to fire the callback
|
|
* @cb: the callback to be called when an event occurrs
|
|
* @opaque: user data to pass to the callback
|
|
* @ff: the callback invoked to free opaque data blob
|
|
*
|
|
* Part of the EventImpl, this callback Adds a file handle callback to
|
|
* listen for specific events. The same file handle can be registered
|
|
* multiple times provided the requested event sets are non-overlapping
|
|
*
|
|
* If the opaque user data requires free'ing when the handle
|
|
* is unregistered, then a 2nd callback can be supplied for
|
|
* this purpose.
|
|
*
|
|
* Returns a handle watch number to be used for updating
|
|
* and unregistering for events
|
|
*/
|
|
typedef int (*virEventAddHandleFunc)(int fd, int event,
|
|
virEventHandleCallback cb,
|
|
void *opaque,
|
|
virFreeCallback ff);
|
|
|
|
/**
|
|
* virEventUpdateHandleFunc:
|
|
* @watch: file descriptor watch to modify
|
|
* @event: new events to listen on
|
|
*
|
|
* Part of the EventImpl, this user-provided callback is notified when
|
|
* events to listen on change
|
|
*/
|
|
typedef void (*virEventUpdateHandleFunc)(int watch, int event);
|
|
|
|
/**
|
|
* virEventRemoveHandleFunc:
|
|
* @watch: file descriptor watch to stop listening on
|
|
*
|
|
* Part of the EventImpl, this user-provided callback is notified when
|
|
* an fd is no longer being listened on.
|
|
*
|
|
* If a virEventHandleFreeFunc was supplied when the handle was
|
|
* registered, it will be invoked some time during, or after this
|
|
* function call, when it is safe to release the user data.
|
|
*/
|
|
typedef int (*virEventRemoveHandleFunc)(int watch);
|
|
|
|
/**
|
|
* virEventTimeoutCallback:
|
|
*
|
|
* @timer: timer id emitting the event
|
|
* @opaque: user data registered with handle
|
|
*
|
|
* callback for receiving timer events
|
|
*/
|
|
typedef void (*virEventTimeoutCallback)(int timer, void *opaque);
|
|
|
|
/**
|
|
* virEventAddTimeoutFunc:
|
|
* @timeout: The timeout to monitor
|
|
* @cb: the callback to call when timeout has expired
|
|
* @opaque: user data to pass to the callback
|
|
* @ff: the callback invoked to free opaque data blob
|
|
*
|
|
* Part of the EventImpl, this user-defined callback handles adding an
|
|
* event timeout.
|
|
*
|
|
* If the opaque user data requires free'ing when the handle
|
|
* is unregistered, then a 2nd callback can be supplied for
|
|
* this purpose.
|
|
*
|
|
* Returns a timer value
|
|
*/
|
|
typedef int (*virEventAddTimeoutFunc)(int timeout,
|
|
virEventTimeoutCallback cb,
|
|
void *opaque,
|
|
virFreeCallback ff);
|
|
|
|
/**
|
|
* virEventUpdateTimeoutFunc:
|
|
* @timer: the timer to modify
|
|
* @timeout: the new timeout value
|
|
*
|
|
* Part of the EventImpl, this user-defined callback updates an
|
|
* event timeout.
|
|
*/
|
|
typedef void (*virEventUpdateTimeoutFunc)(int timer, int timeout);
|
|
|
|
/**
|
|
* virEventRemoveTimeoutFunc:
|
|
* @timer: the timer to remove
|
|
*
|
|
* Part of the EventImpl, this user-defined callback removes a timer
|
|
*
|
|
* If a virEventTimeoutFreeFunc was supplied when the handle was
|
|
* registered, it will be invoked some time during, or after this
|
|
* function call, when it is safe to release the user data.
|
|
*
|
|
* Returns 0 on success, -1 on failure
|
|
*/
|
|
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);
|
|
|
|
/*
|
|
* Secret manipulation API
|
|
*/
|
|
|
|
/**
|
|
* virSecret:
|
|
*
|
|
* A virSecret stores a secret value (e.g. a passphrase or encryption key)
|
|
* and associated metadata.
|
|
*/
|
|
typedef struct _virSecret virSecret;
|
|
typedef virSecret *virSecretPtr;
|
|
|
|
typedef enum {
|
|
VIR_SECRET_USAGE_TYPE_NONE = 0,
|
|
VIR_SECRET_USAGE_TYPE_VOLUME = 1,
|
|
/* Expect more owner types later... */
|
|
} virSecretUsageType;
|
|
|
|
virConnectPtr virSecretGetConnect (virSecretPtr secret);
|
|
int virConnectNumOfSecrets (virConnectPtr conn);
|
|
int virConnectListSecrets (virConnectPtr conn,
|
|
char **uuids,
|
|
int maxuuids);
|
|
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_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);
|
|
|
|
|
|
/**
|
|
* virStreamSourceFunc:
|
|
*
|
|
* @st: the stream object
|
|
* @data: preallocated array to be filled with data
|
|
* @nbytes: size of the data array
|
|
* @opaque: optional application provided data
|
|
*
|
|
* The virStreamSourceFunc callback is used together
|
|
* with the virStreamSendAll function for libvirt to
|
|
* obtain the data that is to be sent.
|
|
*
|
|
* The callback will be invoked multiple times,
|
|
* fetching data in small chunks. The application
|
|
* should fill the 'data' array with upto 'nbytes'
|
|
* of data and then return the number actual number
|
|
* of bytes. The callback will continue to be
|
|
* invoked until it indicates the end of the source
|
|
* has been reached by returning 0. A return value
|
|
* of -1 at any time will abort the send operation
|
|
*
|
|
* Returns the number of bytes filled, 0 upon end
|
|
* of file, or -1 upon error
|
|
*/
|
|
typedef int (*virStreamSourceFunc)(virStreamPtr st,
|
|
char *data,
|
|
size_t nbytes,
|
|
void *opaque);
|
|
|
|
int virStreamSendAll(virStreamPtr st,
|
|
virStreamSourceFunc handler,
|
|
void *opaque);
|
|
|
|
/**
|
|
* virStreamSinkFunc:
|
|
*
|
|
* @st: the stream object
|
|
* @data: preallocated array to be filled with data
|
|
* @nbytes: size of the data array
|
|
* @opaque: optional application provided data
|
|
*
|
|
* The virStreamSinkFunc callback is used together
|
|
* with the virStreamRecvAll function for libvirt to
|
|
* provide the data that has been received.
|
|
*
|
|
* The callback will be invoked multiple times,
|
|
* providing data in small chunks. The application
|
|
* should consume up 'nbytes' from the 'data' array
|
|
* of data and then return the number actual number
|
|
* of bytes consumed. The callback will continue to be
|
|
* invoked until it indicates the end of the stream
|
|
* has been reached. A return value of -1 at any time
|
|
* will abort the receive operation
|
|
*
|
|
* Returns the number of bytes consumed or -1 upon
|
|
* error
|
|
*/
|
|
typedef int (*virStreamSinkFunc)(virStreamPtr st,
|
|
const char *data,
|
|
size_t nbytes,
|
|
void *opaque);
|
|
|
|
int virStreamRecvAll(virStreamPtr st,
|
|
virStreamSinkFunc handler,
|
|
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;
|
|
|
|
|
|
/**
|
|
* virStreamEventCallback:
|
|
*
|
|
* @stream: stream on which the event occurred
|
|
* @events: bitset of events from virEventHandleType constants
|
|
* @opaque: user data registered with handle
|
|
*
|
|
* Callback for receiving stream events. The callback will
|
|
* be invoked once for each event which is pending.
|
|
*/
|
|
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);
|
|
|
|
|
|
int virDomainIsActive(virDomainPtr dom);
|
|
int virDomainIsPersistent(virDomainPtr dom);
|
|
int virDomainIsUpdated(virDomainPtr dom);
|
|
|
|
int virNetworkIsActive(virNetworkPtr net);
|
|
int virNetworkIsPersistent(virNetworkPtr net);
|
|
|
|
int virStoragePoolIsActive(virStoragePoolPtr pool);
|
|
int virStoragePoolIsPersistent(virStoragePoolPtr pool);
|
|
|
|
int virInterfaceIsActive(virInterfacePtr iface);
|
|
|
|
int virConnectIsEncrypted(virConnectPtr conn);
|
|
int virConnectIsSecure(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
|
|
} virCPUCompareResult;
|
|
|
|
/**
|
|
* virConnectCompareCPU:
|
|
*
|
|
* @conn: virConnect connection
|
|
* @xmlDesc: XML description of either guest or host cpu with <cpu> root tag
|
|
* @flags: comparison flags
|
|
*
|
|
* Compares given CPU with host cpu.
|
|
*
|
|
* Returns virCPUCompareResult.
|
|
*/
|
|
int virConnectCompareCPU(virConnectPtr conn,
|
|
const char *xmlDesc,
|
|
unsigned int flags);
|
|
|
|
|
|
/**
|
|
* virConnectBaselineCPU:
|
|
*
|
|
* @conn: virConnect connection
|
|
* @ncpus: number of CPUs in xmlCPUs
|
|
* @xmlCPUs: array of XML descriptions of host CPUs
|
|
* @flags: fine-tuning flags
|
|
*
|
|
* Computes the most feature-rich CPU which is compatible with all given
|
|
* host CPUs.
|
|
*
|
|
* Returns XML description of the computed CPU or NULL on error.
|
|
*/
|
|
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 */
|
|
} virDomainJobType;
|
|
|
|
typedef struct _virDomainJobInfo virDomainJobInfo;
|
|
typedef virDomainJobInfo *virDomainJobInfoPtr;
|
|
struct _virDomainJobInfo {
|
|
/* One of virDomainJobType */
|
|
int type;
|
|
|
|
/* Time is measured in mill-seconds */
|
|
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 eg due to dirtied pages during migration
|
|
*
|
|
* For VIR_DOMAIN_JOB_BOUNDED, dataTotal shall always
|
|
* equal 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;
|
|
};
|
|
|
|
int virDomainGetJobInfo(virDomainPtr dom,
|
|
virDomainJobInfoPtr info);
|
|
int virDomainAbortJob(virDomainPtr dom);
|
|
|
|
/**
|
|
* virDomainSnapshot:
|
|
*
|
|
* a virDomainSnapshot is a private structure representing a snapshot of
|
|
* a domain.
|
|
*/
|
|
typedef struct _virDomainSnapshot virDomainSnapshot;
|
|
|
|
/**
|
|
* virDomainSnapshotPtr:
|
|
*
|
|
* a virDomainSnapshotPtr is pointer to a virDomainSnapshot private structure,
|
|
* and is the type used to reference a domain snapshot in the API.
|
|
*/
|
|
typedef virDomainSnapshot *virDomainSnapshotPtr;
|
|
|
|
/* Take a snapshot of the current VM state */
|
|
virDomainSnapshotPtr virDomainSnapshotCreateXML(virDomainPtr domain,
|
|
const char *xmlDesc,
|
|
unsigned int flags);
|
|
|
|
/* Dump the XML of a snapshot */
|
|
char *virDomainSnapshotGetXMLDesc(virDomainSnapshotPtr snapshot,
|
|
unsigned int flags);
|
|
|
|
/* Return the number of snapshots for this domain */
|
|
int virDomainSnapshotNum(virDomainPtr domain, unsigned int flags);
|
|
|
|
/* Get the names of all snapshots for this domain */
|
|
int virDomainSnapshotListNames(virDomainPtr domain, char **names, int nameslen,
|
|
unsigned int flags);
|
|
|
|
/* Get a handle to a named snapshot */
|
|
virDomainSnapshotPtr virDomainSnapshotLookupByName(virDomainPtr domain,
|
|
const char *name,
|
|
unsigned int flags);
|
|
|
|
/* Check whether a domain has a snapshot which is currently used */
|
|
int virDomainHasCurrentSnapshot(virDomainPtr domain, unsigned flags);
|
|
|
|
/* Get a handle to the current snapshot */
|
|
virDomainSnapshotPtr virDomainSnapshotCurrent(virDomainPtr domain,
|
|
unsigned int flags);
|
|
|
|
/* Revert the domain to a point-in-time snapshot. The
|
|
* state of the guest after this call will be the state
|
|
* of the guest when the snapshot in question was taken
|
|
*/
|
|
int virDomainRevertToSnapshot(virDomainSnapshotPtr snapshot,
|
|
unsigned int flags);
|
|
|
|
/* Delete a snapshot */
|
|
typedef enum {
|
|
VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN = (1 << 0),
|
|
} virDomainSnapshotDeleteFlags;
|
|
|
|
int virDomainSnapshotDelete(virDomainSnapshotPtr snapshot,
|
|
unsigned int flags);
|
|
|
|
int virDomainSnapshotFree(virDomainSnapshotPtr snapshot);
|
|
|
|
/*
|
|
* virConnectDomainEventGenericCallback:
|
|
* @conn: the connection pointer
|
|
* @dom: the domain pointer
|
|
* @opaque: application specified data
|
|
*
|
|
* A generic domain event callback handler. Specific events usually
|
|
* have a customization with extra parameters
|
|
*/
|
|
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 forcably powered off */
|
|
VIR_DOMAIN_EVENT_WATCHDOG_SHUTDOWN, /* Guest is requested to gracefully shutdown */
|
|
VIR_DOMAIN_EVENT_WATCHDOG_DEBUG, /* No action, a debug message logged */
|
|
} 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 occuring
|
|
*/
|
|
typedef enum {
|
|
VIR_DOMAIN_EVENT_IO_ERROR_NONE = 0, /* No action, IO error ignored */
|
|
VIR_DOMAIN_EVENT_IO_ERROR_PAUSE, /* Guest CPUs are pausde */
|
|
VIR_DOMAIN_EVENT_IO_ERROR_REPORT, /* IO error reported to guest OS */
|
|
} 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 with virConnectDomainEventRegisterAny()
|
|
*
|
|
*/
|
|
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 */
|
|
} 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 */
|
|
} virDomainEventGraphicsAddressType;
|
|
|
|
|
|
/**
|
|
* virDomainEventGraphicsAddress:
|
|
*
|
|
* The data structure containing connection address details
|
|
*
|
|
*/
|
|
struct _virDomainEventGraphicsAddress {
|
|
int family; /* Address family, virDomainEventGraphicsAddressType */
|
|
const char *node; /* Address of node (eg IP address) */
|
|
const char *service; /* Service name/number (eg TCP port) */
|
|
};
|
|
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 {
|
|
const char *type; /* Type of identity */
|
|
const 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,
|
|
virDomainEventGraphicsAddressPtr local,
|
|
virDomainEventGraphicsAddressPtr remote,
|
|
const char *authScheme,
|
|
virDomainEventGraphicsSubjectPtr subject,
|
|
void *opaque);
|
|
|
|
/**
|
|
* VIR_DOMAIN_EVENT_CALLBACK:
|
|
*
|
|
* Used to cast the event specific callback into the generic one
|
|
* for use for virDomainEventRegister
|
|
*/
|
|
#define VIR_DOMAIN_EVENT_CALLBACK(cb) ((virConnectDomainEventGenericCallback)(cb))
|
|
|
|
|
|
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 */
|
|
|
|
/*
|
|
* 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.
|
|
*/
|
|
VIR_DOMAIN_EVENT_ID_LAST
|
|
} 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);
|
|
|
|
|
|
/**
|
|
* virNWFilter:
|
|
*
|
|
* a virNWFilter is a private structure representing a network filter
|
|
*/
|
|
typedef struct _virNWFilter virNWFilter;
|
|
|
|
/**
|
|
* virNWFilterPtr:
|
|
*
|
|
* a virNWFilterPtr is pointer to a virNWFilter private structure,
|
|
* this is the type used to reference a network filter in the API.
|
|
*/
|
|
typedef virNWFilter *virNWFilterPtr;
|
|
|
|
|
|
/*
|
|
* List NWFilters
|
|
*/
|
|
int virConnectNumOfNWFilters (virConnectPtr conn);
|
|
int virConnectListNWFilters (virConnectPtr conn,
|
|
char **const names,
|
|
int maxnames);
|
|
|
|
/*
|
|
* Lookup nwfilter by name or uuid
|
|
*/
|
|
virNWFilterPtr virNWFilterLookupByName (virConnectPtr conn,
|
|
const char *name);
|
|
virNWFilterPtr virNWFilterLookupByUUID (virConnectPtr conn,
|
|
const unsigned char *uuid);
|
|
virNWFilterPtr virNWFilterLookupByUUIDString (virConnectPtr conn,
|
|
const char *uuid);
|
|
|
|
/*
|
|
* Define persistent nwfilter
|
|
*/
|
|
virNWFilterPtr virNWFilterDefineXML (virConnectPtr conn,
|
|
const char *xmlDesc);
|
|
|
|
/*
|
|
* Delete persistent nwfilter
|
|
*/
|
|
int virNWFilterUndefine (virNWFilterPtr nwfilter);
|
|
|
|
/*
|
|
* NWFilter destroy/free
|
|
*/
|
|
int virNWFilterRef (virNWFilterPtr nwfilter);
|
|
int virNWFilterFree (virNWFilterPtr nwfilter);
|
|
|
|
/*
|
|
* NWFilter information
|
|
*/
|
|
const char* virNWFilterGetName (virNWFilterPtr nwfilter);
|
|
int virNWFilterGetUUID (virNWFilterPtr nwfilter,
|
|
unsigned char *uuid);
|
|
int virNWFilterGetUUIDString (virNWFilterPtr nwfilter,
|
|
char *buf);
|
|
char * virNWFilterGetXMLDesc (virNWFilterPtr nwfilter,
|
|
int flags);
|
|
|
|
|
|
int virDomainOpenConsole(virDomainPtr dom,
|
|
const char *devname,
|
|
virStreamPtr st,
|
|
unsigned int flags);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* __VIR_VIRLIB_H__ */
|