![]() |
![]() |
![]() |
libvirt Reference Manual |
---|
libvirt - core interfaces for the libvirt library
Provides the interfaces of the libvirt library to handle virtualized domains
Author(s): Daniel Veillard <veillard@redhat.com>
#define LIBVIR_VERSION_NUMBER; #define VIR_COPY_CPUMAP(cpumaps, maplen, vcpu, cpumap); #define VIR_CPU_MAPLEN(cpu); #define VIR_CPU_USABLE(cpumaps, maplen, vcpu, cpu); #define VIR_DOMAIN_BLKIO_FIELD_LENGTH; #define VIR_DOMAIN_BLKIO_WEIGHT; #define VIR_DOMAIN_BLOCK_STATS_ERRS; #define VIR_DOMAIN_BLOCK_STATS_FIELD_LENGTH; #define VIR_DOMAIN_BLOCK_STATS_FLUSH_REQ; #define VIR_DOMAIN_BLOCK_STATS_FLUSH_TOTAL_TIMES; #define VIR_DOMAIN_BLOCK_STATS_READ_BYTES; #define VIR_DOMAIN_BLOCK_STATS_READ_REQ; #define VIR_DOMAIN_BLOCK_STATS_READ_TOTAL_TIMES; #define VIR_DOMAIN_BLOCK_STATS_WRITE_BYTES; #define VIR_DOMAIN_BLOCK_STATS_WRITE_REQ; #define VIR_DOMAIN_BLOCK_STATS_WRITE_TOTAL_TIMES; #define VIR_DOMAIN_EVENT_CALLBACK; #define VIR_DOMAIN_MEMORY_FIELD_LENGTH; #define VIR_DOMAIN_MEMORY_HARD_LIMIT; #define VIR_DOMAIN_MEMORY_MIN_GUARANTEE; #define VIR_DOMAIN_MEMORY_PARAM_UNLIMITED; #define VIR_DOMAIN_MEMORY_SOFT_LIMIT; #define VIR_DOMAIN_MEMORY_SWAP_HARD_LIMIT; #define VIR_DOMAIN_SCHED_FIELD_LENGTH; #define VIR_DOMAIN_SEND_KEY_MAX_KEYS; #define VIR_GET_CPUMAP(cpumaps, maplen, vcpu); #define VIR_NODEINFO_MAXCPUS(nodeinfo); #define VIR_NODE_CPU_STATS_ALL_CPUS; #define VIR_NODE_CPU_STATS_FIELD_LENGTH; #define VIR_NODE_CPU_STATS_IDLE; #define VIR_NODE_CPU_STATS_IOWAIT; #define VIR_NODE_CPU_STATS_KERNEL; #define VIR_NODE_CPU_STATS_USER; #define VIR_NODE_CPU_STATS_UTILIZATION; #define VIR_NODE_MEMORY_STATS_ALL_CELLS; #define VIR_NODE_MEMORY_STATS_BUFFERS; #define VIR_NODE_MEMORY_STATS_CACHED; #define VIR_NODE_MEMORY_STATS_FIELD_LENGTH; #define VIR_NODE_MEMORY_STATS_FREE; #define VIR_NODE_MEMORY_STATS_TOTAL; #define VIR_SECURITY_DOI_BUFLEN; #define VIR_SECURITY_LABEL_BUFLEN; #define VIR_SECURITY_MODEL_BUFLEN; #define VIR_TYPED_PARAM_FIELD_LENGTH; #define VIR_UNUSE_CPU(cpumap, cpu); #define VIR_USE_CPU(cpumap, cpu); #define VIR_UUID_BUFLEN; #define VIR_UUID_STRING_BUFLEN; #define _virBlkioParameter; #define _virMemoryParameter; #define _virSchedParameter; typedef struct _virTypedParameter virBlkioParameter; typedef virBlkioParameter * virBlkioParameterPtr; typedef enum virBlkioParameterType; typedef enum virCPUCompareResult; typedef struct _virConnect virConnect; typedef struct _virConnectAuth virConnectAuth; typedef virConnectAuth * virConnectAuthPtr; typedef struct _virConnectCredential virConnectCredential; typedef virConnectCredential * virConnectCredentialPtr; typedef enum virConnectCredentialType; typedef enum virConnectDomainEventBlockJobStatus; typedef enum virConnectFlags; typedef virConnect * virConnectPtr; typedef struct _virDomain virDomain; typedef struct _virDomainBlockInfo virDomainBlockInfo; typedef virDomainBlockInfo * virDomainBlockInfoPtr; typedef unsigned long long virDomainBlockJobCursor; typedef struct _virDomainBlockJobInfo virDomainBlockJobInfo; typedef virDomainBlockJobInfo * virDomainBlockJobInfoPtr; typedef enum virDomainBlockJobType; typedef virDomainBlockStatsStruct * virDomainBlockStatsPtr; typedef struct _virDomainBlockStats virDomainBlockStatsStruct; typedef enum virDomainBlockedReason; typedef struct _virDomainControlInfo virDomainControlInfo; typedef virDomainControlInfo * virDomainControlInfoPtr; typedef enum virDomainControlState; typedef enum virDomainCoreDumpFlags; typedef enum virDomainCrashedReason; typedef enum virDomainCreateFlags; typedef enum virDomainDeviceModifyFlags; typedef enum virDomainEventDefinedDetailType; typedef struct _virDomainEventGraphicsAddress virDomainEventGraphicsAddress; typedef virDomainEventGraphicsAddress * virDomainEventGraphicsAddressPtr; typedef enum virDomainEventGraphicsAddressType; typedef enum virDomainEventGraphicsPhase; typedef struct _virDomainEventGraphicsSubject virDomainEventGraphicsSubject; typedef struct _virDomainEventGraphicsSubjectIdentity virDomainEventGraphicsSubjectIdentity; typedef virDomainEventGraphicsSubjectIdentity * virDomainEventGraphicsSubjectIdentityPtr; typedef virDomainEventGraphicsSubject * virDomainEventGraphicsSubjectPtr; typedef enum virDomainEventID; typedef enum virDomainEventIOErrorAction; typedef enum virDomainEventResumedDetailType; typedef enum virDomainEventStartedDetailType; typedef enum virDomainEventStoppedDetailType; typedef enum virDomainEventSuspendedDetailType; typedef enum virDomainEventType; typedef enum virDomainEventUndefinedDetailType; typedef enum virDomainEventWatchdogAction; typedef struct _virDomainInfo virDomainInfo; typedef virDomainInfo * virDomainInfoPtr; typedef virDomainInterfaceStatsStruct * virDomainInterfaceStatsPtr; typedef struct _virDomainInterfaceStats virDomainInterfaceStatsStruct; typedef struct _virDomainJobInfo virDomainJobInfo; typedef virDomainJobInfo * virDomainJobInfoPtr; typedef enum virDomainJobType; typedef enum virDomainMemoryFlags; typedef enum virDomainMemoryModFlags; typedef virDomainMemoryStatStruct * virDomainMemoryStatPtr; typedef struct _virDomainMemoryStat virDomainMemoryStatStruct; typedef enum virDomainMemoryStatTags; typedef enum virDomainMigrateFlags; typedef enum virDomainModificationImpact; typedef enum virDomainNostateReason; typedef enum virDomainPausedReason; typedef virDomain * virDomainPtr; typedef enum virDomainRunningReason; typedef enum virDomainSaveRestoreFlags; typedef enum virDomainShutdownReason; typedef enum virDomainShutoffReason; typedef struct _virDomainSnapshot virDomainSnapshot; typedef enum virDomainSnapshotCreateFlags; typedef enum virDomainSnapshotDeleteFlags; typedef enum virDomainSnapshotListFlags; typedef virDomainSnapshot * virDomainSnapshotPtr; typedef enum virDomainSnapshotRevertFlags; typedef enum virDomainState; typedef enum virDomainUndefineFlagsValues; typedef enum virDomainVcpuFlags; typedef enum virDomainXMLFlags; typedef enum virEventHandleType; typedef struct _virInterface virInterface; typedef virInterface * virInterfacePtr; typedef enum virInterfaceXMLFlags; typedef enum virKeycodeSet; typedef struct _virTypedParameter virMemoryParameter; typedef virMemoryParameter * virMemoryParameterPtr; typedef enum virMemoryParameterType; typedef struct _virNWFilter virNWFilter; typedef virNWFilter * virNWFilterPtr; typedef struct _virNetwork virNetwork; typedef virNetwork * virNetworkPtr; typedef struct _virNodeCPUStats virNodeCPUStats; typedef virNodeCPUStats * virNodeCPUStatsPtr; typedef struct _virNodeDevice virNodeDevice; typedef virNodeDevice * virNodeDevicePtr; typedef struct _virNodeInfo virNodeInfo; typedef virNodeInfo * virNodeInfoPtr; typedef struct _virNodeMemoryStats virNodeMemoryStats; typedef virNodeMemoryStats * virNodeMemoryStatsPtr; typedef struct _virTypedParameter virSchedParameter; typedef virSchedParameter * virSchedParameterPtr; typedef enum virSchedParameterType; typedef struct _virSecret virSecret; typedef virSecret * virSecretPtr; typedef enum virSecretUsageType; typedef struct _virSecurityLabel virSecurityLabel; typedef virSecurityLabel * virSecurityLabelPtr; typedef struct _virSecurityModel virSecurityModel; typedef virSecurityModel * virSecurityModelPtr; typedef struct _virStoragePool virStoragePool; typedef enum virStoragePoolBuildFlags; typedef enum virStoragePoolDeleteFlags; typedef struct _virStoragePoolInfo virStoragePoolInfo; typedef virStoragePoolInfo * virStoragePoolInfoPtr; typedef virStoragePool * virStoragePoolPtr; typedef enum virStoragePoolState; typedef struct _virStorageVol virStorageVol; typedef enum virStorageVolDeleteFlags; typedef struct _virStorageVolInfo virStorageVolInfo; typedef virStorageVolInfo * virStorageVolInfoPtr; typedef virStorageVol * virStorageVolPtr; typedef enum virStorageVolType; typedef struct _virStream virStream; typedef enum virStreamEventType; typedef enum virStreamFlags; typedef virStream * virStreamPtr; typedef struct _virTypedParameter virTypedParameter; typedef virTypedParameter * virTypedParameterPtr; typedef enum virTypedParameterType; typedef struct _virVcpuInfo virVcpuInfo; typedef virVcpuInfo * virVcpuInfoPtr; typedef enum virVcpuState; typedef int virConnectAuthCallbackPtr (virConnectCredentialPtr cred,
unsigned int ncred,
void * cbdata); char * virConnectBaselineCPU (virConnectPtr conn,
const char ** xmlCPUs,
unsigned int ncpus,
unsigned int flags); int virConnectClose (virConnectPtr conn); int virConnectCompareCPU (virConnectPtr conn,
const char * xmlDesc,
unsigned int flags); typedef void virConnectDomainEventBlockJobCallback (virConnectPtr conn,
virDomainPtr dom,
const char * path,
int type,
int status,
void * opaque); typedef int virConnectDomainEventCallback (virConnectPtr conn,
virDomainPtr dom,
int event,
int detail,
void * opaque); int virConnectDomainEventDeregister (virConnectPtr conn,
virConnectDomainEventCallback cb); int virConnectDomainEventDeregisterAny (virConnectPtr conn,
int callbackID); typedef void virConnectDomainEventGenericCallback (virConnectPtr conn,
virDomainPtr dom,
void * opaque); typedef void virConnectDomainEventGraphicsCallback (virConnectPtr conn,
virDomainPtr dom,
int phase,
virDomainEventGraphicsAddressPtr local,
virDomainEventGraphicsAddressPtr remote,
const char * authScheme,
virDomainEventGraphicsSubjectPtr subject,
void * opaque); 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 void virConnectDomainEventRTCChangeCallback (virConnectPtr conn,
virDomainPtr dom,
long long utcoffset,
void * opaque); int virConnectDomainEventRegister (virConnectPtr conn,
virConnectDomainEventCallback cb,
void * opaque,
virFreeCallback freecb); int virConnectDomainEventRegisterAny (virConnectPtr conn,
virDomainPtr dom,
int eventID,
virConnectDomainEventGenericCallback cb,
void * opaque,
virFreeCallback freecb); typedef void virConnectDomainEventWatchdogCallback (virConnectPtr conn,
virDomainPtr dom,
int action,
void * opaque); 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); char * virConnectFindStoragePoolSources (virConnectPtr conn,
const char * type,
const char * srcSpec,
unsigned int flags); char * virConnectGetCapabilities (virConnectPtr conn); char * virConnectGetHostname (virConnectPtr conn); int virConnectGetLibVersion (virConnectPtr conn,
unsigned long * libVer); int virConnectGetMaxVcpus (virConnectPtr conn,
const char * type); char * virConnectGetSysinfo (virConnectPtr conn,
unsigned int flags); const char * virConnectGetType (virConnectPtr conn); char * virConnectGetURI (virConnectPtr conn); int virConnectGetVersion (virConnectPtr conn,
unsigned long * hvVer); int virConnectIsEncrypted (virConnectPtr conn); int virConnectIsSecure (virConnectPtr conn); int virConnectListDefinedDomains (virConnectPtr conn,
char ** const names,
int maxnames); int virConnectListDefinedInterfaces (virConnectPtr conn,
char ** const names,
int maxnames); int virConnectListDefinedNetworks (virConnectPtr conn,
char ** const names,
int maxnames); int virConnectListDefinedStoragePools (virConnectPtr conn,
char ** const names,
int maxnames); int virConnectListDomains (virConnectPtr conn,
int * ids,
int maxids); int virConnectListInterfaces (virConnectPtr conn,
char ** const names,
int maxnames); int virConnectListNWFilters (virConnectPtr conn,
char ** const names,
int maxnames); int virConnectListNetworks (virConnectPtr conn,
char ** const names,
int maxnames); int virConnectListSecrets (virConnectPtr conn,
char ** uuids,
int maxuuids); int virConnectListStoragePools (virConnectPtr conn,
char ** const names,
int maxnames); int virConnectNumOfDefinedDomains (virConnectPtr conn); int virConnectNumOfDefinedInterfaces (virConnectPtr conn); int virConnectNumOfDefinedNetworks (virConnectPtr conn); int virConnectNumOfDefinedStoragePools (virConnectPtr conn); int virConnectNumOfDomains (virConnectPtr conn); int virConnectNumOfInterfaces (virConnectPtr conn); int virConnectNumOfNWFilters (virConnectPtr conn); int virConnectNumOfNetworks (virConnectPtr conn); int virConnectNumOfSecrets (virConnectPtr conn); int virConnectNumOfStoragePools (virConnectPtr conn); virConnectPtr virConnectOpen (const char * name); virConnectPtr virConnectOpenAuth (const char * name,
virConnectAuthPtr auth,
unsigned int flags); virConnectPtr virConnectOpenReadOnly (const char * name); int virConnectRef (virConnectPtr conn); int virDomainAbortJob (virDomainPtr domain); int virDomainAttachDevice (virDomainPtr domain,
const char * xml); int virDomainAttachDeviceFlags (virDomainPtr domain,
const char * xml,
unsigned int flags); int virDomainBlockJobAbort (virDomainPtr dom,
const char * path,
unsigned int flags); int virDomainBlockJobSetSpeed (virDomainPtr dom,
const char * path,
unsigned long bandwidth,
unsigned int flags); int virDomainBlockPeek (virDomainPtr dom,
const char * path,
unsigned long long offset,
size_t size,
void * buffer,
unsigned int flags); int virDomainBlockPull (virDomainPtr dom,
const char * path,
unsigned long bandwidth,
unsigned int flags); int virDomainBlockStats (virDomainPtr dom,
const char * path,
virDomainBlockStatsPtr stats,
size_t size); int virDomainBlockStatsFlags (virDomainPtr dom,
const char * path,
virTypedParameterPtr params,
int * nparams,
unsigned int flags); int virDomainCoreDump (virDomainPtr domain,
const char * to,
unsigned int flags); int virDomainCreate (virDomainPtr domain); virDomainPtr virDomainCreateLinux (virConnectPtr conn,
const char * xmlDesc,
unsigned int flags); int virDomainCreateWithFlags (virDomainPtr domain,
unsigned int flags); virDomainPtr virDomainCreateXML (virConnectPtr conn,
const char * xmlDesc,
unsigned int flags); virDomainPtr virDomainDefineXML (virConnectPtr conn,
const char * xml); int virDomainDestroy (virDomainPtr domain); int virDomainDestroyFlags (virDomainPtr domain,
unsigned int flags); int virDomainDetachDevice (virDomainPtr domain,
const char * xml); int virDomainDetachDeviceFlags (virDomainPtr domain,
const char * xml,
unsigned int flags); int virDomainFree (virDomainPtr domain); int virDomainGetAutostart (virDomainPtr domain,
int * autostart); int virDomainGetBlkioParameters (virDomainPtr domain,
virTypedParameterPtr params,
int * nparams,
unsigned int flags); int virDomainGetBlockInfo (virDomainPtr domain,
const char * path,
virDomainBlockInfoPtr info,
unsigned int flags); int virDomainGetBlockJobInfo (virDomainPtr dom,
const char * path,
virDomainBlockJobInfoPtr info,
unsigned int flags); virConnectPtr virDomainGetConnect (virDomainPtr dom); int virDomainGetControlInfo (virDomainPtr domain,
virDomainControlInfoPtr info,
unsigned int flags); unsigned int virDomainGetID (virDomainPtr domain); int virDomainGetInfo (virDomainPtr domain,
virDomainInfoPtr info); int virDomainGetJobInfo (virDomainPtr domain,
virDomainJobInfoPtr info); unsigned long virDomainGetMaxMemory (virDomainPtr domain); int virDomainGetMaxVcpus (virDomainPtr domain); int virDomainGetMemoryParameters (virDomainPtr domain,
virTypedParameterPtr params,
int * nparams,
unsigned int flags); const char * virDomainGetName (virDomainPtr domain); char * virDomainGetOSType (virDomainPtr domain); int virDomainGetSchedulerParameters (virDomainPtr domain,
virTypedParameterPtr params,
int * nparams); int virDomainGetSchedulerParametersFlags (virDomainPtr domain,
virTypedParameterPtr params,
int * nparams,
unsigned int flags); char * virDomainGetSchedulerType (virDomainPtr domain,
int * nparams); int virDomainGetSecurityLabel (virDomainPtr domain,
virSecurityLabelPtr seclabel); int virDomainGetState (virDomainPtr domain,
int * state,
int * reason,
unsigned int flags); int virDomainGetUUID (virDomainPtr domain,
unsigned char * uuid); int virDomainGetUUIDString (virDomainPtr domain,
char * buf); int virDomainGetVcpuPinInfo (virDomainPtr domain,
int ncpumaps,
unsigned char * cpumaps,
int maplen,
unsigned int flags); int virDomainGetVcpus (virDomainPtr domain,
virVcpuInfoPtr info,
int maxinfo,
unsigned char * cpumaps,
int maplen); int virDomainGetVcpusFlags (virDomainPtr domain,
unsigned int flags); char * virDomainGetXMLDesc (virDomainPtr domain,
unsigned int flags); int virDomainHasCurrentSnapshot (virDomainPtr domain,
unsigned int flags); int virDomainHasManagedSaveImage (virDomainPtr dom,
unsigned int flags); int virDomainInjectNMI (virDomainPtr domain,
unsigned int flags); int virDomainInterfaceStats (virDomainPtr dom,
const char * path,
virDomainInterfaceStatsPtr stats,
size_t size); int virDomainIsActive (virDomainPtr dom); int virDomainIsPersistent (virDomainPtr dom); int virDomainIsUpdated (virDomainPtr dom); virDomainPtr virDomainLookupByID (virConnectPtr conn,
int id); virDomainPtr virDomainLookupByName (virConnectPtr conn,
const char * name); virDomainPtr virDomainLookupByUUID (virConnectPtr conn,
const unsigned char * uuid); virDomainPtr virDomainLookupByUUIDString (virConnectPtr conn,
const char * uuidstr); int virDomainManagedSave (virDomainPtr dom,
unsigned int flags); int virDomainManagedSaveRemove (virDomainPtr dom,
unsigned int flags); int virDomainMemoryPeek (virDomainPtr dom,
unsigned long long start,
size_t size,
void * buffer,
unsigned int flags); int virDomainMemoryStats (virDomainPtr dom,
virDomainMemoryStatPtr stats,
unsigned int nr_stats,
unsigned int flags); 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); int virDomainMigrateGetMaxSpeed (virDomainPtr domain,
unsigned long * bandwidth,
unsigned int flags); int virDomainMigrateSetMaxDowntime (virDomainPtr domain,
unsigned long long downtime,
unsigned int flags); int virDomainMigrateSetMaxSpeed (virDomainPtr domain,
unsigned long bandwidth,
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 virDomainOpenConsole (virDomainPtr dom,
const char * dev_name,
virStreamPtr st,
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 virDomainReboot (virDomainPtr domain,
unsigned int flags); int virDomainRef (virDomainPtr domain); int virDomainRestore (virConnectPtr conn,
const char * from); int virDomainRestoreFlags (virConnectPtr conn,
const char * from,
const char * dxml,
unsigned int flags); int virDomainResume (virDomainPtr domain); int virDomainRevertToSnapshot (virDomainSnapshotPtr snapshot,
unsigned int flags); int virDomainSave (virDomainPtr domain,
const char * to); int virDomainSaveFlags (virDomainPtr domain,
const char * to,
const char * dxml,
unsigned int flags); int virDomainSaveImageDefineXML (virConnectPtr conn,
const char * file,
const char * dxml,
unsigned int flags); char * virDomainSaveImageGetXMLDesc (virConnectPtr conn,
const char * file,
unsigned int flags); char * virDomainScreenshot (virDomainPtr domain,
virStreamPtr stream,
unsigned int screen,
unsigned int flags); int virDomainSendKey (virDomainPtr domain,
unsigned int codeset,
unsigned int holdtime,
unsigned int * keycodes,
int nkeycodes,
unsigned int flags); int virDomainSetAutostart (virDomainPtr domain,
int autostart); int virDomainSetBlkioParameters (virDomainPtr domain,
virTypedParameterPtr params,
int nparams,
unsigned int flags); 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 virDomainSetMemoryParameters (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); int virDomainSetVcpus (virDomainPtr domain,
unsigned int nvcpus); int virDomainSetVcpusFlags (virDomainPtr domain,
unsigned int nvcpus,
unsigned int flags); int virDomainShutdown (virDomainPtr domain); virDomainSnapshotPtr virDomainSnapshotCreateXML (virDomainPtr domain,
const char * xmlDesc,
unsigned int flags); virDomainSnapshotPtr virDomainSnapshotCurrent (virDomainPtr domain,
unsigned int flags); int virDomainSnapshotDelete (virDomainSnapshotPtr snapshot,
unsigned int flags); int virDomainSnapshotFree (virDomainSnapshotPtr snapshot); virConnectPtr virDomainSnapshotGetConnect (virDomainSnapshotPtr snapshot); virDomainPtr virDomainSnapshotGetDomain (virDomainSnapshotPtr snapshot); const char * virDomainSnapshotGetName (virDomainSnapshotPtr snapshot); char * virDomainSnapshotGetXMLDesc (virDomainSnapshotPtr snapshot,
unsigned int flags); int virDomainSnapshotListNames (virDomainPtr domain,
char ** names,
int nameslen,
unsigned int flags); virDomainSnapshotPtr virDomainSnapshotLookupByName (virDomainPtr domain,
const char * name,
unsigned int flags); int virDomainSnapshotNum (virDomainPtr domain,
unsigned int flags); int virDomainSuspend (virDomainPtr domain); int virDomainUndefine (virDomainPtr domain); int virDomainUndefineFlags (virDomainPtr domain,
unsigned int flags); int virDomainUpdateDeviceFlags (virDomainPtr domain,
const char * xml,
unsigned int flags); int virEventAddHandle (int fd,
int events,
virEventHandleCallback cb,
void * opaque,
virFreeCallback ff); typedef int virEventAddHandleFunc (int fd,
int event,
virEventHandleCallback cb,
void * opaque,
virFreeCallback ff); int virEventAddTimeout (int timeout,
virEventTimeoutCallback cb,
void * opaque,
virFreeCallback ff); typedef int virEventAddTimeoutFunc (int timeout,
virEventTimeoutCallback cb,
void * opaque,
virFreeCallback ff); typedef void virEventHandleCallback (int watch,
int fd,
int events,
void * opaque); int virEventRegisterDefaultImpl (void); void virEventRegisterImpl (virEventAddHandleFunc addHandle,
virEventUpdateHandleFunc updateHandle,
virEventRemoveHandleFunc removeHandle,
virEventAddTimeoutFunc addTimeout,
virEventUpdateTimeoutFunc updateTimeout,
virEventRemoveTimeoutFunc removeTimeout); int virEventRemoveHandle (int watch); typedef int virEventRemoveHandleFunc (int watch); int virEventRemoveTimeout (int timer); typedef int virEventRemoveTimeoutFunc (int timer); int virEventRunDefaultImpl (void); typedef void virEventTimeoutCallback (int timer,
void * opaque); void virEventUpdateHandle (int watch,
int events); typedef void virEventUpdateHandleFunc (int watch,
int event); void virEventUpdateTimeout (int timer,
int timeout); typedef void virEventUpdateTimeoutFunc (int timer,
int timeout); typedef void virFreeCallback (void * opaque); int virGetVersion (unsigned long * libVer,
const char * type,
unsigned long * typeVer); int virInitialize (void); int virInterfaceChangeBegin (virConnectPtr conn,
unsigned int flags); int virInterfaceChangeCommit (virConnectPtr conn,
unsigned int flags); int virInterfaceChangeRollback (virConnectPtr conn,
unsigned int flags); int virInterfaceCreate (virInterfacePtr iface,
unsigned int flags); virInterfacePtr virInterfaceDefineXML (virConnectPtr conn,
const char * xml,
unsigned int flags); int virInterfaceDestroy (virInterfacePtr iface,
unsigned int flags); int virInterfaceFree (virInterfacePtr iface); virConnectPtr virInterfaceGetConnect (virInterfacePtr iface); const char * virInterfaceGetMACString (virInterfacePtr iface); const char * virInterfaceGetName (virInterfacePtr iface); char * virInterfaceGetXMLDesc (virInterfacePtr iface,
unsigned int flags); int virInterfaceIsActive (virInterfacePtr iface); virInterfacePtr virInterfaceLookupByMACString (virConnectPtr conn,
const char * macstr); virInterfacePtr virInterfaceLookupByName (virConnectPtr conn,
const char * name); int virInterfaceRef (virInterfacePtr iface); int virInterfaceUndefine (virInterfacePtr iface); virNWFilterPtr virNWFilterDefineXML (virConnectPtr conn,
const char * xmlDesc); 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); virNWFilterPtr virNWFilterLookupByName (virConnectPtr conn,
const char * name); virNWFilterPtr virNWFilterLookupByUUID (virConnectPtr conn,
const unsigned char * uuid); virNWFilterPtr virNWFilterLookupByUUIDString (virConnectPtr conn,
const char * uuidstr); int virNWFilterRef (virNWFilterPtr nwfilter); int virNWFilterUndefine (virNWFilterPtr nwfilter); int virNetworkCreate (virNetworkPtr network); virNetworkPtr virNetworkCreateXML (virConnectPtr conn,
const char * xmlDesc); virNetworkPtr virNetworkDefineXML (virConnectPtr conn,
const char * xml); int virNetworkDestroy (virNetworkPtr network); int virNetworkFree (virNetworkPtr network); int virNetworkGetAutostart (virNetworkPtr network,
int * autostart); char * virNetworkGetBridgeName (virNetworkPtr network); virConnectPtr virNetworkGetConnect (virNetworkPtr net); 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); int virNetworkIsActive (virNetworkPtr net); int virNetworkIsPersistent (virNetworkPtr net); virNetworkPtr virNetworkLookupByName (virConnectPtr conn,
const char * name); virNetworkPtr virNetworkLookupByUUID (virConnectPtr conn,
const unsigned char * uuid); virNetworkPtr virNetworkLookupByUUIDString (virConnectPtr conn,
const char * uuidstr); int virNetworkRef (virNetworkPtr network); int virNetworkSetAutostart (virNetworkPtr network,
int autostart); int virNetworkUndefine (virNetworkPtr network); virNodeDevicePtr virNodeDeviceCreateXML (virConnectPtr conn,
const char * xmlDesc,
unsigned int flags); int virNodeDeviceDestroy (virNodeDevicePtr dev); int virNodeDeviceDettach (virNodeDevicePtr dev); int virNodeDeviceFree (virNodeDevicePtr dev); const char * virNodeDeviceGetName (virNodeDevicePtr dev); const char * virNodeDeviceGetParent (virNodeDevicePtr dev); char * virNodeDeviceGetXMLDesc (virNodeDevicePtr dev,
unsigned int flags); int virNodeDeviceListCaps (virNodeDevicePtr dev,
char ** const names,
int maxnames); virNodeDevicePtr virNodeDeviceLookupByName (virConnectPtr conn,
const char * name); int virNodeDeviceNumOfCaps (virNodeDevicePtr dev); int virNodeDeviceReAttach (virNodeDevicePtr dev); int virNodeDeviceRef (virNodeDevicePtr dev); int virNodeDeviceReset (virNodeDevicePtr dev); int virNodeGetCPUStats (virConnectPtr conn,
int cpuNum,
virNodeCPUStatsPtr params,
int * nparams,
unsigned int flags); int virNodeGetCellsFreeMemory (virConnectPtr conn,
unsigned long long * freeMems,
int startCell,
int maxCells); unsigned long long virNodeGetFreeMemory (virConnectPtr conn); int virNodeGetInfo (virConnectPtr conn,
virNodeInfoPtr info); int virNodeGetMemoryStats (virConnectPtr conn,
int cellNum,
virNodeMemoryStatsPtr params,
int * nparams,
unsigned int flags); int virNodeGetSecurityModel (virConnectPtr conn,
virSecurityModelPtr secmodel); int virNodeListDevices (virConnectPtr conn,
const char * cap,
char ** const names,
int maxnames,
unsigned int flags); int virNodeNumOfDevices (virConnectPtr conn,
const char * cap,
unsigned int flags); virSecretPtr virSecretDefineXML (virConnectPtr conn,
const char * xml,
unsigned int flags); int virSecretFree (virSecretPtr secret); virConnectPtr virSecretGetConnect (virSecretPtr secret); int virSecretGetUUID (virSecretPtr secret,
unsigned char * uuid); int virSecretGetUUIDString (virSecretPtr secret,
char * buf); const char * virSecretGetUsageID (virSecretPtr secret); int virSecretGetUsageType (virSecretPtr secret); unsigned char * virSecretGetValue (virSecretPtr secret,
size_t * value_size,
unsigned int flags); char * virSecretGetXMLDesc (virSecretPtr secret,
unsigned int flags); virSecretPtr virSecretLookupByUUID (virConnectPtr conn,
const unsigned char * uuid); virSecretPtr virSecretLookupByUUIDString (virConnectPtr conn,
const char * uuidstr); virSecretPtr virSecretLookupByUsage (virConnectPtr conn,
int usageType,
const char * usageID); int virSecretRef (virSecretPtr secret); int virSecretSetValue (virSecretPtr secret,
const unsigned char * value,
size_t value_size,
unsigned int flags); int virSecretUndefine (virSecretPtr secret); int virStoragePoolBuild (virStoragePoolPtr pool,
unsigned int flags); int virStoragePoolCreate (virStoragePoolPtr pool,
unsigned int flags); virStoragePoolPtr virStoragePoolCreateXML (virConnectPtr conn,
const char * xmlDesc,
unsigned int flags); virStoragePoolPtr virStoragePoolDefineXML (virConnectPtr conn,
const char * xml,
unsigned int flags); int virStoragePoolDelete (virStoragePoolPtr pool,
unsigned int flags); int virStoragePoolDestroy (virStoragePoolPtr pool); int virStoragePoolFree (virStoragePoolPtr pool); int virStoragePoolGetAutostart (virStoragePoolPtr pool,
int * autostart); virConnectPtr virStoragePoolGetConnect (virStoragePoolPtr pool); int virStoragePoolGetInfo (virStoragePoolPtr pool,
virStoragePoolInfoPtr info); const char * virStoragePoolGetName (virStoragePoolPtr pool); int virStoragePoolGetUUID (virStoragePoolPtr pool,
unsigned char * uuid); int virStoragePoolGetUUIDString (virStoragePoolPtr pool,
char * buf); char * virStoragePoolGetXMLDesc (virStoragePoolPtr pool,
unsigned int flags); int virStoragePoolIsActive (virStoragePoolPtr pool); int virStoragePoolIsPersistent (virStoragePoolPtr pool); int virStoragePoolListVolumes (virStoragePoolPtr pool,
char ** const names,
int maxnames); virStoragePoolPtr virStoragePoolLookupByName (virConnectPtr conn,
const char * name); virStoragePoolPtr virStoragePoolLookupByUUID (virConnectPtr conn,
const unsigned char * uuid); virStoragePoolPtr virStoragePoolLookupByUUIDString (virConnectPtr conn,
const char * uuidstr); virStoragePoolPtr virStoragePoolLookupByVolume (virStorageVolPtr vol); int virStoragePoolNumOfVolumes (virStoragePoolPtr pool); int virStoragePoolRef (virStoragePoolPtr pool); int virStoragePoolRefresh (virStoragePoolPtr pool,
unsigned int flags); int virStoragePoolSetAutostart (virStoragePoolPtr pool,
int autostart); int virStoragePoolUndefine (virStoragePoolPtr pool); 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 virStorageVolDownload (virStorageVolPtr vol,
virStreamPtr stream,
unsigned long long offset,
unsigned long long length,
unsigned int flags); int virStorageVolFree (virStorageVolPtr vol); virConnectPtr virStorageVolGetConnect (virStorageVolPtr vol); int virStorageVolGetInfo (virStorageVolPtr vol,
virStorageVolInfoPtr info); const char * virStorageVolGetKey (virStorageVolPtr vol); const char * virStorageVolGetName (virStorageVolPtr vol); char * virStorageVolGetPath (virStorageVolPtr vol); char * virStorageVolGetXMLDesc (virStorageVolPtr vol,
unsigned int flags); virStorageVolPtr virStorageVolLookupByKey (virConnectPtr conn,
const char * key); virStorageVolPtr virStorageVolLookupByName (virStoragePoolPtr pool,
const char * name); virStorageVolPtr virStorageVolLookupByPath (virConnectPtr conn,
const char * path); int virStorageVolRef (virStorageVolPtr vol); int virStorageVolUpload (virStorageVolPtr vol,
virStreamPtr stream,
unsigned long long offset,
unsigned long long length,
unsigned int flags); int virStorageVolWipe (virStorageVolPtr vol,
unsigned int flags); int virStreamAbort (virStreamPtr stream); int virStreamEventAddCallback (virStreamPtr stream,
int events,
virStreamEventCallback cb,
void * opaque,
virFreeCallback ff); typedef void virStreamEventCallback (virStreamPtr stream,
int events,
void * opaque); int virStreamEventRemoveCallback (virStreamPtr stream); int virStreamEventUpdateCallback (virStreamPtr stream,
int events); int virStreamFinish (virStreamPtr stream); int virStreamFree (virStreamPtr stream); virStreamPtr virStreamNew (virConnectPtr conn,
unsigned int flags); int virStreamRecv (virStreamPtr stream,
char * data,
size_t nbytes); int virStreamRecvAll (virStreamPtr stream,
virStreamSinkFunc handler,
void * opaque); int virStreamRef (virStreamPtr stream); int virStreamSend (virStreamPtr stream,
const char * data,
size_t nbytes); int virStreamSendAll (virStreamPtr stream,
virStreamSourceFunc handler,
void * opaque); typedef int virStreamSinkFunc (virStreamPtr st,
const char * data,
size_t nbytes,
void * opaque); typedef int virStreamSourceFunc (virStreamPtr st,
char * data,
size_t nbytes,
void * opaque);
#define LIBVIR_VERSION_NUMBER;
Macro providing the version of the library as version * 1,000,000 + minor * 1000 + micro
#define VIR_COPY_CPUMAP(cpumaps, maplen, vcpu, cpumap);
This macro is to be used in conjunction with virDomainGetVcpus() and virDomainPinVcpu() APIs. VIR_COPY_CPUMAP macro extract the cpumap of the specified vcpu from cpumaps array and copy it into cpumap to be used later by virDomainPinVcpu() API.
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)) |
#define VIR_CPU_MAPLEN(cpu);
This macro is to be used in conjunction with virDomainPinVcpu() API. It returns the length (in bytes) required to store the complete CPU map between a single virtual & all physical CPUs of a domain.
cpu: | number of physical CPUs |
#define VIR_CPU_USABLE(cpumaps, maplen, vcpu, cpu);
This macro is to be used in conjunction with virDomainGetVcpus() API. VIR_CPU_USABLE macro returns a non zero value (true) if the cpu is usable by the vcpu, and 0 otherwise.
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 |
#define VIR_DOMAIN_BLKIO_FIELD_LENGTH;
Macro providing the field length of virBlkioParameter. Provided for backwards compatibility; VIR_TYPED_PARAM_FIELD_LENGTH is the preferred value since 0.9.2.
#define VIR_DOMAIN_BLKIO_WEIGHT;
Macro for the Blkio tunable weight: it represents the io weight the guest can use.
#define VIR_DOMAIN_BLOCK_STATS_ERRS;
In Xen this returns the mysterious 'oo_req'
#define VIR_DOMAIN_BLOCK_STATS_FIELD_LENGTH;
Macro providing the field length of virDomainBlockStatsFlagsStruct
#define VIR_DOMAIN_BLOCK_STATS_FLUSH_REQ;
Macro represents the total flush requests of the block device.
#define VIR_DOMAIN_BLOCK_STATS_FLUSH_TOTAL_TIMES;
Macro represents the total time spend on cache flushing in nano-seconds of the block device.
#define VIR_DOMAIN_BLOCK_STATS_READ_BYTES;
Macro represents the total number of read bytes of the block device.
#define VIR_DOMAIN_BLOCK_STATS_READ_REQ;
Macro represents the total read requests of the block device.
#define VIR_DOMAIN_BLOCK_STATS_READ_TOTAL_TIMES;
Macro represents the total time spend on cache reads in nano-seconds of the block device.
#define VIR_DOMAIN_BLOCK_STATS_WRITE_BYTES;
Macro represents the total number of write bytes of the block device.
#define VIR_DOMAIN_BLOCK_STATS_WRITE_REQ;
Macro represents the total write requests of the block device.
#define VIR_DOMAIN_BLOCK_STATS_WRITE_TOTAL_TIMES;
Macro represents the total time spend on cache writes in nano-seconds of the block device.
#define VIR_DOMAIN_EVENT_CALLBACK;
Used to cast the event specific callback into the generic one for use for virDomainEventRegister
#define VIR_DOMAIN_MEMORY_FIELD_LENGTH;
Macro providing the field length of virMemoryParameter. Provided for backwards compatibility; VIR_TYPED_PARAM_FIELD_LENGTH is the preferred value since 0.9.2.
#define 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_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_PARAM_UNLIMITED;
Macro providing the virMemoryParameter value that indicates "unlimited"
#define 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_SWAP_HARD_LIMIT;
Macro for the swap tunable swap_hard_limit: it represents the maximum swap plus memory the guest can use. This limit has to be more than VIR_DOMAIN_MEMORY_HARD_LIMIT.
#define VIR_DOMAIN_SCHED_FIELD_LENGTH;
Macro providing the field length of virSchedParameter. Provided for backwards compatibility; VIR_TYPED_PARAM_FIELD_LENGTH is the preferred value since 0.9.2.
#define VIR_DOMAIN_SEND_KEY_MAX_KEYS;
Maximum number of keycodes that can be sent in one virDomainSendKey() call.
#define VIR_GET_CPUMAP(cpumaps, maplen, vcpu);
This macro is to be used in conjunction with virDomainGetVcpus() and virDomainPinVcpu() APIs. VIR_GET_CPUMAP macro returns a pointer to the cpumap of the specified vcpu from cpumaps array.
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 |
#define VIR_NODEINFO_MAXCPUS(nodeinfo);
This macro is to calculate the total number of CPUs supported but not necessary active in the host.
nodeinfo: | virNodeInfo instance |
#define VIR_NODE_CPU_STATS_ALL_CPUS;
Macro for the total CPU time/utilization
#define VIR_NODE_CPU_STATS_FIELD_LENGTH;
Macro providing the field length of virNodeCPUStats
#define VIR_NODE_CPU_STATS_IDLE;
The cumulative idle CPU time, since the node booting up (in nanoseconds).
#define VIR_NODE_CPU_STATS_IOWAIT;
The cumulative I/O wait CPU time, since the node booting up (in nanoseconds).
#define VIR_NODE_CPU_STATS_KERNEL;
Macro for the cumulative CPU time which was spent by the kernel, since the node booting up (in nanoseconds).
#define VIR_NODE_CPU_STATS_USER;
The cumulative CPU time which was spent by user processes, since the node booting up (in nanoseconds).
#define VIR_NODE_CPU_STATS_UTILIZATION;
The CPU utilization of a node. The usage value is in percent and 100% represents all CPUs of the node.
#define VIR_NODE_MEMORY_STATS_ALL_CELLS;
Macro for the total memory of all cells.
#define VIR_NODE_MEMORY_STATS_BUFFERS;
Macro for the buffer memory: On Linux, it is only returned in case of VIR_NODE_MEMORY_STATS_ALL_CELLS.
#define VIR_NODE_MEMORY_STATS_CACHED;
Macro for the cached memory: On Linux, it is only returned in case of VIR_NODE_MEMORY_STATS_ALL_CELLS.
#define VIR_NODE_MEMORY_STATS_FIELD_LENGTH;
Macro providing the field length of virNodeMemoryStats
#define VIR_NODE_MEMORY_STATS_FREE;
Macro for the free memory of specified cell: On Linux, it includes buffer and cached memory, in case of VIR_NODE_MEMORY_STATS_ALL_CELLS.
#define VIR_NODE_MEMORY_STATS_TOTAL;
Macro for the total memory of specified cell: it represents the maximum memory.
#define VIR_SECURITY_DOI_BUFLEN;
Macro providing the maximum length of the virSecurityModel doi string.
#define VIR_SECURITY_LABEL_BUFLEN;
Macro providing the maximum length of the virSecurityLabel label string. Note that this value is based on that used by Labeled NFS.
#define VIR_SECURITY_MODEL_BUFLEN;
Macro providing the maximum length of the virSecurityModel model string.
#define VIR_TYPED_PARAM_FIELD_LENGTH;
Macro providing the field length of virTypedParameter name
#define VIR_UNUSE_CPU(cpumap, cpu);
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.
cpumap: | pointer to a bit map of real CPUs (in 8-bit bytes) (IN/OUT) |
cpu: | the physical CPU number |
#define VIR_USE_CPU(cpumap, cpu);
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.
cpumap: | pointer to a bit map of real CPUs (in 8-bit bytes) (IN/OUT) |
cpu: | the physical CPU number |
#define VIR_UUID_BUFLEN;
This macro provides the length of the buffer required for virDomainGetUUID()
#define VIR_UUID_STRING_BUFLEN;
This macro provides the length of the buffer required for virDomainGetUUIDString()
#define _virBlkioParameter;
#define _virMemoryParameter;
#define _virSchedParameter;
struct _virTypedParameter { char field[VIR_TYPED_PARAM_FIELD_LENGTH] field : parameter name int type : parameter type, virTypedParameterType union value : parameter value } virBlkioParameter;
virBlkioParameter * virBlkioParameterPtr;
a virBlkioParameterPtr is a pointer to a virBlkioParameter structure. Provided for backwards compatibility; virTypedParameterPtr is the preferred alias since 0.9.2.
enum virBlkioParameterType { VIR_DOMAIN_BLKIO_PARAM_BOOLEAN = VIR_TYPED_PARAM_BOOLEAN VIR_DOMAIN_BLKIO_PARAM_DOUBLE = VIR_TYPED_PARAM_DOUBLE VIR_DOMAIN_BLKIO_PARAM_INT = VIR_TYPED_PARAM_INT VIR_DOMAIN_BLKIO_PARAM_LLONG = VIR_TYPED_PARAM_LLONG VIR_DOMAIN_BLKIO_PARAM_UINT = VIR_TYPED_PARAM_UINT VIR_DOMAIN_BLKIO_PARAM_ULLONG = VIR_TYPED_PARAM_ULLONG };
enum virCPUCompareResult { VIR_CPU_COMPARE_ERROR = -1 VIR_CPU_COMPARE_INCOMPATIBLE = 0 VIR_CPU_COMPARE_IDENTICAL = 1 VIR_CPU_COMPARE_SUPERSET = 2 };
struct _virConnect { The content of this structure is not made public by the API. } virConnect;
struct _virConnectAuth { int * credtype : List of supported virConnectCredentialType values unsigned int ncredtype virConnectAuthCallbackPtr cb : Callback used to collect credentials void * cbdata } virConnectAuth;
virConnectAuth * virConnectAuthPtr;
struct _virConnectCredential { int type : One of virConnectCredentialType constants const char * prompt : Prompt to show to user const char * challenge : Additional challenge to show const char * defresult : Optional default result char * result : Result to be filled with user response (or defresult) unsigned int resultlen : Length of the result } virConnectCredential;
virConnectCredential * virConnectCredentialPtr;
enum virConnectCredentialType { VIR_CRED_USERNAME = 1 /* Identity to act as */ VIR_CRED_AUTHNAME = 2 /* Identify to authorize as */ VIR_CRED_LANGUAGE = 3 /* RFC 1766 languages, comma separated */ VIR_CRED_CNONCE = 4 /* client supplies a nonce */ VIR_CRED_PASSPHRASE = 5 /* Passphrase secret */ VIR_CRED_ECHOPROMPT = 6 /* Challenge response */ VIR_CRED_NOECHOPROMPT = 7 /* Challenge response */ VIR_CRED_REALM = 8 /* Authentication realm */ VIR_CRED_EXTERNAL = 9 /* Externally managed credential More may be added - expect the unexpected */ };
enum virConnectDomainEventBlockJobStatus { VIR_DOMAIN_BLOCK_JOB_COMPLETED = 0 VIR_DOMAIN_BLOCK_JOB_FAILED = 1 };
enum virConnectFlags { VIR_CONNECT_RO = 1 /* A readonly connection */ };
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.
struct _virDomain { The content of this structure is not made public by the API. } virDomain;
struct _virDomainBlockInfo { unsigned long long capacity : logical size in bytes of the block device backing image unsigned long long allocation : highest allocated extent in bytes of the block device backing image unsigned long long physical : physical size in bytes of the container of the backing image } virDomainBlockInfo;
virDomainBlockInfo * virDomainBlockInfoPtr;
unsigned long long virDomainBlockJobCursor;
struct _virDomainBlockJobInfo { virDomainBlockJobType type unsigned long bandwidth : The following fields provide an indication of block job progress. @cu virDomainBlockJobCursor cur virDomainBlockJobCursor end } virDomainBlockJobInfo;
virDomainBlockJobInfo * virDomainBlockJobInfoPtr;
enum virDomainBlockJobType { VIR_DOMAIN_BLOCK_JOB_TYPE_UNKNOWN = 0 VIR_DOMAIN_BLOCK_JOB_TYPE_PULL = 1 };
virDomainBlockStatsStruct * virDomainBlockStatsPtr;
A pointer to a virDomainBlockStats structure
struct _virDomainBlockStats { long long rd_req : number of read requests long long rd_bytes : number of read bytes long long wr_req : number of write requests long long wr_bytes : number of written bytes long long errs : In Xen this returns the mysterious 'oo_req'. } virDomainBlockStatsStruct;
enum virDomainBlockedReason { VIR_DOMAIN_BLOCKED_UNKNOWN = 0 /* the reason is unknown */ };
struct _virDomainControlInfo { unsigned int state : control state, one of virDomainControlState unsigned int details : state details, currently 0 unsigned long long stateTime : for how long (in msec) control interface has been in current state (ex } virDomainControlInfo;
virDomainControlInfo * virDomainControlInfoPtr;
Pointer to virDomainControlInfo structure.
enum virDomainControlState { VIR_DOMAIN_CONTROL_OK = 0 /* operational, ready to accept commands */ VIR_DOMAIN_CONTROL_JOB = 1 /* background job is running (can be monitored by virDomainGetJobInfo); only limited set of commands may be allowed */ VIR_DOMAIN_CONTROL_OCCUPIED = 2 /* occupied by a running command */ VIR_DOMAIN_CONTROL_ERROR = 3 /* unusable, domain cannot be fully operated */ };
enum virDomainCoreDumpFlags { VIR_DUMP_CRASH = 1 /* crash after dump */ VIR_DUMP_LIVE = 2 /* live dump */ VIR_DUMP_BYPASS_CACHE = 4 /* avoid file system cache pollution */ };
enum virDomainCrashedReason { VIR_DOMAIN_CRASHED_UNKNOWN = 0 /* crashed for unknown reason */ };
enum virDomainCreateFlags { VIR_DOMAIN_NONE = 0 /* Default behavior */ VIR_DOMAIN_START_PAUSED = 1 /* Launch guest in paused state */ VIR_DOMAIN_START_AUTODESTROY = 2 /* Automatically kill guest when virConnectPtr is closed */ VIR_DOMAIN_START_BYPASS_CACHE = 4 /* Avoid file system cache pollution */ VIR_DOMAIN_START_FORCE_BOOT = 8 /* Boot, discarding any managed save */ };
enum virDomainDeviceModifyFlags { VIR_DOMAIN_DEVICE_MODIFY_CONFIG = VIR_DOMAIN_AFFECT_CONFIG /* Additionally, these flags may be bitwise-OR'd in. */ VIR_DOMAIN_DEVICE_MODIFY_CURRENT = VIR_DOMAIN_AFFECT_CURRENT VIR_DOMAIN_DEVICE_MODIFY_LIVE = VIR_DOMAIN_AFFECT_LIVE VIR_DOMAIN_DEVICE_MODIFY_FORCE = 4 /* Forcibly modify device (ex. force eject a cdrom) */ };
enum virDomainEventDefinedDetailType { VIR_DOMAIN_EVENT_DEFINED_ADDED = 0 /* Newly created config file */ VIR_DOMAIN_EVENT_DEFINED_UPDATED = 1 /* Changed config file */ };
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) } virDomainEventGraphicsAddress;
virDomainEventGraphicsAddress * virDomainEventGraphicsAddressPtr;
enum virDomainEventGraphicsAddressType { VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_IPV4 = 1 /* IPv4 address */ VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_IPV6 = 2 /* IPv6 address */ };
enum virDomainEventGraphicsPhase { VIR_DOMAIN_EVENT_GRAPHICS_CONNECT = 0 /* Initial socket connection established */ VIR_DOMAIN_EVENT_GRAPHICS_INITIALIZE = 1 /* Authentication & setup completed */ VIR_DOMAIN_EVENT_GRAPHICS_DISCONNECT = 2 /* Final socket disconnection */ };
struct _virDomainEventGraphicsSubject { int nidentity : Number of identities in arra virDomainEventGraphicsSubjectIdentityPtr identities : Array of identities for subject } virDomainEventGraphicsSubject;
struct _virDomainEventGraphicsSubjectIdentity { const char * type : Type of identity const char * name : Identity value } virDomainEventGraphicsSubjectIdentity;
virDomainEventGraphicsSubjectIdentity * virDomainEventGraphicsSubjectIdentityPtr;
virDomainEventGraphicsSubject * virDomainEventGraphicsSubjectPtr;
enum virDomainEventID { VIR_DOMAIN_EVENT_ID_LIFECYCLE = 0 /* virConnectDomainEventCallback */ VIR_DOMAIN_EVENT_ID_REBOOT = 1 /* virConnectDomainEventGenericCallback */ VIR_DOMAIN_EVENT_ID_RTC_CHANGE = 2 /* virConnectDomainEventRTCChangeCallback */ VIR_DOMAIN_EVENT_ID_WATCHDOG = 3 /* virConnectDomainEventWatchdogCallback */ VIR_DOMAIN_EVENT_ID_IO_ERROR = 4 /* virConnectDomainEventIOErrorCallback */ VIR_DOMAIN_EVENT_ID_GRAPHICS = 5 /* virConnectDomainEventGraphicsCallback */ VIR_DOMAIN_EVENT_ID_IO_ERROR_REASON = 6 /* virConnectDomainEventIOErrorReasonCallback */ VIR_DOMAIN_EVENT_ID_CONTROL_ERROR = 7 /* virConnectDomainEventGenericCallback */ VIR_DOMAIN_EVENT_ID_BLOCK_JOB = 8 /* 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 = 9 };
enum virDomainEventIOErrorAction { VIR_DOMAIN_EVENT_IO_ERROR_NONE = 0 /* No action, IO error ignored */ VIR_DOMAIN_EVENT_IO_ERROR_PAUSE = 1 /* Guest CPUs are pausde */ VIR_DOMAIN_EVENT_IO_ERROR_REPORT = 2 /* IO error reported to guest OS */ };
enum virDomainEventResumedDetailType { VIR_DOMAIN_EVENT_RESUMED_UNPAUSED = 0 /* Normal resume due to admin unpause */ VIR_DOMAIN_EVENT_RESUMED_MIGRATED = 1 /* Resumed for completion of migration */ VIR_DOMAIN_EVENT_RESUMED_FROM_SNAPSHOT = 2 /* Resumed from snapshot */ };
enum virDomainEventStartedDetailType { VIR_DOMAIN_EVENT_STARTED_BOOTED = 0 /* Normal startup from boot */ VIR_DOMAIN_EVENT_STARTED_MIGRATED = 1 /* Incoming migration from another host */ VIR_DOMAIN_EVENT_STARTED_RESTORED = 2 /* Restored from a state file */ VIR_DOMAIN_EVENT_STARTED_FROM_SNAPSHOT = 3 /* Restored from snapshot */ };
enum virDomainEventStoppedDetailType { VIR_DOMAIN_EVENT_STOPPED_SHUTDOWN = 0 /* Normal shutdown */ VIR_DOMAIN_EVENT_STOPPED_DESTROYED = 1 /* Forced poweroff from host */ VIR_DOMAIN_EVENT_STOPPED_CRASHED = 2 /* Guest crashed */ VIR_DOMAIN_EVENT_STOPPED_MIGRATED = 3 /* Migrated off to another host */ VIR_DOMAIN_EVENT_STOPPED_SAVED = 4 /* Saved to a state file */ VIR_DOMAIN_EVENT_STOPPED_FAILED = 5 /* Host emulator/mgmt failed */ VIR_DOMAIN_EVENT_STOPPED_FROM_SNAPSHOT = 6 /* offline snapshot loaded */ };
enum virDomainEventSuspendedDetailType { VIR_DOMAIN_EVENT_SUSPENDED_PAUSED = 0 /* Normal suspend due to admin pause */ VIR_DOMAIN_EVENT_SUSPENDED_MIGRATED = 1 /* Suspended for offline migration */ VIR_DOMAIN_EVENT_SUSPENDED_IOERROR = 2 /* Suspended due to a disk I/O error */ VIR_DOMAIN_EVENT_SUSPENDED_WATCHDOG = 3 /* Suspended due to a watchdog firing */ VIR_DOMAIN_EVENT_SUSPENDED_RESTORED = 4 /* Restored from paused state file */ VIR_DOMAIN_EVENT_SUSPENDED_FROM_SNAPSHOT = 5 /* Restored from paused snapshot */ };
enum virDomainEventType { VIR_DOMAIN_EVENT_DEFINED = 0 VIR_DOMAIN_EVENT_UNDEFINED = 1 VIR_DOMAIN_EVENT_STARTED = 2 VIR_DOMAIN_EVENT_SUSPENDED = 3 VIR_DOMAIN_EVENT_RESUMED = 4 VIR_DOMAIN_EVENT_STOPPED = 5 };
enum virDomainEventUndefinedDetailType { VIR_DOMAIN_EVENT_UNDEFINED_REMOVED = 0 /* Deleted the config file */ };
enum virDomainEventWatchdogAction { VIR_DOMAIN_EVENT_WATCHDOG_NONE = 0 /* No action, watchdog ignored */ VIR_DOMAIN_EVENT_WATCHDOG_PAUSE = 1 /* Guest CPUs are paused */ VIR_DOMAIN_EVENT_WATCHDOG_RESET = 2 /* Guest CPUs are reset */ VIR_DOMAIN_EVENT_WATCHDOG_POWEROFF = 3 /* Guest is forcably powered off */ VIR_DOMAIN_EVENT_WATCHDOG_SHUTDOWN = 4 /* Guest is requested to gracefully shutdown */ VIR_DOMAIN_EVENT_WATCHDOG_DEBUG = 5 /* No action, a debug message logged */ };
struct _virDomainInfo { unsigned char state : the running state, one of virDomainState unsigned long maxMem : the maximum memory in KBytes allowed unsigned long memory : the memory in KBytes used by the domain unsigned short nrVirtCpu : the number of virtual CPUs for the domain unsigned long long cpuTime : the CPU time used in nanoseconds } virDomainInfo;
virDomainInfo * virDomainInfoPtr;
a virDomainInfoPtr is a pointer to a virDomainInfo structure.
virDomainInterfaceStatsStruct * virDomainInterfaceStatsPtr;
A pointer to a virDomainInterfaceStats structure
struct _virDomainInterfaceStats { long long rx_bytes long long rx_packets long long rx_errs long long rx_drop long long tx_bytes long long tx_packets long long tx_errs long long tx_drop } virDomainInterfaceStatsStruct;
struct _virDomainJobInfo { 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 other unsigned long long dataTotal unsigned long long dataProcessed unsigned long long dataRemaining : As above, but only tracking guest memory progress unsigned long long memTotal unsigned long long memProcessed unsigned long long memRemaining : As above, but only tracking guest disk file progress unsigned long long fileTotal unsigned long long fileProcessed unsigned long long fileRemaining } virDomainJobInfo;
virDomainJobInfo * virDomainJobInfoPtr;
enum virDomainJobType { VIR_DOMAIN_JOB_NONE = 0 /* No job is active */ VIR_DOMAIN_JOB_BOUNDED = 1 /* Job with a finite completion time */ VIR_DOMAIN_JOB_UNBOUNDED = 2 /* Job without a finite completion time */ VIR_DOMAIN_JOB_COMPLETED = 3 /* Job has finished, but isn't cleaned up */ VIR_DOMAIN_JOB_FAILED = 4 /* Job hit error, but isn't cleaned up */ VIR_DOMAIN_JOB_CANCELLED = 5 /* Job was aborted, but isn't cleaned up */ };
enum virDomainMemoryFlags { VIR_MEMORY_VIRTUAL = 1 /* addresses are virtual addresses */ VIR_MEMORY_PHYSICAL = 2 /* addresses are physical addresses */ };
enum virDomainMemoryModFlags { VIR_DOMAIN_MEM_CONFIG = VIR_DOMAIN_AFFECT_CONFIG /* Additionally, these flags may be bitwise-OR'd in. */ VIR_DOMAIN_MEM_CURRENT = VIR_DOMAIN_AFFECT_CURRENT VIR_DOMAIN_MEM_LIVE = VIR_DOMAIN_AFFECT_LIVE VIR_DOMAIN_MEM_MAXIMUM = 4 /* affect Max rather than current */ };
virDomainMemoryStatStruct * virDomainMemoryStatPtr;
struct _virDomainMemoryStat { int tag unsigned long long val } virDomainMemoryStatStruct;
enum virDomainMemoryStatTags { VIR_DOMAIN_MEMORY_STAT_SWAP_IN = 0 /* The total amount of memory written out to swap space (in kB). */ VIR_DOMAIN_MEMORY_STAT_SWAP_OUT = 1 /* Page faults occur when a process makes a valid access to virtual memory that is not available. When servicing the page fault, if disk IO is required, it is considered a major fault. If not, it is a minor fault. These are expressed as the number of faults that have occurred. */ VIR_DOMAIN_MEMORY_STAT_MAJOR_FAULT = 2 VIR_DOMAIN_MEMORY_STAT_MINOR_FAULT = 3 /* The amount of memory left completely unused by the system. Memory that is available but used for reclaimable caches should NOT be reported as free. This value is expressed in kB. */ VIR_DOMAIN_MEMORY_STAT_UNUSED = 4 /* The total amount of usable memory as seen by the domain. This value may be less than the amount of memory assigned to the domain if a balloon driver is in use or if the guest OS does not initialize all assigned pages. This value is expressed in kB. */ VIR_DOMAIN_MEMORY_STAT_AVAILABLE = 5 /* Current balloon value (in KB). */ VIR_DOMAIN_MEMORY_STAT_ACTUAL_BALLOON = 6 /* 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 = 7 };
enum virDomainMigrateFlags { VIR_MIGRATE_LIVE = 1 /* live migration */ VIR_MIGRATE_PEER2PEER = 2 /* direct source -> dest host control channel Note the less-common spelling that we're stuck with: VIR_MIGRATE_TUNNELLED should be VIR_MIGRATE_TUNNELED */ VIR_MIGRATE_TUNNELLED = 4 /* tunnel migration data over libvirtd connection */ VIR_MIGRATE_PERSIST_DEST = 8 /* persist the VM on the destination */ VIR_MIGRATE_UNDEFINE_SOURCE = 16 /* undefine the VM on the source */ VIR_MIGRATE_PAUSED = 32 /* pause on remote side */ VIR_MIGRATE_NON_SHARED_DISK = 64 /* migration with non-shared storage with full disk copy */ VIR_MIGRATE_NON_SHARED_INC = 128 /* migration with non-shared storage with incremental copy (same base image shared between source and destination) */ VIR_MIGRATE_CHANGE_PROTECTION = 256 /* protect for changing domain configuration through the whole migration process; this will be used automatically when supported */ };
enum virDomainModificationImpact { VIR_DOMAIN_AFFECT_CURRENT = 0 /* Affect current domain state. */ VIR_DOMAIN_AFFECT_LIVE = 1 /* Affect running domain state. */ VIR_DOMAIN_AFFECT_CONFIG = 2 /* Affect persistent domain state. */ };
enum virDomainNostateReason { VIR_DOMAIN_NOSTATE_UNKNOWN = 0 };
enum virDomainPausedReason { VIR_DOMAIN_PAUSED_UNKNOWN = 0 /* the reason is unknown */ VIR_DOMAIN_PAUSED_USER = 1 /* paused on user request */ VIR_DOMAIN_PAUSED_MIGRATION = 2 /* paused for offline migration */ VIR_DOMAIN_PAUSED_SAVE = 3 /* paused for save */ VIR_DOMAIN_PAUSED_DUMP = 4 /* paused for offline core dump */ VIR_DOMAIN_PAUSED_IOERROR = 5 /* paused due to a disk I/O error */ VIR_DOMAIN_PAUSED_WATCHDOG = 6 /* paused due to a watchdog event */ VIR_DOMAIN_PAUSED_FROM_SNAPSHOT = 7 /* paused after restoring from snapshot */ VIR_DOMAIN_PAUSED_SHUTTING_DOWN = 8 /* paused during shutdown process */ };
virDomain * virDomainPtr;
a virDomainPtr is pointer to a virDomain private structure, this is the type used to reference a domain in the API.
enum virDomainRunningReason { VIR_DOMAIN_RUNNING_UNKNOWN = 0 VIR_DOMAIN_RUNNING_BOOTED = 1 /* normal startup from boot */ VIR_DOMAIN_RUNNING_MIGRATED = 2 /* migrated from another host */ VIR_DOMAIN_RUNNING_RESTORED = 3 /* restored from a state file */ VIR_DOMAIN_RUNNING_FROM_SNAPSHOT = 4 /* restored from snapshot */ VIR_DOMAIN_RUNNING_UNPAUSED = 5 /* returned from paused state */ VIR_DOMAIN_RUNNING_MIGRATION_CANCELED = 6 /* returned from migration */ VIR_DOMAIN_RUNNING_SAVE_CANCELED = 7 /* returned from failed save process */ };
enum virDomainSaveRestoreFlags { VIR_DOMAIN_SAVE_BYPASS_CACHE = 1 /* Avoid file system cache pollution */ VIR_DOMAIN_SAVE_RUNNING = 2 /* Favor running over paused */ VIR_DOMAIN_SAVE_PAUSED = 4 /* Favor paused over running */ };
enum virDomainShutdownReason { VIR_DOMAIN_SHUTDOWN_UNKNOWN = 0 /* the reason is unknown */ VIR_DOMAIN_SHUTDOWN_USER = 1 /* shutting down on user request */ };
enum virDomainShutoffReason { VIR_DOMAIN_SHUTOFF_UNKNOWN = 0 /* the reason is unknown */ VIR_DOMAIN_SHUTOFF_SHUTDOWN = 1 /* normal shutdown */ VIR_DOMAIN_SHUTOFF_DESTROYED = 2 /* forced poweroff */ VIR_DOMAIN_SHUTOFF_CRASHED = 3 /* domain crashed */ VIR_DOMAIN_SHUTOFF_MIGRATED = 4 /* migrated to another host */ VIR_DOMAIN_SHUTOFF_SAVED = 5 /* saved to a file */ VIR_DOMAIN_SHUTOFF_FAILED = 6 /* domain failed to start */ VIR_DOMAIN_SHUTOFF_FROM_SNAPSHOT = 7 /* restored from a snapshot which was taken while domain was shutoff */ };
struct _virDomainSnapshot { The content of this structure is not made public by the API. } virDomainSnapshot;
enum virDomainSnapshotCreateFlags { VIR_DOMAIN_SNAPSHOT_CREATE_REDEFINE = 1 /* Restore or alter metadata */ VIR_DOMAIN_SNAPSHOT_CREATE_CURRENT = 2 /* With redefine, make snapshot current */ VIR_DOMAIN_SNAPSHOT_CREATE_NO_METADATA = 4 /* Make snapshot without remembering it */ VIR_DOMAIN_SNAPSHOT_CREATE_HALT = 8 /* Stop running guest after snapshot */ VIR_DOMAIN_SNAPSHOT_CREATE_DISK_ONLY = 16 /* disk snapshot, not system checkpoint */ };
enum virDomainSnapshotDeleteFlags { VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN = 1 /* Also delete children */ VIR_DOMAIN_SNAPSHOT_DELETE_METADATA_ONLY = 2 /* Delete just metadata */ VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN_ONLY = 4 /* Delete just children */ };
enum virDomainSnapshotListFlags { VIR_DOMAIN_SNAPSHOT_LIST_ROOTS = 1 /* Filter by snapshots which have no parents */ VIR_DOMAIN_SNAPSHOT_LIST_METADATA = 2 /* Filter by snapshots which have metadata */ };
virDomainSnapshot * virDomainSnapshotPtr;
a virDomainSnapshotPtr is pointer to a virDomainSnapshot private structure, and is the type used to reference a domain snapshot in the API.
enum virDomainSnapshotRevertFlags { VIR_DOMAIN_SNAPSHOT_REVERT_RUNNING = 1 /* Run after revert */ VIR_DOMAIN_SNAPSHOT_REVERT_PAUSED = 2 /* Pause after revert */ };
enum virDomainState { VIR_DOMAIN_NOSTATE = 0 /* no state */ VIR_DOMAIN_RUNNING = 1 /* the domain is running */ VIR_DOMAIN_BLOCKED = 2 /* the domain is blocked on resource */ VIR_DOMAIN_PAUSED = 3 /* the domain is paused by user */ VIR_DOMAIN_SHUTDOWN = 4 /* the domain is being shut down */ VIR_DOMAIN_SHUTOFF = 5 /* the domain is shut off */ VIR_DOMAIN_CRASHED = 6 /* NB: this enum value will increase over time as new events are added to the libvirt API. It reflects the last state supported by this version of the libvirt API. */ VIR_DOMAIN_LAST = 7 };
enum virDomainUndefineFlagsValues { VIR_DOMAIN_UNDEFINE_MANAGED_SAVE = 1 /* Also remove any managed save */ VIR_DOMAIN_UNDEFINE_SNAPSHOTS_METADATA = 2 /* If last use of domain, then also remove any snapshot metadata Future undefine control flags should come here. */ };
enum virDomainVcpuFlags { VIR_DOMAIN_VCPU_CONFIG = VIR_DOMAIN_AFFECT_CONFIG /* Additionally, these flags may be bitwise-OR'd in. */ VIR_DOMAIN_VCPU_CURRENT = VIR_DOMAIN_AFFECT_CURRENT VIR_DOMAIN_VCPU_LIVE = VIR_DOMAIN_AFFECT_LIVE VIR_DOMAIN_VCPU_MAXIMUM = 4 /* Max rather than current count */ };
enum virDomainXMLFlags { VIR_DOMAIN_XML_SECURE = 1 /* dump security sensitive information too */ VIR_DOMAIN_XML_INACTIVE = 2 /* dump inactive domain information */ VIR_DOMAIN_XML_UPDATE_CPU = 4 /* update guest CPU requirements according to host CPU */ };
enum virEventHandleType { VIR_EVENT_HANDLE_READABLE = 1 VIR_EVENT_HANDLE_WRITABLE = 2 VIR_EVENT_HANDLE_ERROR = 4 VIR_EVENT_HANDLE_HANGUP = 8 };
struct _virInterface { The content of this structure is not made public by the API. } 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.
enum virInterfaceXMLFlags { VIR_INTERFACE_XML_INACTIVE = 1 /* dump inactive interface information */ };
enum virKeycodeSet { VIR_KEYCODE_SET_LINUX = 0 VIR_KEYCODE_SET_XT = 1 VIR_KEYCODE_SET_ATSET1 = 2 VIR_KEYCODE_SET_ATSET2 = 3 VIR_KEYCODE_SET_ATSET3 = 4 VIR_KEYCODE_SET_OSX = 5 VIR_KEYCODE_SET_XT_KBD = 6 VIR_KEYCODE_SET_USB = 7 VIR_KEYCODE_SET_WIN32 = 8 VIR_KEYCODE_SET_RFB = 9 /* NB: this enum value will increase over time as new events are added to the libvirt API. It reflects the last keycode set supported by this version of the libvirt API. */ VIR_KEYCODE_SET_LAST = 10 };
struct _virTypedParameter { char field[VIR_TYPED_PARAM_FIELD_LENGTH] field : parameter name int type : parameter type, virTypedParameterType union value : parameter value } virMemoryParameter;
virMemoryParameter * virMemoryParameterPtr;
a virMemoryParameterPtr is a pointer to a virMemoryParameter structure. Provided for backwards compatibility; virTypedParameterPtr is the preferred alias since 0.9.2.
enum virMemoryParameterType { VIR_DOMAIN_MEMORY_PARAM_BOOLEAN = VIR_TYPED_PARAM_BOOLEAN VIR_DOMAIN_MEMORY_PARAM_DOUBLE = VIR_TYPED_PARAM_DOUBLE VIR_DOMAIN_MEMORY_PARAM_INT = VIR_TYPED_PARAM_INT VIR_DOMAIN_MEMORY_PARAM_LLONG = VIR_TYPED_PARAM_LLONG VIR_DOMAIN_MEMORY_PARAM_UINT = VIR_TYPED_PARAM_UINT VIR_DOMAIN_MEMORY_PARAM_ULLONG = VIR_TYPED_PARAM_ULLONG };
struct _virNWFilter { The content of this structure is not made public by the API. } 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.
struct _virNetwork { The content of this structure is not made public by the API. } 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.
struct _virNodeCPUStats { char field[VIR_NODE_CPU_STATS_FIELD_LENGTH] field unsigned long long value } virNodeCPUStats;
virNodeCPUStats * virNodeCPUStatsPtr;
a virNodeCPUStatsPtr is a pointer to a virNodeCPUStats structure.
struct _virNodeDevice { The content of this structure is not made public by the API. } 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.
struct _virNodeInfo { char model[32] model : string indicating the CPU model unsigned long memory : memory size in kilobytes unsigned int cpus : the number of active CPUs unsigned int mhz : expected CPU frequency unsigned int nodes : the number of NUMA cell, 1 for unusual NUMA topologies or uniform memo unsigned int sockets : number of CPU sockets per node if nodes > 1, total number of CPU socke unsigned int cores : number of cores per socket unsigned int threads : number of threads per core } virNodeInfo;
virNodeInfo * virNodeInfoPtr;
a virNodeInfoPtr is a pointer to a virNodeInfo structure.
struct _virNodeMemoryStats { char field[VIR_NODE_MEMORY_STATS_FIELD_LENGTH] field unsigned long long value } virNodeMemoryStats;
virNodeMemoryStats * virNodeMemoryStatsPtr;
a virNodeMemoryStatsPtr is a pointer to a virNodeMemoryStats structure.
struct _virTypedParameter { char field[VIR_TYPED_PARAM_FIELD_LENGTH] field : parameter name int type : parameter type, virTypedParameterType union value : parameter value } virSchedParameter;
virSchedParameter * virSchedParameterPtr;
a virSchedParameterPtr is a pointer to a virSchedParameter structure. Provided for backwards compatibility; virTypedParameterPtr is the preferred alias since 0.9.2.
enum virSchedParameterType { VIR_DOMAIN_SCHED_FIELD_BOOLEAN = VIR_TYPED_PARAM_BOOLEAN VIR_DOMAIN_SCHED_FIELD_DOUBLE = VIR_TYPED_PARAM_DOUBLE VIR_DOMAIN_SCHED_FIELD_INT = VIR_TYPED_PARAM_INT VIR_DOMAIN_SCHED_FIELD_LLONG = VIR_TYPED_PARAM_LLONG VIR_DOMAIN_SCHED_FIELD_UINT = VIR_TYPED_PARAM_UINT VIR_DOMAIN_SCHED_FIELD_ULLONG = VIR_TYPED_PARAM_ULLONG };
struct _virSecret { The content of this structure is not made public by the API. } virSecret;
enum virSecretUsageType { VIR_SECRET_USAGE_TYPE_NONE = 0 VIR_SECRET_USAGE_TYPE_VOLUME = 1 /* Expect more owner types later... */ };
struct _virSecurityLabel { The content of this structure is not made public by the API. } virSecurityLabel;
virSecurityLabel * virSecurityLabelPtr;
a virSecurityLabelPtr is a pointer to a virSecurityLabel.
struct _virSecurityModel { The content of this structure is not made public by the API. } virSecurityModel;
virSecurityModel * virSecurityModelPtr;
a virSecurityModelPtr is a pointer to a virSecurityModel.
struct _virStoragePool { The content of this structure is not made public by the API. } virStoragePool;
enum virStoragePoolBuildFlags { VIR_STORAGE_POOL_BUILD_NEW = 0 /* Regular build from scratch */ VIR_STORAGE_POOL_BUILD_REPAIR = 1 /* Repair / reinitialize */ VIR_STORAGE_POOL_BUILD_RESIZE = 2 /* Extend existing pool */ VIR_STORAGE_POOL_BUILD_NO_OVERWRITE = 4 /* Do not overwrite existing pool */ VIR_STORAGE_POOL_BUILD_OVERWRITE = 8 /* Overwrite data */ };
enum virStoragePoolDeleteFlags { VIR_STORAGE_POOL_DELETE_NORMAL = 0 /* Delete metadata only (fast) */ VIR_STORAGE_POOL_DELETE_ZEROED = 1 /* Clear all data to zeros (slow) */ };
struct _virStoragePoolInfo { int state : virStoragePoolState flags unsigned long long capacity : Logical size bytes unsigned long long allocation : Current allocation bytes unsigned long long available : Remaining free space bytes } virStoragePoolInfo;
virStoragePoolInfo * virStoragePoolInfoPtr;
virStoragePool * virStoragePoolPtr;
a virStoragePoolPtr is pointer to a virStoragePool private structure, this is the type used to reference a storage pool in the API.
enum virStoragePoolState { 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 */ };
struct _virStorageVol { The content of this structure is not made public by the API. } virStorageVol;
enum virStorageVolDeleteFlags { VIR_STORAGE_VOL_DELETE_NORMAL = 0 /* Delete metadata only (fast) */ VIR_STORAGE_VOL_DELETE_ZEROED = 1 /* Clear all data to zeros (slow) */ };
struct _virStorageVolInfo { int type : virStorageVolType flags unsigned long long capacity : Logical size bytes unsigned long long allocation : Current allocation bytes } virStorageVolInfo;
virStorageVolInfo * virStorageVolInfoPtr;
virStorageVol * virStorageVolPtr;
a virStorageVolPtr is pointer to a virStorageVol private structure, this is the type used to reference a storage volume in the API.
enum virStorageVolType { VIR_STORAGE_VOL_FILE = 0 /* Regular file based volumes */ VIR_STORAGE_VOL_BLOCK = 1 /* Block based volumes */ VIR_STORAGE_VOL_DIR = 2 /* Directory-passthrough based volume */ };
struct _virStream { The content of this structure is not made public by the API. } virStream;
enum virStreamEventType { VIR_STREAM_EVENT_READABLE = 1 VIR_STREAM_EVENT_WRITABLE = 2 VIR_STREAM_EVENT_ERROR = 4 VIR_STREAM_EVENT_HANGUP = 8 };
enum virStreamFlags { VIR_STREAM_NONBLOCK = 1 };
virStream * virStreamPtr;
a virStreamPtr is pointer to a virStream private structure, this is the type used to reference a data stream in the API.
struct _virTypedParameter { char field[VIR_TYPED_PARAM_FIELD_LENGTH] field : parameter name int type : parameter type, virTypedParameterType union value : parameter value } virTypedParameter;
virTypedParameter * virTypedParameterPtr;
a pointer to a virTypedParameter structure.
enum virTypedParameterType { VIR_TYPED_PARAM_INT = 1 /* integer case */ VIR_TYPED_PARAM_UINT = 2 /* unsigned integer case */ VIR_TYPED_PARAM_LLONG = 3 /* long long case */ VIR_TYPED_PARAM_ULLONG = 4 /* unsigned long long case */ VIR_TYPED_PARAM_DOUBLE = 5 /* double case */ VIR_TYPED_PARAM_BOOLEAN = 6 /* boolean(character) case */ };
struct _virVcpuInfo { unsigned int number : virtual CPU number int state : value from virVcpuState unsigned long long cpuTime : CPU time used, in nanoseconds int cpu : real CPU number, or -1 if offline } virVcpuInfo;
virVcpuInfo * virVcpuInfoPtr;
enum virVcpuState { VIR_VCPU_OFFLINE = 0 /* the virtual CPU is offline */ VIR_VCPU_RUNNING = 1 /* the virtual CPU is running */ VIR_VCPU_BLOCKED = 2 /* the virtual CPU is blocked on resource */ };
int virConnectAuthCallbackPtr (virConnectCredentialPtr cred,
unsigned int ncred,
void * cbdata)
When authentication requires one or more interactions, this callback is invoked. For each interaction supplied, data must be gathered from the user and filled in to the 'result' and 'resultlen' fields. If an interaction cannot be filled, fill in NULL and 0.
cred: | list of virConnectCredential object to fetch from user |
ncred: | size of cred list |
cbdata: | opaque data passed to virConnectOpenAuth |
Returns: | 0 if all interactions were filled, or -1 upon error |
void virConnectDomainEventBlockJobCallback (virConnectPtr conn,
virDomainPtr dom,
const char * path,
int type,
int status,
void * opaque)
The callback signature to use when registering for an event of type VIR_DOMAIN_EVENT_ID_BLOCK_JOB with virConnectDomainEventRegisterAny()
conn: | connection object |
dom: | domain on which the event occurred |
path: | fully-qualified filename of the affected disk |
type: | type of block job (virDomainBlockJobType) |
status: | final status of the operation (virConnectDomainEventBlockJobStatus) |
opaque: |
int virConnectDomainEventCallback (virConnectPtr conn,
virDomainPtr dom,
int event,
int detail,
void * opaque)
A callback function to be registered, and called when a domain event occurs
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 |
Returns: |
void virConnectDomainEventGenericCallback (virConnectPtr conn,
virDomainPtr dom,
void * opaque)
A generic domain event callback handler. Specific events usually have a customization with extra parameters
conn: | the connection pointer |
dom: | the domain pointer |
opaque: | application specified data |
void virConnectDomainEventGraphicsCallback (virConnectPtr conn,
virDomainPtr dom,
int phase,
virDomainEventGraphicsAddressPtr local,
virDomainEventGraphicsAddressPtr remote,
const char * authScheme,
virDomainEventGraphicsSubjectPtr subject,
void * opaque)
The callback signature to use when registering for an event of type VIR_DOMAIN_EVENT_ID_GRAPHICS with virConnectDomainEventRegisterAny()
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 |
void virConnectDomainEventIOErrorCallback (virConnectPtr conn,
virDomainPtr dom,
const char * srcPath,
const char * devAlias,
int action,
void * opaque)
The callback signature to use when registering for an event of type VIR_DOMAIN_EVENT_ID_IO_ERROR with virConnectDomainEventRegisterAny()
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 |
void virConnectDomainEventIOErrorReasonCallback (virConnectPtr conn,
virDomainPtr dom,
const char * srcPath,
const char * devAlias,
int action,
const char * reason,
void * opaque)
The callback signature to use when registering for an event of type VIR_DOMAIN_EVENT_ID_IO_ERROR with virConnectDomainEventRegisterAny()
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 |
void virConnectDomainEventRTCChangeCallback (virConnectPtr conn,
virDomainPtr dom,
long long utcoffset,
void * opaque)
The callback signature to use when registering for an event of type VIR_DOMAIN_EVENT_ID_RTC_CHANGE with virConnectDomainEventRegisterAny()
conn: | connection object |
dom: | domain on which the event occurred |
utcoffset: | the new RTC offset from UTC, measured in seconds |
opaque: | application specified data |
void virConnectDomainEventWatchdogCallback (virConnectPtr conn,
virDomainPtr dom,
int action,
void * opaque)
The callback signature to use when registering for an event of type VIR_DOMAIN_EVENT_ID_WATCHDOG with virConnectDomainEventRegisterAny()
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 |
int virEventAddHandleFunc (int fd,
int event,
virEventHandleCallback cb,
void * opaque,
virFreeCallback ff)
Part of the EventImpl, this callback Adds a file handle callback to listen for specific events. The same file handle can be registered multiple times provided the requested event sets are non-overlapping If the opaque user data requires free'ing when the handle is unregistered, then a 2nd callback can be supplied for this purpose.
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 |
Returns: | a handle watch number to be used for updating and unregistering for events |
int virEventAddTimeoutFunc (int timeout,
virEventTimeoutCallback cb,
void * opaque,
virFreeCallback ff)
Part of the EventImpl, this user-defined callback handles adding an event timeout. If the opaque user data requires free'ing when the handle is unregistered, then a 2nd callback can be supplied for this purpose.
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 |
Returns: | a timer value |
void virEventHandleCallback (int watch,
int fd,
int events,
void * opaque)
Callback for receiving file handle events. The callback will be invoked once for each event which is pending.
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 |
int virEventRemoveHandleFunc (int watch)
Part of the EventImpl, this user-provided callback is notified when an fd is no longer being listened on. If a virEventHandleFreeFunc was supplied when the handle was registered, it will be invoked some time during, or after this function call, when it is safe to release the user data.
watch: | file descriptor watch to stop listening on |
Returns: |
int virEventRemoveTimeoutFunc (int timer)
Part of the EventImpl, this user-defined callback removes a timer If a virEventTimeoutFreeFunc was supplied when the handle was registered, it will be invoked some time during, or after this function call, when it is safe to release the user data.
timer: | the timer to remove |
Returns: | 0 on success, -1 on failure |
void virEventTimeoutCallback (int timer,
void * opaque)
callback for receiving timer events
timer: | timer id emitting the event |
opaque: | user data registered with handle |
void virEventUpdateHandleFunc (int watch,
int event)
Part of the EventImpl, this user-provided callback is notified when events to listen on change
watch: | file descriptor watch to modify |
event: | new events to listen on |
void virEventUpdateTimeoutFunc (int timer,
int timeout)
Part of the EventImpl, this user-defined callback updates an event timeout.
timer: | the timer to modify |
timeout: | the new timeout value |
void virFreeCallback (void * opaque)
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
opaque: | opaque user data provided at registration |
void virStreamEventCallback (virStreamPtr stream,
int events,
void * opaque)
Callback for receiving stream events. The callback will be invoked once for each event which is pending.
stream: | stream on which the event occurred |
events: | bitset of events from virEventHandleType constants |
opaque: | user data registered with handle |
int virStreamSinkFunc (virStreamPtr st,
const char * data,
size_t nbytes,
void * opaque)
The virStreamSinkFunc callback is used together with the virStreamRecvAll function for libvirt to provide the data that has been received. The callback will be invoked multiple times, providing data in small chunks. The application should consume up 'nbytes' from the 'data' array of data and then return the number actual number of bytes consumed. The callback will continue to be invoked until it indicates the end of the stream has been reached. A return value of -1 at any time will abort the receive operation
st: | the stream object |
data: | preallocated array to be filled with data |
nbytes: | size of the data array |
opaque: | optional application provided data |
Returns: | the number of bytes consumed or -1 upon error |
int virStreamSourceFunc (virStreamPtr st,
char * data,
size_t nbytes,
void * opaque)
The virStreamSourceFunc callback is used together with the virStreamSendAll function for libvirt to obtain the data that is to be sent. The callback will be invoked multiple times, fetching data in small chunks. The application should fill the 'data' array with 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
st: | the stream object |
data: | preallocated array to be filled with data |
nbytes: | size of the data array |
opaque: | optional application provided data |
Returns: | the number of bytes filled, 0 upon end of file, or -1 upon error |
virConnectAuthPtr virConnectAuthPtrDefault;
char * virConnectBaselineCPU (virConnectPtr conn,
const char ** xmlCPUs,
unsigned int ncpus,
unsigned int flags)
Computes the most feature-rich CPU which is compatible with all given host CPUs.
conn: | virConnect connection |
xmlCPUs: | array of XML descriptions of host CPUs |
ncpus: | number of CPUs in xmlCPUs |
flags: | fine-tuning flags, currently unused, pass 0. |
Returns: | XML description of the computed CPU or NULL on error. |
int virConnectClose (virConnectPtr conn)
This function closes the connection to the Hypervisor. This should not be called if further interaction with the Hypervisor are needed especially if there is running domain which need further monitoring by the application. Connections are reference counted; the count is explicitly increased by the initial open (virConnectOpen, virConnectOpenAuth, and the like) as well as virConnectRef; it is also temporarily increased by other API that depend on the connection remaining alive. The open and every virConnectRef call should have a matching virConnectClose, and all other references will be released after the corresponding operation completes.
conn: | pointer to the hypervisor connection |
Returns: | the number of remaining references on success (positive implies that some other call still has a reference open, 0 implies that no references remain and the connection is closed), or -1 on failure. It is possible for the last virConnectClose to return a positive value if some other object still has a temporary reference to the connection, but the application should not try to further use a connection after the virConnectClose that matches the initial open. |
int virConnectCompareCPU (virConnectPtr conn,
const char * xmlDesc,
unsigned int flags)
Compares the given CPU description with the host CPU
conn: | virConnect connection |
xmlDesc: | XML describing the CPU to compare with host CPU |
flags: | currently unused, pass 0 |
Returns: | comparison result according to enum virCPUCompareResult |
int virConnectDomainEventDeregister (virConnectPtr conn,
virConnectDomainEventCallback cb)
Removes a callback previously registered with the virConnectDomainEventRegister funtion. Use of this method is no longer recommended. Instead applications should try virConnectDomainEventUnregisterAny which has a more flexible API contract
conn: | pointer to the connection |
cb: | callback to the function handling domain events |
Returns: | 0 on success, -1 on failure |
int virConnectDomainEventDeregisterAny (virConnectPtr conn,
int callbackID)
Removes an event callback. The callbackID parameter should be the vaule obtained from a previous virDomainEventRegisterAny method.
conn: | pointer to the connection |
callbackID: | the callback identifier |
Returns: | 0 on success, -1 on failure |
int virConnectDomainEventRegister (virConnectPtr conn,
virConnectDomainEventCallback cb,
void * opaque,
virFreeCallback freecb)
Adds a callback to receive notifications of domain lifecycle events occurring on a connection Use of this method is no longer recommended. Instead applications should try virConnectDomainEventRegisterAny which has a more flexible API contract The virDomainPtr object handle passed into the callback upon delivery of an event is only valid for the duration of execution of the callback. If the callback wishes to keep the domain object after the callback returns, it shall take a reference to it, by calling virDomainRef. The reference can be released once the object is no longer required by calling virDomainFree.
conn: | pointer to the connection |
cb: | callback to the function handling domain events |
opaque: | opaque data to pass on to the callback |
freecb: | optional function to deallocate opaque when not used anymore |
Returns: | 0 on success, -1 on failure |
int virConnectDomainEventRegisterAny (virConnectPtr conn,
virDomainPtr dom,
int eventID,
virConnectDomainEventGenericCallback cb,
void * opaque,
virFreeCallback freecb)
Adds a callback to receive notifications of arbitrary domain events occurring on a domain. If dom is NULL, then events will be monitored for any domain. If dom is non-NULL, then only the specific domain will be monitored Most types of event have a callback providing a custom set of parameters for the event. When registering an event, it is thus neccessary to use the VIR_DOMAIN_EVENT_CALLBACK() macro to cast the supplied function pointer to match the signature of this method. The virDomainPtr object handle passed into the callback upon delivery of an event is only valid for the duration of execution of the callback. If the callback wishes to keep the domain object after the callback returns, it shall take a reference to it, by calling virDomainRef. The reference can be released once the object is no longer required by calling virDomainFree. The return value from this method is a positive integer identifier for the callback. To unregister a callback, this callback ID should be passed to the virDomainEventUnregisterAny method
conn: | pointer to the connection |
dom: | pointer to the domain |
eventID: | the event type to receive |
cb: | callback to the function handling domain events |
opaque: | opaque data to pass on to the callback |
freecb: | optional function to deallocate opaque when not used anymore |
Returns: | a callback identifier on success, -1 on failure |
char * virConnectDomainXMLFromNative (virConnectPtr conn,
const char * nativeFormat,
const char * nativeConfig,
unsigned int flags)
Reads native configuration data describing a domain, and generates libvirt domain XML. The format of the native data is hypervisor dependant.
conn: | a connection object |
nativeFormat: | configuration format importing from |
nativeConfig: | the configuration data to import |
flags: | currently unused, pass 0 |
Returns: | a 0 terminated UTF-8 encoded XML instance, or NULL in case of error. the caller must free() the returned value. |
char * virConnectDomainXMLToNative (virConnectPtr conn,
const char * nativeFormat,
const char * domainXml,
unsigned int flags)
Reads a domain XML configuration document, and generates a native configuration file describing the domain. The format of the native data is hypervisor dependant.
conn: | a connection object |
nativeFormat: | configuration format exporting to |
domainXml: | the domain configuration to export |
flags: | currently unused, pass 0 |
Returns: | a 0 terminated UTF-8 encoded native config datafile, or NULL in case of error. the caller must free() the returned value. |
char * virConnectFindStoragePoolSources (virConnectPtr conn,
const char * type,
const char * srcSpec,
unsigned int flags)
Talks to a storage backend and attempts to auto-discover the set of available storage pool sources. e.g. For iSCSI this would be a set of iSCSI targets. For NFS this would be a list of exported paths. The srcSpec (optional for some storage pool types, e.g. local ones) is an instance of the storage pool's source element specifying where to look for the pools. srcSpec is not required for some types (e.g., those querying local storage resources only)
conn: | pointer to hypervisor connection |
type: | type of storage pool sources to discover |
srcSpec: | XML document specifying discovery source |
flags: | flags for discovery (unused, pass 0) |
Returns: | an xml document consisting of a SourceList element containing a source document appropriate to the given pool type for each discovered source. |
char * virConnectGetCapabilities (virConnectPtr conn)
Provides capabilities of the hypervisor / driver.
conn: | pointer to the hypervisor connection |
Returns: | NULL in case of error, or an XML string defining the capabilities. The client must free the returned string after use. |
char * virConnectGetHostname (virConnectPtr conn)
This returns the system hostname on which the hypervisor is running (the result of the gethostname system call). If we are connected to a remote system, then this returns the hostname of the remote system.
conn: | pointer to a hypervisor connection |
Returns: | the hostname which must be freed by the caller, or NULL if there was an error. |
int virConnectGetLibVersion (virConnectPtr conn,
unsigned long * libVer)
Provides @libVer, which is the version of libvirt used by the daemon running on the @conn host
conn: | pointer to the hypervisor connection |
libVer: | returns the libvirt library version used on the connection (OUT) |
Returns: | -1 in case of failure, 0 otherwise, and values for @libVer have the format major * 1,000,000 + minor * 1,000 + release. |
int virConnectGetMaxVcpus (virConnectPtr conn,
const char * type)
Provides the maximum number of virtual CPUs supported for a guest VM of a specific type. The 'type' parameter here corresponds to the 'type' attribute in the <domain> element of the XML.
conn: | pointer to the hypervisor connection |
type: | value of the 'type' attribute in the <domain> element |
Returns: | the maximum of virtual CPU or -1 in case of error. |
char * virConnectGetSysinfo (virConnectPtr conn,
unsigned int flags)
This returns the XML description of the sysinfo details for the host on which the hypervisor is running, in the same format as the <sysinfo> element of a domain XML. This information is generally available only for hypervisors running with root privileges.
conn: | pointer to a hypervisor connection |
flags: | callers should always pass 0 |
Returns: | the XML string which must be freed by the caller, or NULL if there was an error. |
const char * virConnectGetType (virConnectPtr conn)
Get the name of the Hypervisor software used.
conn: | pointer to the hypervisor connection |
Returns: | NULL in case of error, a static zero terminated string otherwise. See also: http://www.redhat.com/archives/libvir-list/2007-February/msg00096.html |
char * virConnectGetURI (virConnectPtr conn)
This returns the URI (name) of the hypervisor connection. Normally this is the same as or similar to the string passed to the virConnectOpen/virConnectOpenReadOnly call, but the driver may make the URI canonical. If name == NULL was passed to virConnectOpen, then the driver will return a non-NULL URI which can be used to connect to the same hypervisor later.
conn: | pointer to a hypervisor connection |
Returns: | the URI string which must be freed by the caller, or NULL if there was an error. |
int virConnectGetVersion (virConnectPtr conn,
unsigned long * hvVer)
Get the version level of the Hypervisor running. This may work only with hypervisor call, i.e. with privileged access to the hypervisor, not with a Read-Only connection.
conn: | pointer to the hypervisor connection |
hvVer: | return value for the version of the running hypervisor (OUT) |
Returns: | -1 in case of error, 0 otherwise. if the version can't be extracted by lack of capacities returns 0 and @hvVer is 0, otherwise @hvVer value is major * 1,000,000 + minor * 1,000 + release |
int virConnectIsEncrypted (virConnectPtr conn)
Determine if the connection to the hypervisor is encrypted
conn: | pointer to the connection object |
Returns: | 1 if encrypted, 0 if not encrypted, -1 on error |
int virConnectIsSecure (virConnectPtr conn)
Determine if the connection to the hypervisor is secure A connection will be classed as secure if it is either encrypted, or running over a channel which is not exposed to eavesdropping (eg a UNIX domain socket, or pipe)
conn: | pointer to the connection object |
Returns: | 1 if secure, 0 if secure, -1 on error |
int virConnectListDefinedDomains (virConnectPtr conn,
char ** const names,
int maxnames)
list the defined but inactive domains, stores the pointers to the names in @names
conn: | pointer to the hypervisor connection |
names: | pointer to an array to store the names |
maxnames: | size of the array |
Returns: | the number of names provided in the array or -1 in case of error |
int virConnectListDefinedInterfaces (virConnectPtr conn,
char ** const names,
int maxnames)
Collect the list of defined (inactive) physical host interfaces, and store their names in @names.
conn: | pointer to the hypervisor connection |
names: | array to collect the list of names of interfaces |
maxnames: | size of @names |
Returns: | the number of interfaces found or -1 in case of error |
int virConnectListDefinedNetworks (virConnectPtr conn,
char ** const names,
int maxnames)
list the inactive networks, stores the pointers to the names in @names
conn: | pointer to the hypervisor connection |
names: | pointer to an array to store the names |
maxnames: | size of the array |
Returns: | the number of names provided in the array or -1 in case of error |
int virConnectListDefinedStoragePools (virConnectPtr conn,
char ** const names,
int maxnames)
Provides the list of names of inactive storage pools upto maxnames. If there are more than maxnames, the remaining names will be silently ignored.
conn: | pointer to hypervisor connection |
names: | array of char * to fill with pool names (allocated by caller) |
maxnames: | size of the names array |
Returns: | 0 on success, -1 on error |
int virConnectListDomains (virConnectPtr conn,
int * ids,
int maxids)
Collect the list of active domains, and store their ID in @maxids
conn: | pointer to the hypervisor connection |
ids: | array to collect the list of IDs of active domains |
maxids: | size of @ids |
Returns: | the number of domain found or -1 in case of error |
int virConnectListInterfaces (virConnectPtr conn,
char ** const names,
int maxnames)
Collect the list of active physical host interfaces, and store their names in @names
conn: | pointer to the hypervisor connection |
names: | array to collect the list of names of interfaces |
maxnames: | size of @names |
Returns: | the number of interfaces found or -1 in case of error |
int virConnectListNWFilters (virConnectPtr conn,
char ** const names,
int maxnames)
Collect the list of network filters, and store their names in @names
conn: | pointer to the hypervisor connection |
names: | array to collect the list of names of network filters |
maxnames: | size of @names |
Returns: | the number of network filters found or -1 in case of error |
int virConnectListNetworks (virConnectPtr conn,
char ** const names,
int maxnames)
Collect the list of active networks, and store their names in @names
conn: | pointer to the hypervisor connection |
names: | array to collect the list of names of active networks |
maxnames: | size of @names |
Returns: | the number of networks found or -1 in case of error |
int virConnectListSecrets (virConnectPtr conn,
char ** uuids,
int maxuuids)
List UUIDs of defined secrets, store pointers to names in uuids.
conn: | virConnect connection |
uuids: | Pointer to an array to store the UUIDs |
maxuuids: | size of the array. |
Returns: | the number of UUIDs provided in the array, or -1 on failure. |
int virConnectListStoragePools (virConnectPtr conn,
char ** const names,
int maxnames)
Provides the list of names of active storage pools upto maxnames. If there are more than maxnames, the remaining names will be silently ignored.
conn: | pointer to hypervisor connection |
names: | array of char * to fill with pool names (allocated by caller) |
maxnames: | size of the names array |
Returns: | 0 on success, -1 on error |
int virConnectNumOfDefinedDomains (virConnectPtr conn)
Provides the number of defined but inactive domains.
conn: | pointer to the hypervisor connection |
Returns: | the number of domain found or -1 in case of error |
int virConnectNumOfDefinedInterfaces (virConnectPtr conn)
Provides the number of defined (inactive) interfaces on the physical host.
conn: | pointer to the hypervisor connection |
Returns: | the number of defined interface found or -1 in case of error |
int virConnectNumOfDefinedNetworks (virConnectPtr conn)
Provides the number of inactive networks.
conn: | pointer to the hypervisor connection |
Returns: | the number of networks found or -1 in case of error |
int virConnectNumOfDefinedStoragePools (virConnectPtr conn)
Provides the number of inactive storage pools
conn: | pointer to hypervisor connection |
Returns: | the number of pools found, or -1 on error |
int virConnectNumOfDomains (virConnectPtr conn)
Provides the number of active domains.
conn: | pointer to the hypervisor connection |
Returns: | the number of domain found or -1 in case of error |
int virConnectNumOfInterfaces (virConnectPtr conn)
Provides the number of active interfaces on the physical host.
conn: | pointer to the hypervisor connection |
Returns: | the number of active interfaces found or -1 in case of error |
int virConnectNumOfNWFilters (virConnectPtr conn)
Provides the number of nwfilters.
conn: | pointer to the hypervisor connection |
Returns: | the number of nwfilters found or -1 in case of error |
int virConnectNumOfNetworks (virConnectPtr conn)
Provides the number of active networks.
conn: | pointer to the hypervisor connection |
Returns: | the number of network found or -1 in case of error |
int virConnectNumOfSecrets (virConnectPtr conn)
Fetch number of currently defined secrets.
conn: | virConnect connection |
Returns: | the number currently defined secrets. |
int virConnectNumOfStoragePools (virConnectPtr conn)
Provides the number of active storage pools
conn: | pointer to hypervisor connection |
Returns: | the number of pools found, or -1 on error |
virConnectPtr virConnectOpen (const char * name)
This function should be called first to get a connection to the Hypervisor and xen store
name: | URI of the hypervisor |
Returns: | a pointer to the hypervisor connection or NULL in case of error If @name is NULL then probing will be done to determine a suitable default driver to activate. This involves trying each hypervisor in turn until one successfully opens. If the LIBVIRT_DEFAULT_URI environment variable is set, then it will be used in preference to probing for a driver. If connecting to an unprivileged hypervisor driver which requires the libvirtd daemon to be active, it will automatically be launched if not already running. This can be prevented by setting the environment variable LIBVIRT_AUTOSTART=0 URIs are documented at http://libvirt.org/uri.html |
virConnectPtr virConnectOpenAuth (const char * name,
virConnectAuthPtr auth,
unsigned int flags)
This function should be called first to get a connection to the Hypervisor. If necessary, authentication will be performed fetching credentials via the callback See virConnectOpen for notes about environment variables which can have an effect on opening drivers
name: | URI of the hypervisor |
auth: | Authenticate callback parameters |
flags: | Open flags |
Returns: | a pointer to the hypervisor connection or NULL in case of error URIs are documented at http://libvirt.org/uri.html |
virConnectPtr virConnectOpenReadOnly (const char * name)
This function should be called first to get a restricted connection to the library functionalities. The set of APIs usable are then restricted on the available methods to control the domains. See virConnectOpen for notes about environment variables which can have an effect on opening drivers
name: | URI of the hypervisor |
Returns: | a pointer to the hypervisor connection or NULL in case of error URIs are documented at http://libvirt.org/uri.html |
int virConnectRef (virConnectPtr conn)
Increment the reference count on the connection. For each additional call to this method, there shall be a corresponding call to virConnectClose to release the reference count, once the caller no longer needs the reference to this object. This method is typically useful for applications where multiple threads are using a connection, and it is required that the connection remain open until all threads have finished using it. ie, each new thread using a connection would increment the reference count.
conn: | the connection to hold a reference on |
Returns: | 0 in case of success, -1 in case of failure |
int virDomainAbortJob (virDomainPtr domain)
Requests that the current background job be aborted at the soonest opportunity. This will block until the job has either completed, or aborted.
domain: | a domain object |
Returns: | 0 in case of success and -1 in case of failure. |
int virDomainAttachDevice (virDomainPtr domain,
const char * xml)
Create a virtual device attachment to backend. This function, having hotplug semantics, is only allowed on an active domain. For compatibility, this method can also be used to change the media in an existing CDROM/Floppy device, however, applications are recommended to use the virDomainUpdateDeviceFlag method instead.
domain: | pointer to domain object |
xml: | pointer to XML description of one device |
Returns: | 0 in case of success, -1 in case of failure. |
int virDomainAttachDeviceFlags (virDomainPtr domain,
const char * xml,
unsigned int flags)
Attach a virtual device to a domain, using the flags parameter to control how the device is attached. VIR_DOMAIN_AFFECT_CURRENT specifies that the device allocation is made based on current domain state. VIR_DOMAIN_AFFECT_LIVE specifies that the device shall be allocated to the active domain instance only and is not added to the persisted domain configuration. VIR_DOMAIN_AFFECT_CONFIG specifies that the device shall be allocated to the persisted domain configuration only. Note that the target hypervisor must return an error if unable to satisfy flags. E.g. the hypervisor driver will return failure if LIVE is specified but it only supports modifying the persisted device allocation. For compatibility, this method can also be used to change the media in an existing CDROM/Floppy device, however, applications are recommended to use the virDomainUpdateDeviceFlag method instead.
domain: | pointer to domain object |
xml: | pointer to XML description of one device |
flags: | an OR'ed set of virDomainDeviceModifyFlags |
Returns: | 0 in case of success, -1 in case of failure. |
int virDomainBlockJobAbort (virDomainPtr dom,
const char * path,
unsigned int flags)
Cancel the active block job on the given disk.
dom: | pointer to domain object |
path: | fully-qualified filename of disk |
flags: | currently unused, for future extension |
Returns: | -1 in case of failure, 0 when successful. |
int virDomainBlockJobSetSpeed (virDomainPtr dom,
const char * path,
unsigned long bandwidth,
unsigned int flags)
Set the maximimum allowable bandwidth that a block job may consume. If bandwidth is 0, the limit will revert to the hypervisor default.
dom: | pointer to domain object |
path: | fully-qualified filename of disk |
bandwidth: | specify bandwidth limit in Mbps |
flags: | currently unused, for future extension |
Returns: | -1 in case of failure, 0 when successful. |
int virDomainBlockPeek (virDomainPtr dom,
const char * path,
unsigned long long offset,
size_t size,
void * buffer,
unsigned int flags)
This function allows you to read the contents of a domain's disk device. Typical uses for this are to determine if the domain has written a Master Boot Record (indicating that the domain has completed installation), or to try to work out the state of the domain's filesystems. (Note that in the local case you might try to open the block device or file directly, but that won't work in the remote case, nor if you don't have sufficient permission. Hence the need for this call). 'path' must be a device or file corresponding to the domain. In other words it must be the precise string returned in a <disk><source dev='...'/></disk> from virDomainGetXMLDesc. 'offset' and 'size' represent an area which must lie entirely within the device or file. 'size' may be 0 to test if the call would succeed. 'buffer' is the return buffer and must be at least 'size' bytes. NB. The remote driver imposes a 64K byte limit on 'size'. For your program to be able to work reliably over a remote connection you should split large requests to <= 65536 bytes.
dom: | pointer to the domain object |
path: | path to the block device |
offset: | offset within block device |
size: | size to read |
buffer: | return buffer (must be at least size bytes) |
flags: | unused, always pass 0 |
Returns: | 0 in case of success or -1 in case of failure. really 64 bits |
int virDomainBlockPull (virDomainPtr dom,
const char * path,
unsigned long bandwidth,
unsigned int flags)
Populate a disk image with data from its backing image. Once all data from its backing image has been pulled, the disk no longer depends on a backing image. This function pulls data for the entire device in the background. Progress of the operation can be checked with virDomainGetBlockJobInfo() and the operation can be aborted with virDomainBlockJobAbort(). When finished, an asynchronous event is raised to indicate the final status. The maximum bandwidth (in Mbps) that will be used to do the copy can be specified with the bandwidth parameter. If set to 0, libvirt will choose a suitable default. Some hypervisors do not support this feature and will return an error if bandwidth is not 0.
dom: | pointer to domain object |
path: | Fully-qualified filename of disk |
bandwidth: | (optional) specify copy bandwidth limit in Mbps |
flags: | currently unused, for future extension |
Returns: | 0 if the operation has started, -1 on failure. |
int virDomainBlockStats (virDomainPtr dom,
const char * path,
virDomainBlockStatsPtr stats,
size_t size)
This function returns block device (disk) stats for block devices attached to the domain. The path parameter is the name of the block device. Get this by calling virDomainGetXMLDesc and finding the <target dev='...'> attribute within //domain/devices/disk. (For example, "xvda"). Domains may have more than one block device. To get stats for each you should make multiple calls to this function. Individual fields within the stats structure may be returned as -1, which indicates that the hypervisor does not support that particular statistic.
dom: | pointer to the domain object |
path: | path to the block device |
stats: | block device stats (returned) |
size: | size of stats structure |
Returns: | 0 in case of success or -1 in case of failure. |
int virDomainBlockStatsFlags (virDomainPtr dom,
const char * path,
virTypedParameterPtr params,
int * nparams,
unsigned int flags)
This function is to get block stats parameters for block devices attached to the domain. The @path is the name of the block device. Get this by calling virDomainGetXMLDesc and finding the <target dev='...'> attribute within //domain/devices/disk. (For example, "xvda"). Domains may have more than one block device. To get stats for each you should make multiple calls to this function. The @params array will be filled with the value equal to the number of parameters suggested by @nparams. As the value of @nparams is dynamic, call the API setting @nparams to 0 and @params as NULL, the API returns the number of parameters supported by the HV by updating @nparams on SUCCESS. (Note that block device of different type might support different parameters numbers, so it might be necessary to compute @nparams for each block device type). The caller should then allocate @params array, i.e. (sizeof(@virTypedParameter) * @nparams) bytes and call the API again. See virDomainGetMemoryParameters for more details.
dom: | pointer to domain object |
path: | path to the block device |
params: | pointer to block stats parameter object (return value) |
nparams: | pointer to number of block stats |
flags: | unused, always passes 0 |
Returns: | -1 in case of error, 0 in case of success. |
int virDomainCoreDump (virDomainPtr domain,
const char * to,
unsigned int flags)
This method will dump the core of a domain on a given file for analysis. Note that for remote Xen Daemon the file path will be interpreted in the remote host. Hypervisors may require the user to manually ensure proper permissions on the file named by @to. If @flags includes VIR_DUMP_CRASH, then leave the guest shut off with a crashed state after the dump completes. If @flags includes VIR_DUMP_LIVE, then make the core dump while continuing to allow the guest to run; otherwise, the guest is suspended during the dump. The above two flags are mutually exclusive. Additionally, if @flags includes VIR_DUMP_BYPASS_CACHE, then libvirt will attempt to bypass the file system cache while creating the file, or fail if it cannot do so for the given system; this can allow less pressure on file system cache, but also risks slowing saves to NFS.
domain: | a domain object |
to: | path for the core file |
flags: | an OR'ed set of virDomainCoreDumpFlags |
Returns: | 0 in case of success and -1 in case of failure. |
int virDomainCreate (virDomainPtr domain)
Launch a defined domain. If the call succeeds the domain moves from the defined to the running domains pools. The domain will be paused only if restoring from managed state created from a paused domain. For more control, see virDomainCreateWithFlags().
domain: | pointer to a defined domain |
Returns: | 0 in case of success, -1 in case of error |
virDomainPtr virDomainCreateLinux (virConnectPtr conn,
const char * xmlDesc,
unsigned int flags)
Deprecated after 0.4.6. Renamed to virDomainCreateXML() providing identical functionality. This existing name will left indefinitely for API compatibility.
conn: | pointer to the hypervisor connection |
xmlDesc: | string containing an XML description of the domain |
flags: | callers should always pass 0 |
Returns: | a new domain object or NULL in case of failure |
int virDomainCreateWithFlags (virDomainPtr domain,
unsigned int flags)
Launch a defined domain. If the call succeeds the domain moves from the defined to the running domains pools. If the VIR_DOMAIN_START_PAUSED flag is set, or if the guest domain has a managed save image that requested paused state (see virDomainManagedSave()) the guest domain will be started, but its CPUs will remain paused. The CPUs can later be manually started using virDomainResume(). In all other cases, the guest domain will be running. If the VIR_DOMAIN_START_AUTODESTROY flag is set, the guest domain will be automatically destroyed when the virConnectPtr object is finally released. This will also happen if the client application crashes / loses its connection to the libvirtd daemon. Any domains marked for auto destroy will block attempts at migration, save-to-file, or snapshots. If the VIR_DOMAIN_START_BYPASS_CACHE flag is set, and there is a managed save file for this domain (created by virDomainManagedSave()), then libvirt will attempt to bypass the file system cache while restoring the file, or fail if it cannot do so for the given system; this can allow less pressure on file system cache, but also risks slowing loads from NFS. If the VIR_DOMAIN_START_FORCE_BOOT flag is set, then any managed save file for this domain is discarded, and the domain boots from scratch.
domain: | pointer to a defined domain |
flags: | bitwise-or of supported virDomainCreateFlags |
Returns: | 0 in case of success, -1 in case of error |
virDomainPtr virDomainCreateXML (virConnectPtr conn,
const char * xmlDesc,
unsigned int flags)
Launch a new guest domain, based on an XML description similar to the one returned by virDomainGetXMLDesc() This function may require privileged access to the hypervisor. The domain is not persistent, so its definition will disappear when it is destroyed, or if the host is restarted (see virDomainDefineXML() to define persistent domains). If the VIR_DOMAIN_START_PAUSED flag is set, the guest domain will be started, but its CPUs will remain paused. The CPUs can later be manually started using virDomainResume. If the VIR_DOMAIN_START_AUTODESTROY flag is set, the guest domain will be automatically destroyed when the virConnectPtr object is finally released. This will also happen if the client application crashes / loses its connection to the libvirtd daemon. Any domains marked for auto destroy will block attempts at migration, save-to-file, or snapshots.
conn: | pointer to the hypervisor connection |
xmlDesc: | string containing an XML description of the domain |
flags: | bitwise-or of supported virDomainCreateFlags |
Returns: | a new domain object or NULL in case of failure |
virDomainPtr virDomainDefineXML (virConnectPtr conn,
const char * xml)
Define a domain, but does not start it. This definition is persistent, until explicitly undefined with virDomainUndefine(). A previous definition for this domain would be overriden if it already exists.
conn: | pointer to the hypervisor connection |
xml: | the XML description for the domain, preferably in UTF-8 |
Returns: | NULL in case of error, a pointer to the domain otherwise |
int virDomainDestroy (virDomainPtr domain)
Destroy the domain object. The running instance is shutdown if not down already and all resources used by it are given back to the hypervisor. This does not free the associated virDomainPtr object. This function may require privileged access If the domain is transient and has any snapshot metadata (see virDomainSnapshotNum()), then that metadata will automatically be deleted when the domain quits.
domain: | a domain object |
Returns: | 0 in case of success and -1 in case of failure. |
int virDomainDestroyFlags (virDomainPtr domain,
unsigned int flags)
Destroy the domain object. The running instance is shutdown if not down already and all resources used by it are given back to the hypervisor. This does not free the associated virDomainPtr object. This function may require privileged access. Calling this function with no @flags set (equal to zero) is equivalent to calling virDomainDestroy. Using virDomainShutdown() may produce cleaner results for the guest's disks, but depends on guest support.
domain: | a domain object |
flags: | an OR'ed set of virDomainDestroyFlagsValues |
Returns: | 0 in case of success and -1 in case of failure. |
int virDomainDetachDevice (virDomainPtr domain,
const char * xml)
Destroy a virtual device attachment to backend. This function, having hot-unplug semantics, is only allowed on an active domain.
domain: | pointer to domain object |
xml: | pointer to XML description of one device |
Returns: | 0 in case of success, -1 in case of failure. |
int virDomainDetachDeviceFlags (virDomainPtr domain,
const char * xml,
unsigned int flags)
Detach a virtual device from a domain, using the flags parameter to control how the device is detached. VIR_DOMAIN_AFFECT_CURRENT specifies that the device allocation is removed based on current domain state. VIR_DOMAIN_AFFECT_LIVE specifies that the device shall be deallocated from the active domain instance only and is not from the persisted domain configuration. VIR_DOMAIN_AFFECT_CONFIG specifies that the device shall be deallocated from the persisted domain configuration only. Note that the target hypervisor must return an error if unable to satisfy flags. E.g. the hypervisor driver will return failure if LIVE is specified but it only supports removing the persisted device allocation.
domain: | pointer to domain object |
xml: | pointer to XML description of one device |
flags: | an OR'ed set of virDomainDeviceModifyFlags |
Returns: | 0 in case of success, -1 in case of failure. |
int virDomainFree (virDomainPtr domain)
Free the domain object. The running instance is kept alive. The data structure is freed and should not be used thereafter.
domain: | a domain object |
Returns: | 0 in case of success and -1 in case of failure. |
int virDomainGetAutostart (virDomainPtr domain,
int * autostart)
Provides a boolean value indicating whether the domain configured to be automatically started when the host machine boots.
domain: | a domain object |
autostart: | the value returned |
Returns: | -1 in case of error, 0 in case of success |
int virDomainGetBlkioParameters (virDomainPtr domain,
virTypedParameterPtr params,
int * nparams,
unsigned int flags)
Get all blkio parameters, the @params array will be filled with the values equal to the number of parameters suggested by @nparams. See virDomainGetMemoryParameters for an equivalent usage example. This function may require privileged access to the hypervisor. This function expects the caller to allocate the @params.
domain: | pointer to domain object |
params: | pointer to blkio parameter object (return value, allocated by the caller) |
nparams: | pointer to number of blkio parameters |
flags: | an OR'ed set of virDomainModificationImpact |
Returns: | -1 in case of error, 0 in case of success. |
int virDomainGetBlockInfo (virDomainPtr domain,
const char * path,
virDomainBlockInfoPtr info,
unsigned int flags)
Extract information about a domain's block device.
domain: | a domain object |
path: | path to the block device or file |
info: | pointer to a virDomainBlockInfo structure allocated by the user |
flags: | currently unused, pass zero |
Returns: | 0 in case of success and -1 in case of failure. |
int virDomainGetBlockJobInfo (virDomainPtr dom,
const char * path,
virDomainBlockJobInfoPtr info,
unsigned int flags)
Request block job information for the given disk. If an operation is active @info will be updated with the current progress.
dom: | pointer to domain object |
path: | fully-qualified filename of disk |
info: | pointer to a virDomainBlockJobInfo structure |
flags: | currently unused, for future extension |
Returns: | -1 in case of failure, 0 when nothing found, 1 when info was found. |
virConnectPtr virDomainGetConnect (virDomainPtr dom)
Provides the connection pointer associated with a domain. The reference counter on the connection is not increased by this call. WARNING: When writing libvirt bindings in other languages, do not use this function. Instead, store the connection and the domain object together.
dom: | pointer to a domain |
Returns: | the virConnectPtr or NULL in case of failure. |
int virDomainGetControlInfo (virDomainPtr domain,
virDomainControlInfoPtr info,
unsigned int flags)
Extract details about current state of control interface to a domain.
domain: | a domain object |
info: | pointer to a virDomainControlInfo structure allocated by the user |
flags: | additional flags, 0 for now |
Returns: | 0 in case of success and -1 in case of failure. |
unsigned int virDomainGetID (virDomainPtr domain)
Get the hypervisor ID number for the domain
domain: | a domain object |
Returns: | the domain ID number or (unsigned int) -1 in case of error |
int virDomainGetInfo (virDomainPtr domain,
virDomainInfoPtr info)
Extract information about a domain. Note that if the connection used to get the domain is limited only a partial set of the information can be extracted.
domain: | a domain object |
info: | pointer to a virDomainInfo structure allocated by the user |
Returns: | 0 in case of success and -1 in case of failure. |
int virDomainGetJobInfo (virDomainPtr domain,
virDomainJobInfoPtr info)
Extract information about progress of a background job on a domain. Will return an error if the domain is not active.
domain: | a domain object |
info: | pointer to a virDomainJobInfo structure allocated by the user |
Returns: | 0 in case of success and -1 in case of failure. |
unsigned long virDomainGetMaxMemory (virDomainPtr domain)
Retrieve the maximum amount of physical memory allocated to a domain. If domain is NULL, then this get the amount of memory reserved to Domain0 i.e. the domain where the application runs.
domain: | a domain object or NULL |
Returns: | the memory size in kilobytes or 0 in case of error. |
int virDomainGetMaxVcpus (virDomainPtr domain)
Provides the maximum number of virtual CPUs supported for the guest VM. If the guest is inactive, this is basically the same as virConnectGetMaxVcpus(). If the guest is running this will reflect the maximum number of virtual CPUs the guest was booted with. For more details, see virDomainGetVcpusFlags().
domain: | pointer to domain object |
Returns: | the maximum of virtual CPU or -1 in case of error. |
int virDomainGetMemoryParameters (virDomainPtr domain,
virTypedParameterPtr params,
int * nparams,
unsigned int flags)
Get all memory parameters, the @params array will be filled with the values equal to the number of parameters suggested by @nparams As the value of @nparams is dynamic, call the API setting @nparams to 0 and @params as NULL, the API returns the number of parameters supported by the HV by updating @nparams on SUCCESS. The caller should then allocate @params array, i.e. (sizeof(@virTypedParameter) * @nparams) bytes and call the API again. Here is a sample code snippet: if ((virDomainGetMemoryParameters(dom, NULL, &nparams, 0) == 0) && (nparams != 0)) { if ((params = malloc(sizeof(*params) * nparams)) == NULL) goto error; memset(params, 0, sizeof(*params) * nparams); if (virDomainGetMemoryParameters(dom, params, &nparams, 0)) goto error; } This function may require privileged access to the hypervisor. This function expects the caller to allocate the @params.
domain: | pointer to domain object |
params: | pointer to memory parameter object (return value, allocated by the caller) |
nparams: | pointer to number of memory parameters |
flags: | one of virDomainModificationImpact |
Returns: | -1 in case of error, 0 in case of success. |
const char * virDomainGetName (virDomainPtr domain)
Get the public name for that domain
domain: | a domain object |
Returns: | a pointer to the name or NULL, the string need not be deallocated its lifetime will be the same as the domain object. |
char * virDomainGetOSType (virDomainPtr domain)
Get the type of domain operation system.
domain: | a domain object |
Returns: | the new string or NULL in case of error, the string must be freed by the caller. |
int virDomainGetSchedulerParameters (virDomainPtr domain,
virTypedParameterPtr params,
int * nparams)
Get all scheduler parameters, the @params array will be filled with the values and @nparams will be updated to the number of valid elements in @params. It is hypervisor specific whether this returns the live or persistent state; for more control, use virDomainGetSchedulerParametersFlags.
domain: | pointer to domain object |
params: | pointer to scheduler parameter objects (return value) |
nparams: | pointer to number of scheduler parameter objects (this value must be at least as large as the returned value nparams of virDomainGetSchedulerType) |
Returns: | -1 in case of error, 0 in case of success. |
int virDomainGetSchedulerParametersFlags (virDomainPtr domain,
virTypedParameterPtr params,
int * nparams,
unsigned int flags)
Get the scheduler parameters, the @params array will be filled with the values. The value of @flags can be exactly VIR_DOMAIN_AFFECT_CURRENT, VIR_DOMAIN_AFFECT_LIVE, or VIR_DOMAIN_AFFECT_CONFIG.
domain: | pointer to domain object |
params: | pointer to scheduler parameter object (return value) |
nparams: | pointer to number of scheduler parameter (this value should be same than the returned value nparams of virDomainGetSchedulerType) |
flags: | one of virDomainModificationImpact |
Returns: | -1 in case of error, 0 in case of success. |
char * virDomainGetSchedulerType (virDomainPtr domain,
int * nparams)
Get the scheduler type and the number of scheduler parameters.
domain: | pointer to domain object |
nparams: | pointer to number of scheduler parameters, can be NULL (return value) |
Returns: | NULL in case of error. The caller must free the returned string. |
int virDomainGetSecurityLabel (virDomainPtr domain,
virSecurityLabelPtr seclabel)
Extract security label of an active domain. The 'label' field in the @seclabel argument will be initialized to the empty string if the domain is not running under a security model.
domain: | a domain object |
seclabel: | pointer to a virSecurityLabel structure |
Returns: | 0 in case of success, -1 in case of failure |
int virDomainGetState (virDomainPtr domain,
int * state,
int * reason,
unsigned int flags)
Extract domain state. Each state can be accompanied with a reason (if known) which led to the state.
domain: | a domain object |
state: | returned state of the domain (one of virDomainState) |
reason: | returned reason which led to @state (one of virDomain*Reason corresponding to the current state); it is allowed to be NULL |
flags: | additional flags, 0 for now. |
Returns: | 0 in case of success and -1 in case of failure. |
int virDomainGetUUID (virDomainPtr domain,
unsigned char * uuid)
Get the UUID for a domain
domain: | a domain object |
uuid: | pointer to a VIR_UUID_BUFLEN bytes array |
Returns: | -1 in case of error, 0 in case of success |
int virDomainGetUUIDString (virDomainPtr domain,
char * buf)
Get the UUID for a domain as string. For more information about UUID see RFC4122.
domain: | a domain object |
buf: | pointer to a VIR_UUID_STRING_BUFLEN bytes array |
Returns: | -1 in case of error, 0 in case of success |
int virDomainGetVcpuPinInfo (virDomainPtr domain,
int ncpumaps,
unsigned char * cpumaps,
int maplen,
unsigned int flags)
Query the CPU affinity setting of all virtual CPUs of domain, store it in cpumaps.
domain: | pointer to domain object, or NULL for Domain0 |
ncpumaps: | the number of cpumap (listed first to match virDomainGetVcpus) |
cpumaps: | pointer to a bit map of real CPUs for all vcpus of this domain (in 8-bit bytes) (OUT) It's assumed there is <ncpumaps> cpumap in cpumaps array. The memory allocated to cpumaps must be (ncpumaps * maplen) bytes (ie: calloc(ncpumaps, maplen)). One cpumap inside cpumaps has the format described in virDomainPinVcpu() API. Must not be NULL. |
maplen: | the number of bytes in one cpumap, from 1 up to size of CPU map. Must be positive. |
flags: | an OR'ed set of virDomainModificationImpact Must not be VIR_DOMAIN_AFFECT_LIVE and VIR_DOMAIN_AFFECT_CONFIG concurrently. |
Returns: | the number of virtual CPUs in case of success, -1 in case of failure. |
int virDomainGetVcpus (virDomainPtr domain,
virVcpuInfoPtr info,
int maxinfo,
unsigned char * cpumaps,
int maplen)
Extract information about virtual CPUs of domain, store it in info array and also in cpumaps if this pointer isn't NULL. This call may fail on an inactive domain. See also virDomainGetVcpuPinInfo for querying just cpumaps, including on an inactive domain.
domain: | pointer to domain object, or NULL for Domain0 |
info: | pointer to an array of virVcpuInfo structures (OUT) |
maxinfo: | number of structures in info array |
cpumaps: | pointer to a bit map of real CPUs for all vcpus of this domain (in 8-bit bytes) (OUT) If cpumaps is NULL, then no cpumap information is returned by the API. It's assumed there is <maxinfo> cpumap in cpumaps array. The memory allocated to cpumaps must be (maxinfo * maplen) bytes (ie: calloc(maxinfo, maplen)). One cpumap inside cpumaps has the format described in virDomainPinVcpu() API. |
maplen: | number of bytes in one cpumap, from 1 up to size of CPU map in underlying virtualization system (Xen...). Must be zero when cpumaps is NULL and positive when it is non-NULL. |
Returns: | the number of info filled in case of success, -1 in case of failure. |
int virDomainGetVcpusFlags (virDomainPtr domain,
unsigned int flags)
Query the number of virtual CPUs used by the domain. Note that this call may fail if the underlying virtualization hypervisor does not support it. This function may require privileged access to the hypervisor. If @flags includes VIR_DOMAIN_AFFECT_LIVE, this will query a running domain (which will fail if domain is not active); if it includes VIR_DOMAIN_AFFECT_CONFIG, this will query the XML description of the domain. It is an error to set both flags. If neither flag is set (that is, VIR_DOMAIN_AFFECT_CURRENT), then the configuration queried depends on whether the domain is currently running. If @flags includes VIR_DOMAIN_VCPU_MAXIMUM, then the maximum virtual CPU limit is queried. Otherwise, this call queries the current virtual CPU limit.
domain: | pointer to domain object, or NULL for Domain0 |
flags: | an OR'ed set of virDomainVcpuFlags |
Returns: | 0 in case of success, -1 in case of failure. |
char * virDomainGetXMLDesc (virDomainPtr domain,
unsigned int flags)
Provide an XML description of the domain. The description may be reused later to relaunch the domain with virDomainCreateXML(). No security-sensitive data will be included unless @flags contains VIR_DOMAIN_XML_SECURE; this flag is rejected on read-only connections. If @flags includes VIR_DOMAIN_XML_INACTIVE, then the XML represents the configuration that will be used on the next boot of a persistent domain; otherwise, the configuration represents the currently running domain. If @flags contains VIR_DOMAIN_XML_UPDATE_CPU, then the portion of the domain XML describing CPU capabilities is modified to match actual capabilities of the host.
domain: | a domain object |
flags: | an OR'ed set of virDomainXMLFlags |
Returns: | a 0 terminated UTF-8 encoded XML instance, or NULL in case of error. the caller must free() the returned value. |
int virDomainHasCurrentSnapshot (virDomainPtr domain,
unsigned int flags)
Determine if the domain has a current snapshot.
domain: | pointer to the domain object |
flags: | unused flag parameters; callers should pass 0 |
Returns: | 1 if such snapshot exists, 0 if it doesn't, -1 on error. |
int virDomainHasManagedSaveImage (virDomainPtr dom,
unsigned int flags)
Check if a domain has a managed save image as created by virDomainManagedSave(). Note that any running domain should not have such an image, as it should have been removed on restart.
dom: | pointer to the domain |
flags: | optional flags currently unused |
Returns: | 0 if no image is present, 1 if an image is present, and -1 in case of error |
int virDomainInjectNMI (virDomainPtr domain,
unsigned int flags)
Send NMI to the guest
domain: | pointer to domain object, or NULL for Domain0 |
flags: | the flags for controlling behavior, pass 0 for now |
Returns: | 0 in case of success, -1 in case of failure. |
int virDomainInterfaceStats (virDomainPtr dom,
const char * path,
virDomainInterfaceStatsPtr stats,
size_t size)
This function returns network interface stats for interfaces attached to the domain. The path parameter is the name of the network interface. Domains may have more than one network interface. To get stats for each you should make multiple calls to this function. Individual fields within the stats structure may be returned as -1, which indicates that the hypervisor does not support that particular statistic.
dom: | pointer to the domain object |
path: | path to the interface |
stats: | network interface stats (returned) |
size: | size of stats structure |
Returns: | 0 in case of success or -1 in case of failure. |
int virDomainIsActive (virDomainPtr dom)
Determine if the domain is currently running
dom: | pointer to the domain object |
Returns: | 1 if running, 0 if inactive, -1 on error |
int virDomainIsPersistent (virDomainPtr dom)
Determine if the domain has a persistent configuration which means it will still exist after shutting down
dom: | pointer to the domain object |
Returns: | 1 if persistent, 0 if transient, -1 on error |
int virDomainIsUpdated (virDomainPtr dom)
Determine if the domain has been updated.
dom: | pointer to the domain object |
Returns: | 1 if updated, 0 if not, -1 on error |
virDomainPtr virDomainLookupByID (virConnectPtr conn,
int id)
Try to find a domain based on the hypervisor ID number Note that this won't work for inactive domains which have an ID of -1, in that case a lookup based on the Name or UUId need to be done instead.
conn: | pointer to the hypervisor connection |
id: | the domain ID number |
Returns: | a new domain object or NULL in case of failure. If the domain cannot be found, then VIR_ERR_NO_DOMAIN error is raised. |
virDomainPtr virDomainLookupByName (virConnectPtr conn,
const char * name)
Try to lookup a domain on the given hypervisor based on its name.
conn: | pointer to the hypervisor connection |
name: | name for the domain |
Returns: | a new domain object or NULL in case of failure. If the domain cannot be found, then VIR_ERR_NO_DOMAIN error is raised. |
virDomainPtr virDomainLookupByUUID (virConnectPtr conn,
const unsigned char * uuid)
Try to lookup a domain on the given hypervisor based on its UUID.
conn: | pointer to the hypervisor connection |
uuid: | the raw UUID for the domain |
Returns: | a new domain object or NULL in case of failure. If the domain cannot be found, then VIR_ERR_NO_DOMAIN error is raised. |
virDomainPtr virDomainLookupByUUIDString (virConnectPtr conn,
const char * uuidstr)
Try to lookup a domain on the given hypervisor based on its UUID.
conn: | pointer to the hypervisor connection |
uuidstr: | the string UUID for the domain |
Returns: | a new domain object or NULL in case of failure. If the domain cannot be found, then VIR_ERR_NO_DOMAIN error is raised. |
int virDomainManagedSave (virDomainPtr dom,
unsigned int flags)
This method will suspend a domain and save its memory contents to a file on disk. After the call, if successful, the domain is not listed as running anymore. The difference from virDomainSave() is that libvirt is keeping track of the saved state itself, and will reuse it once the domain is being restarted (automatically or via an explicit libvirt call). As a result any running domain is sure to not have a managed saved image. This also implies that managed save only works on persistent domains, since the domain must still exist in order to use virDomainCreate() to restart it. If @flags includes VIR_DOMAIN_SAVE_BYPASS_CACHE, then libvirt will attempt to bypass the file system cache while creating the file, or fail if it cannot do so for the given system; this can allow less pressure on file system cache, but also risks slowing saves to NFS. Normally, the managed saved state will remember whether the domain was running or paused, and start will resume to the same state. Specifying VIR_DOMAIN_SAVE_RUNNING or VIR_DOMAIN_SAVE_PAUSED in @flags will override the default saved into the file. These two flags are mutually exclusive.
dom: | pointer to the domain |
flags: | bitwise-OR of virDomainSaveRestoreFlags |
Returns: | 0 in case of success or -1 in case of failure |
int virDomainManagedSaveRemove (virDomainPtr dom,
unsigned int flags)
Remove any managed save image for this domain.
dom: | pointer to the domain |
flags: | optional flags currently unused |
Returns: | 0 in case of success, and -1 in case of error |
int virDomainMemoryPeek (virDomainPtr dom,
unsigned long long start,
size_t size,
void * buffer,
unsigned int flags)
This function allows you to read the contents of a domain's memory. The memory which is read is controlled by the 'start', 'size' and 'flags' parameters. If 'flags' is VIR_MEMORY_VIRTUAL then the 'start' and 'size' parameters are interpreted as virtual memory addresses for whichever task happens to be running on the domain at the moment. Although this sounds haphazard it is in fact what you want in order to read Linux kernel state, because it ensures that pointers in the kernel image can be interpreted coherently. 'buffer' is the return buffer and must be at least 'size' bytes. 'size' may be 0 to test if the call would succeed. NB. The remote driver imposes a 64K byte limit on 'size'. For your program to be able to work reliably over a remote connection you should split large requests to <= 65536 bytes.
dom: | pointer to the domain object |
start: | start of memory to peek |
size: | size of memory to peek |
buffer: | return buffer (must be at least size bytes) |
flags: | flags, see below |
Returns: | 0 in case of success or -1 in case of failure. really 64 bits |
int virDomainMemoryStats (virDomainPtr dom,
virDomainMemoryStatPtr stats,
unsigned int nr_stats,
unsigned int flags)
This function provides memory statistics for the domain. Up to 'nr_stats' elements of 'stats' will be populated with memory statistics from the domain. Only statistics supported by the domain, the driver, and this version of libvirt will be returned. Memory Statistics: VIR_DOMAIN_MEMORY_STAT_SWAP_IN: The total amount of data read from swap space (in kb). VIR_DOMAIN_MEMORY_STAT_SWAP_OUT: The total amount of memory written out to swap space (in kb). VIR_DOMAIN_MEMORY_STAT_MAJOR_FAULT: The number of page faults that required disk IO to service. VIR_DOMAIN_MEMORY_STAT_MINOR_FAULT: The number of page faults serviced without disk IO. VIR_DOMAIN_MEMORY_STAT_UNUSED: The amount of memory which is not being used for any purpose (in kb). VIR_DOMAIN_MEMORY_STAT_AVAILABLE: The total amount of memory available to the domain's OS (in kb). VIR_DOMAIN_MEMORY_STAT_ACTUAL_BALLOON: Current balloon value (in kb).
dom: | pointer to the domain object |
stats: | nr_stats-sized array of stat structures (returned) |
nr_stats: | number of memory statistics requested |
flags: | unused, always pass 0 |
Returns: | The number of stats provided or -1 in case of failure. |
virDomainPtr virDomainMigrate (virDomainPtr domain,
virConnectPtr dconn,
unsigned long flags,
const char * dname,
const char * uri,
unsigned long bandwidth)
Migrate the domain object from its current host to the destination host given by dconn (a connection to the destination host). Flags may be one of more of the following: VIR_MIGRATE_LIVE Do not pause the VM during migration VIR_MIGRATE_PEER2PEER Direct connection between source & destination hosts VIR_MIGRATE_TUNNELLED Tunnel migration data over the libvirt RPC channel VIR_MIGRATE_PERSIST_DEST If the migration is successful, persist the domain on the destination host. VIR_MIGRATE_UNDEFINE_SOURCE If the migration is successful, undefine the domain on the source host. VIR_MIGRATE_PAUSED Leave the domain suspended on the remote side. VIR_MIGRATE_CHANGE_PROTECTION Protect against domain configuration changes during the migration process (set automatically when supported). VIR_MIGRATE_TUNNELLED requires that VIR_MIGRATE_PEER2PEER be set. Applications using the VIR_MIGRATE_PEER2PEER flag will probably prefer to invoke virDomainMigrateToURI, avoiding the need to open connection to the destination host themselves. If a hypervisor supports renaming domains during migration, then you may set the dname parameter to the new name (otherwise it keeps the same name). If this is not supported by the hypervisor, dname must be NULL or else you will get an error. If the VIR_MIGRATE_PEER2PEER flag is set, the uri parameter must be a valid libvirt connection URI, by which the source libvirt driver can connect to the destination libvirt. If omitted, the dconn connection object will be queried for its current URI. If the VIR_MIGRATE_PEER2PEER flag is NOT set, the URI parameter takes a hypervisor specific format. The hypervisor capabilities XML includes details of the support URI schemes. If omitted the dconn will be asked for a default URI. In either case it is typically only necessary to specify a URI if the destination host has multiple interfaces and a specific interface is required to transmit migration data. The maximum bandwidth (in Mbps) that will be used to do migration can be specified with the bandwidth parameter. If set to 0, libvirt will choose a suitable default. Some hypervisors do not support this feature and will return an error if bandwidth is not 0. To see which features are supported by the current hypervisor, see virConnectGetCapabilities, /capabilities/host/migration_features. There are many limitations on migration imposed by the underlying technology - for example it may not be possible to migrate between different processors even with the same architecture, or between different types of hypervisor.
domain: | a domain object |
dconn: | destination host (a connection object) |
flags: | flags |
dname: | (optional) rename domain to this at destination |
uri: | (optional) dest hostname/URI as seen from the source host |
bandwidth: | (optional) specify migration bandwidth limit in Mbps |
Returns: | the new domain object if the migration was successful, or NULL in case of error. Note that the new domain object exists in the scope of the destination connection (dconn). |
virDomainPtr virDomainMigrate2 (virDomainPtr domain,
virConnectPtr dconn,
const char * dxml,
unsigned long flags,
const char * dname,
const char * uri,
unsigned long bandwidth)
Migrate the domain object from its current host to the destination host given by dconn (a connection to the destination host). Flags may be one of more of the following: VIR_MIGRATE_LIVE Do not pause the VM during migration VIR_MIGRATE_PEER2PEER Direct connection between source & destination hosts VIR_MIGRATE_TUNNELLED Tunnel migration data over the libvirt RPC channel VIR_MIGRATE_PERSIST_DEST If the migration is successful, persist the domain on the destination host. VIR_MIGRATE_UNDEFINE_SOURCE If the migration is successful, undefine the domain on the source host. VIR_MIGRATE_PAUSED Leave the domain suspended on the remote side. VIR_MIGRATE_CHANGE_PROTECTION Protect against domain configuration changes during the migration process (set automatically when supported). VIR_MIGRATE_TUNNELLED requires that VIR_MIGRATE_PEER2PEER be set. Applications using the VIR_MIGRATE_PEER2PEER flag will probably prefer to invoke virDomainMigrateToURI, avoiding the need to open connection to the destination host themselves. If a hypervisor supports renaming domains during migration, then you may set the dname parameter to the new name (otherwise it keeps the same name). If this is not supported by the hypervisor, dname must be NULL or else you will get an error. If the VIR_MIGRATE_PEER2PEER flag is set, the uri parameter must be a valid libvirt connection URI, by which the source libvirt driver can connect to the destination libvirt. If omitted, the dconn connection object will be queried for its current URI. If the VIR_MIGRATE_PEER2PEER flag is NOT set, the URI parameter takes a hypervisor specific format. The hypervisor capabilities XML includes details of the support URI schemes. If omitted the dconn will be asked for a default URI. In either case it is typically only necessary to specify a URI if the destination host has multiple interfaces and a specific interface is required to transmit migration data. The maximum bandwidth (in Mbps) that will be used to do migration can be specified with the bandwidth parameter. If set to 0, libvirt will choose a suitable default. Some hypervisors do not support this feature and will return an error if bandwidth is not 0. To see which features are supported by the current hypervisor, see virConnectGetCapabilities, /capabilities/host/migration_features. There are many limitations on migration imposed by the underlying technology - for example it may not be possible to migrate between different processors even with the same architecture, or between different types of hypervisor. If the hypervisor supports it, @dxml can be used to alter host-specific portions of the domain XML that will be used on the destination. For example, it is possible to alter the backing filename that is associated with a disk device, in order to account for naming differences between source and destination in accessing the underlying storage. The migration will fail if @dxml would cause any guest-visible changes. Pass NULL if no changes are needed to the XML between source and destination.
domain: | a domain object |
dconn: | destination host (a connection object) |
dxml: | (optional) XML config for launching guest on target |
flags: | flags |
dname: | (optional) rename domain to this at destination |
uri: | (optional) dest hostname/URI as seen from the source host |
bandwidth: | (optional) specify migration bandwidth limit in Mbps |
Returns: | the new domain object if the migration was successful, or NULL in case of error. Note that the new domain object exists in the scope of the destination connection (dconn). |
int virDomainMigrateGetMaxSpeed (virDomainPtr domain,
unsigned long * bandwidth,
unsigned int flags)
Get the current maximum bandwidth (in Mbps) that will be used if the domain is migrated. Not all hypervisors will support a bandwidth limit.
domain: | a domain object |
bandwidth: | return value of current migration bandwidth limit in Mbps |
flags: | fine-tuning flags, currently unused, use 0 |
Returns: | 0 in case of success, -1 otherwise. |
int virDomainMigrateSetMaxDowntime (virDomainPtr domain,
unsigned long long downtime,
unsigned int flags)
Sets maximum tolerable time for which the domain is allowed to be paused at the end of live migration. It's supposed to be called while the domain is being live-migrated as a reaction to migration progress.
domain: | a domain object |
downtime: | maximum tolerable downtime for live migration, in milliseconds |
flags: | fine-tuning flags, currently unused, use 0 |
Returns: | 0 in case of success, -1 otherwise. |
int virDomainMigrateSetMaxSpeed (virDomainPtr domain,
unsigned long bandwidth,
unsigned int flags)
The maximum bandwidth (in Mbps) that will be used to do migration can be specified with the bandwidth parameter. Not all hypervisors will support a bandwidth cap
domain: | a domain object |
bandwidth: | migration bandwidth limit in Mbps |
flags: | fine-tuning flags, currently unused, use 0 |
Returns: | 0 in case of success, -1 otherwise. |
int virDomainMigrateToURI (virDomainPtr domain,
const char * duri,
unsigned long flags,
const char * dname,
unsigned long bandwidth)
Migrate the domain object from its current host to the destination host given by duri. Flags may be one of more of the following: VIR_MIGRATE_LIVE Do not pause the VM during migration VIR_MIGRATE_PEER2PEER Direct connection between source & destination hosts VIR_MIGRATE_TUNNELLED Tunnel migration data over the libvirt RPC channel VIR_MIGRATE_PERSIST_DEST If the migration is successful, persist the domain on the destination host. VIR_MIGRATE_UNDEFINE_SOURCE If the migration is successful, undefine the domain on the source host. VIR_MIGRATE_CHANGE_PROTECTION Protect against domain configuration changes during the migration process (set automatically when supported). The operation of this API hinges on the VIR_MIGRATE_PEER2PEER flag. If the VIR_MIGRATE_PEER2PEER flag is NOT set, the duri parameter takes a hypervisor specific format. The uri_transports element of the hypervisor capabilities XML includes details of the supported URI schemes. Not all hypervisors will support this mode of migration, so if the VIR_MIGRATE_PEER2PEER flag is not set, then it may be necessary to use the alternative virDomainMigrate API providing and explicit virConnectPtr for the destination host. If the VIR_MIGRATE_PEER2PEER flag IS set, the duri parameter must be a valid libvirt connection URI, by which the source libvirt driver can connect to the destination libvirt. VIR_MIGRATE_TUNNELLED requires that VIR_MIGRATE_PEER2PEER be set. If a hypervisor supports renaming domains during migration, the dname parameter specifies the new name for the domain. Setting dname to NULL keeps the domain name the same. If domain renaming is not supported by the hypervisor, dname must be NULL or else an error will be returned. The maximum bandwidth (in Mbps) that will be used to do migration can be specified with the bandwidth parameter. If set to 0, libvirt will choose a suitable default. Some hypervisors do not support this feature and will return an error if bandwidth is not 0. To see which features are supported by the current hypervisor, see virConnectGetCapabilities, /capabilities/host/migration_features. There are many limitations on migration imposed by the underlying technology - for example it may not be possible to migrate between different processors even with the same architecture, or between different types of hypervisor.
domain: | a domain object |
duri: | mandatory URI for the destination host |
flags: | flags |
dname: | (optional) rename domain to this at destination |
bandwidth: | (optional) specify migration bandwidth limit in Mbps |
Returns: | 0 if the migration succeeded, -1 upon error. |
int virDomainMigrateToURI2 (virDomainPtr domain,
const char * dconnuri,
const char * miguri,
const char * dxml,
unsigned long flags,
const char * dname,
unsigned long bandwidth)
Migrate the domain object from its current host to the destination host given by duri. Flags may be one of more of the following: VIR_MIGRATE_LIVE Do not pause the VM during migration VIR_MIGRATE_PEER2PEER Direct connection between source & destination hosts VIR_MIGRATE_TUNNELLED Tunnel migration data over the libvirt RPC channel VIR_MIGRATE_PERSIST_DEST If the migration is successful, persist the domain on the destination host. VIR_MIGRATE_UNDEFINE_SOURCE If the migration is successful, undefine the domain on the source host. VIR_MIGRATE_CHANGE_PROTECTION Protect against domain configuration changes during the migration process (set automatically when supported). The operation of this API hinges on the VIR_MIGRATE_PEER2PEER flag. If the VIR_MIGRATE_PEER2PEER flag is set, the @dconnuri parameter must be a valid libvirt connection URI, by which the source libvirt driver can connect to the destination libvirt. If the VIR_MIGRATE_PEER2PEER flag is NOT set, then @dconnuri must be NULL. If the VIR_MIGRATE_TUNNELLED flag is NOT set, then the @miguri parameter allows specification of a URI to use to initiate the VM migration. It takes a hypervisor specific format. The uri_transports element of the hypervisor capabilities XML includes details of the supported URI schemes. VIR_MIGRATE_TUNNELLED requires that VIR_MIGRATE_PEER2PEER be set. If a hypervisor supports changing the configuration of the guest during migration, the @dxml parameter specifies the new config for the guest. The configuration must include an identical set of virtual devices, to ensure a stable guest ABI across migration. Only parameters related to host side configuration can be changed in the XML. Hypervisors will validate this and refuse to allow migration if the provided XML would cause a change in the guest ABI, If a hypervisor supports renaming domains during migration, the dname parameter specifies the new name for the domain. Setting dname to NULL keeps the domain name the same. If domain renaming is not supported by the hypervisor, dname must be NULL or else an error will be returned. The maximum bandwidth (in Mbps) that will be used to do migration can be specified with the bandwidth parameter. If set to 0, libvirt will choose a suitable default. Some hypervisors do not support this feature and will return an error if bandwidth is not 0. To see which features are supported by the current hypervisor, see virConnectGetCapabilities, /capabilities/host/migration_features. There are many limitations on migration imposed by the underlying technology - for example it may not be possible to migrate between different processors even with the same architecture, or between different types of hypervisor.
domain: | a domain object |
dconnuri: | (optional) URI for target libvirtd if @flags includes VIR_MIGRATE_PEER2PEER |
miguri: | (optional) URI for invoking the migration, not if @flags includs VIR_MIGRATE_TUNNELLED |
dxml: | (optional) XML config for launching guest on target |
flags: | flags |
dname: | (optional) rename domain to this at destination |
bandwidth: | (optional) specify migration bandwidth limit in Mbps |
Returns: | 0 if the migration succeeded, -1 upon error. |
int virDomainOpenConsole (virDomainPtr dom,
const char * dev_name,
virStreamPtr st,
unsigned int flags)
This opens the backend associated with a console, serial or parallel port device on a guest, if the backend is supported. If the @dev_name is omitted, then the first console or serial device is opened. The console is associated with the passed in @st stream, which should have been opened in non-blocking mode for bi-directional I/O.
dom: | a domain object |
dev_name: | the console, serial or parallel port device alias, or NULL |
st: | a stream to associate with the console |
flags: | unused, pass 0 |
Returns: | 0 if the console was opened, -1 on error |
int virDomainPinVcpu (virDomainPtr domain,
unsigned int vcpu,
unsigned char * cpumap,
int maplen)
Dynamically change the real CPUs which can be allocated to a virtual CPU. This function may require privileged access to the hypervisor. This command only changes the runtime configuration of the domain, so can only be called on an active domain.
domain: | pointer to domain object, or NULL for Domain0 |
vcpu: | virtual CPU number |
cpumap: | pointer to a bit map of real CPUs (in 8-bit bytes) (IN) Each bit set to 1 means that corresponding CPU is usable. Bytes are stored in little-endian order: CPU0-7, 8-15... In each byte, lowest CPU number is least significant bit. |
maplen: | number of bytes in cpumap, from 1 up to size of CPU map in underlying virtualization system (Xen...). If maplen < size, missing bytes are set to zero. If maplen > size, failure code is returned. |
Returns: | 0 in case of success, -1 in case of failure. |
int virDomainPinVcpuFlags (virDomainPtr domain,
unsigned int vcpu,
unsigned char * cpumap,
int maplen,
unsigned int flags)
Dynamically change the real CPUs which can be allocated to a virtual CPU. This function may require privileged access to the hypervisor. @flags may include VIR_DOMAIN_AFFECT_LIVE or VIR_DOMAIN_AFFECT_CONFIG. Both flags may be set. If VIR_DOMAIN_AFFECT_LIVE is set, the change affects a running domain and may fail if domain is not alive. If VIR_DOMAIN_AFFECT_CONFIG is set, the change affects persistent state, and will fail for transient domains. If neither flag is specified (that is, @flags is VIR_DOMAIN_AFFECT_CURRENT), then an inactive domain modifies persistent setup, while an active domain is hypervisor-dependent on whether just live or both live and persistent state is changed. Not all hypervisors can support all flag combinations. See also virDomainGetVcpuPinInfo for querying this information.
domain: | pointer to domain object, or NULL for Domain0 |
vcpu: | virtual CPU number |
cpumap: | pointer to a bit map of real CPUs (in 8-bit bytes) (IN) Each bit set to 1 means that corresponding CPU is usable. Bytes are stored in little-endian order: CPU0-7, 8-15... In each byte, lowest CPU number is least significant bit. |
maplen: | number of bytes in cpumap, from 1 up to size of CPU map in underlying virtualization system (Xen...). If maplen < size, missing bytes are set to zero. If maplen > size, failure code is returned. |
flags: | bitwise-OR of virDomainModificationImpac |
Returns: | 0 in case of success, -1 in case of failure. |
int virDomainReboot (virDomainPtr domain,
unsigned int flags)
Reboot a domain, the domain object is still usable there after but the domain OS is being stopped for a restart. Note that the guest OS may ignore the request.
domain: | a domain object |
flags: | extra flags for the reboot operation, not used yet |
Returns: | 0 in case of success and -1 in case of failure. |
int virDomainRef (virDomainPtr domain)
Increment the reference count on the domain. For each additional call to this method, there shall be a corresponding call to virDomainFree to release the reference count, once the caller no longer needs the reference to this object. This method is typically useful for applications where multiple threads are using a connection, and it is required that the connection remain open until all threads have finished using it. ie, each new thread using a domain would increment the reference count.
domain: | the domain to hold a reference on |
Returns: | 0 in case of success and -1 in case of failure. |
int virDomainRestore (virConnectPtr conn,
const char * from)
This method will restore a domain saved to disk by virDomainSave(). See virDomainRestoreFlags() for more control.
conn: | pointer to the hypervisor connection |
from: | path to the input file |
Returns: | 0 in case of success and -1 in case of failure. |
int virDomainRestoreFlags (virConnectPtr conn,
const char * from,
const char * dxml,
unsigned int flags)
This method will restore a domain saved to disk by virDomainSave(). If the hypervisor supports it, @dxml can be used to alter host-specific portions of the domain XML that will be used when restoring an image. For example, it is possible to alter the backing filename that is associated with a disk device, in order to prepare for file renaming done as part of backing up the disk device while the domain is stopped. If @flags includes VIR_DOMAIN_SAVE_BYPASS_CACHE, then libvirt will attempt to bypass the file system cache while restoring the file, or fail if it cannot do so for the given system; this can allow less pressure on file system cache, but also risks slowing saves to NFS. Normally, the saved state file will remember whether the domain was running or paused, and restore defaults to the same state. Specifying VIR_DOMAIN_SAVE_RUNNING or VIR_DOMAIN_SAVE_PAUSED in @flags will override the default read from the file. These two flags are mutually exclusive.
conn: | pointer to the hypervisor connection |
from: | path to the input file |
dxml: | (optional) XML config for adjusting guest xml used on restore |
flags: | bitwise-OR of virDomainSaveRestoreFlags |
Returns: | 0 in case of success and -1 in case of failure. |
int virDomainResume (virDomainPtr domain)
Resume a suspended domain, the process is restarted from the state where it was frozen by calling virSuspendDomain(). This function may require privileged access
domain: | a domain object |
Returns: | 0 in case of success and -1 in case of failure. |
int virDomainRevertToSnapshot (virDomainSnapshotPtr snapshot,
unsigned int flags)
Revert the domain to a given snapshot. Normally, the domain will revert to the same state the domain was in while the snapshot was taken (whether inactive, running, or paused), except that disk snapshots default to reverting to inactive state. Including VIR_DOMAIN_SNAPSHOT_REVERT_RUNNING in @flags overrides the snapshot state to guarantee a running domain after the revert; or including VIR_DOMAIN_SNAPSHOT_REVERT_PAUSED in @flags guarantees a paused domain after the revert. These two flags are mutually exclusive. While a persistent domain does not need either flag, it is not possible to revert a transient domain into an inactive state, so transient domains require the use of one of these two flags.
snapshot: | a domain snapshot object |
flags: | bitwise-OR of virDomainSnapshotRevertFlags |
Returns: | 0 if the creation is successful, -1 on error. |
int virDomainSave (virDomainPtr domain,
const char * to)
This method will suspend a domain and save its memory contents to a file on disk. After the call, if successful, the domain is not listed as running anymore (this ends the life of a transient domain). Use virDomainRestore() to restore a domain after saving. See virDomainSaveFlags() for more control. Also, a save file can be inspected or modified slightly with virDomainSaveImageGetXMLDesc() and virDomainSaveImageDefineXML().
domain: | a domain object |
to: | path for the output file |
Returns: | 0 in case of success and -1 in case of failure. |
int virDomainSaveFlags (virDomainPtr domain,
const char * to,
const char * dxml,
unsigned int flags)
This method will suspend a domain and save its memory contents to a file on disk. After the call, if successful, the domain is not listed as running anymore (this ends the life of a transient domain). Use virDomainRestore() to restore a domain after saving. If the hypervisor supports it, @dxml can be used to alter host-specific portions of the domain XML that will be used when restoring an image. For example, it is possible to alter the backing filename that is associated with a disk device, in order to prepare for file renaming done as part of backing up the disk device while the domain is stopped. If @flags includes VIR_DOMAIN_SAVE_BYPASS_CACHE, then libvirt will attempt to bypass the file system cache while creating the file, or fail if it cannot do so for the given system; this can allow less pressure on file system cache, but also risks slowing saves to NFS. Normally, the saved state file will remember whether the domain was running or paused, and restore defaults to the same state. Specifying VIR_DOMAIN_SAVE_RUNNING or VIR_DOMAIN_SAVE_PAUSED in @flags will override what state gets saved into the file. These two flags are mutually exclusive. A save file can be inspected or modified slightly with virDomainSaveImageGetXMLDesc() and virDomainSaveImageDefineXML().
domain: | a domain object |
to: | path for the output file |
dxml: | (optional) XML config for adjusting guest xml used on restore |
flags: | bitwise-OR of virDomainSaveRestoreFlags |
Returns: | 0 in case of success and -1 in case of failure. |
int virDomainSaveImageDefineXML (virConnectPtr conn,
const char * file,
const char * dxml,
unsigned int flags)
This updates the definition of a domain stored in a saved state file. @file must be a file created previously by virDomainSave() or virDomainSaveFlags(). @dxml can be used to alter host-specific portions of the domain XML that will be used when restoring an image. For example, it is possible to alter the backing filename that is associated with a disk device, to match renaming done as part of backing up the disk device while the domain is stopped. Normally, the saved state file will remember whether the domain was running or paused, and restore defaults to the same state. Specifying VIR_DOMAIN_SAVE_RUNNING or VIR_DOMAIN_SAVE_PAUSED in @flags will override the default saved into the file; omitting both leaves the file's default unchanged. These two flags are mutually exclusive.
conn: | pointer to the hypervisor connection |
file: | path to saved state file |
dxml: | XML config for adjusting guest xml used on restore |
flags: | bitwise-OR of virDomainSaveRestoreFlags |
Returns: | 0 in case of success and -1 in case of failure. |
char * virDomainSaveImageGetXMLDesc (virConnectPtr conn,
const char * file,
unsigned int flags)
This method will extract the XML describing the domain at the time a saved state file was created. @file must be a file created previously by virDomainSave() or virDomainSaveFlags(). No security-sensitive data will be included unless @flags contains VIR_DOMAIN_XML_SECURE; this flag is rejected on read-only connections. For this API, @flags should not contain either VIR_DOMAIN_XML_INACTIVE or VIR_DOMAIN_XML_UPDATE_CPU.
conn: | pointer to the hypervisor connection |
file: | path to saved state file |
flags: | bitwise-OR of subset of virDomainXMLFlags |
Returns: | a 0 terminated UTF-8 encoded XML instance, or NULL in case of error. The caller must free() the returned value. |
char * virDomainScreenshot (virDomainPtr domain,
virStreamPtr stream,
unsigned int screen,
unsigned int flags)
Take a screenshot of current domain console as a stream. The image format is hypervisor specific. Moreover, some hypervisors supports multiple displays per domain. These can be distinguished by @screen argument. This call sets up a stream; subsequent use of stream API is necessary to transfer actual data, determine how much data is successfully transfered, and detect any errors. The screen ID is the sequential number of screen. In case of multiple graphics cards, heads are enumerated before devices, e.g. having two graphics cards, both with four heads, screen ID 5 addresses the second head on the second card.
domain: | a domain object |
stream: | stream to use as output |
screen: | monitor ID to take screenshot from |
flags: | extra flags, currently unused |
Returns: | a string representing the mime-type of the image format, or NULL upon error. The caller must free() the returned value. |
int virDomainSendKey (virDomainPtr domain,
unsigned int codeset,
unsigned int holdtime,
unsigned int * keycodes,
int nkeycodes,
unsigned int flags)
Send key(s) to the guest.
domain: | pointer to domain object, or NULL for Domain0 |
codeset: | the code set of keycodes, from virKeycodeSet |
holdtime: | the duration (in milliseconds) that the keys will be held |
keycodes: | array of keycodes |
nkeycodes: | number of keycodes, up to VIR_DOMAIN_SEND_KEY_MAX_KEYS |
flags: | the flags for controlling behavior, pass 0 for now |
Returns: | 0 in case of success, -1 in case of failure. |
int virDomainSetAutostart (virDomainPtr domain,
int autostart)
Configure the domain to be automatically started when the host machine boots.
domain: | a domain object |
autostart: | whether the domain should be automatically started 0 or 1 |
Returns: | -1 in case of error, 0 in case of success |
int virDomainSetBlkioParameters (virDomainPtr domain,
virTypedParameterPtr params,
int nparams,
unsigned int flags)
Change all or a subset of the blkio tunables. This function may require privileged access to the hypervisor.
domain: | pointer to domain object |
params: | pointer to blkio parameter objects |
nparams: | number of blkio parameters (this value can be the same or less than the number of parameters supported) |
flags: | an OR'ed set of virDomainModificationImpact |
Returns: | -1 in case of error, 0 in case of success. |
int virDomainSetMaxMemory (virDomainPtr domain,
unsigned long memory)
Dynamically change the maximum amount of physical memory allocated to a domain. If domain is NULL, then this change the amount of memory reserved to Domain0 i.e. the domain where the application runs. This function may require privileged access to the hypervisor. This command is hypervisor-specific for whether active, persistent, or both configurations are changed; for more control, use virDomainSetMemoryFlags().
domain: | a domain object or NULL |
memory: | the memory size in kilobytes |
Returns: | 0 in case of success and -1 in case of failure. |
int virDomainSetMemory (virDomainPtr domain,
unsigned long memory)
Dynamically change the target amount of physical memory allocated to a domain. If domain is NULL, then this change the amount of memory reserved to Domain0 i.e. the domain where the application runs. This function may require privileged access to the hypervisor. This command only changes the runtime configuration of the domain, so can only be called on an active domain.
domain: | a domain object or NULL |
memory: | the memory size in kilobytes |
Returns: | 0 in case of success and -1 in case of failure. |
int virDomainSetMemoryFlags (virDomainPtr domain,
unsigned long memory,
unsigned int flags)
Dynamically change the target amount of physical memory allocated to a domain. If domain is NULL, then this change the amount of memory reserved to Domain0 i.e. the domain where the application runs. This function may require privileged access to the hypervisor. @flags may include VIR_DOMAIN_AFFECT_LIVE or VIR_DOMAIN_AFFECT_CONFIG. Both flags may be set. If VIR_DOMAIN_AFFECT_LIVE is set, the change affects a running domain and will fail if domain is not active. If VIR_DOMAIN_AFFECT_CONFIG is set, the change affects persistent state, and will fail for transient domains. If neither flag is specified (that is, @flags is VIR_DOMAIN_AFFECT_CURRENT), then an inactive domain modifies persistent setup, while an active domain is hypervisor-dependent on whether just live or both live and persistent state is changed. If VIR_DOMAIN_MEM_MAXIMUM is set, the change affects domain's maximum memory size rather than current memory size. Not all hypervisors can support all flag combinations.
domain: | a domain object or NULL |
memory: | the memory size in kilobytes |
flags: | an OR'ed set of virDomainMemoryModFlags |
Returns: | 0 in case of success, -1 in case of failure. |
int virDomainSetMemoryParameters (virDomainPtr domain,
virTypedParameterPtr params,
int nparams,
unsigned int flags)
Change all or a subset of the memory tunables. This function may require privileged access to the hypervisor.
domain: | pointer to domain object |
params: | pointer to memory parameter objects |
nparams: | number of memory parameter (this value can be the same or less than the number of parameters supported) |
flags: | bitwise-OR of virDomainModificationImpact |
Returns: | -1 in case of error, 0 in case of success. |
int virDomainSetSchedulerParameters (virDomainPtr domain,
virTypedParameterPtr params,
int nparams)
Change all or a subset or the scheduler parameters. It is hypervisor-specific whether this sets live, persistent, or both settings; for more control, use virDomainSetSchedulerParametersFlags.
domain: | pointer to domain object |
params: | pointer to scheduler parameter objects |
nparams: | number of scheduler parameter objects (this value can be the same or less than the returned value nparams of virDomainGetSchedulerType) |
Returns: | -1 in case of error, 0 in case of success. |
int virDomainSetSchedulerParametersFlags (virDomainPtr domain,
virTypedParameterPtr params,
int nparams,
unsigned int flags)
Change a subset or all scheduler parameters. The value of @flags should be either VIR_DOMAIN_AFFECT_CURRENT, or a bitwise-or of values from VIR_DOMAIN_AFFECT_LIVE and VIR_DOMAIN_AFFECT_CURRENT, although hypervisors vary in which flags are supported.
domain: | pointer to domain object |
params: | pointer to scheduler parameter objects |
nparams: | number of scheduler parameter objects (this value can be the same or less than the returned value nparams of virDomainGetSchedulerType) |
flags: | bitwise-OR of virDomainModificationImpact |
Returns: | -1 in case of error, 0 in case of success. |
int virDomainSetVcpus (virDomainPtr domain,
unsigned int nvcpus)
Dynamically change the number of virtual CPUs used by the domain. Note that this call may fail if the underlying virtualization hypervisor does not support it or if growing the number is arbitrary limited. This function may require privileged access to the hypervisor. This command only changes the runtime configuration of the domain, so can only be called on an active domain. It is hypervisor-dependent whether it also affects persistent configuration; for more control, use virDomainSetVcpusFlags().
domain: | pointer to domain object, or NULL for Domain0 |
nvcpus: | the new number of virtual CPUs for this domain |
Returns: | 0 in case of success, -1 in case of failure. |
int virDomainSetVcpusFlags (virDomainPtr domain,
unsigned int nvcpus,
unsigned int flags)
Dynamically change the number of virtual CPUs used by the domain. Note that this call may fail if the underlying virtualization hypervisor does not support it or if growing the number is arbitrary limited. This function may require privileged access to the hypervisor. @flags may include VIR_DOMAIN_AFFECT_LIVE to affect a running domain (which may fail if domain is not active), or VIR_DOMAIN_AFFECT_CONFIG to affect the next boot via the XML description of the domain. Both flags may be set. If neither flag is specified (that is, @flags is VIR_DOMAIN_AFFECT_CURRENT), then an inactive domain modifies persistent setup, while an active domain is hypervisor-dependent on whether just live or both live and persistent state is changed. If @flags includes VIR_DOMAIN_VCPU_MAXIMUM, then VIR_DOMAIN_AFFECT_LIVE must be clear, and only the maximum virtual CPU limit is altered; generally, this value must be less than or equal to virConnectGetMaxVcpus(). Otherwise, this call affects the current virtual CPU limit, which must be less than or equal to the maximum limit. Not all hypervisors can support all flag combinations.
domain: | pointer to domain object, or NULL for Domain0 |
nvcpus: | the new number of virtual CPUs for this domain, must be at least 1 |
flags: | an OR'ed set of virDomainVcpuFlags |
Returns: | 0 in case of success, -1 in case of failure. |
int virDomainShutdown (virDomainPtr domain)
Shutdown a domain, the domain object is still usable thereafter but the domain OS is being stopped. Note that the guest OS may ignore the request. For guests that react to a shutdown request, the differences from virDomainDestroy() are that the guests disk storage will be in a stable state rather than having the (virtual) power cord pulled, and this command returns as soon as the shutdown request is issued rather than blocking until the guest is no longer running. If the domain is transient and has any snapshot metadata (see virDomainSnapshotNum()), then that metadata will automatically be deleted when the domain quits.
domain: | a domain object |
Returns: | 0 in case of success and -1 in case of failure. |
virDomainSnapshotPtr virDomainSnapshotCreateXML (virDomainPtr domain,
const char * xmlDesc,
unsigned int flags)
Creates a new snapshot of a domain based on the snapshot xml contained in xmlDesc. If @flags is 0, the domain can be active, in which case the snapshot will be a system checkpoint (both disk state and runtime VM state such as RAM contents), where reverting to the snapshot is the same as resuming from hibernation (TCP connections may have timed out, but everything else picks up where it left off); or the domain can be inactive, in which case the snapshot includes just the disk state prior to booting. The newly created snapshot becomes current (see virDomainSnapshotCurrent()), and is a child of any previous current snapshot. If @flags includes VIR_DOMAIN_SNAPSHOT_CREATE_REDEFINE, then this is a request to reinstate snapshot metadata that was previously discarded, rather than creating a new snapshot. This can be used to recreate a snapshot hierarchy on a destination, then remove it on the source, in order to allow migration (since migration normally fails if snapshot metadata still remains on the source machine). When redefining snapshot metadata, the current snapshot will not be altered unless the VIR_DOMAIN_SNAPSHOT_CREATE_CURRENT flag is also present. It is an error to request the VIR_DOMAIN_SNAPSHOT_CREATE_CURRENT flag without VIR_DOMAIN_SNAPSHOT_CREATE_REDEFINE. On some hypervisors, redefining an existing snapshot can be used to alter host-specific portions of the domain XML to be used during revert (such as backing filenames associated with disk devices), but must not alter guest-visible layout. When redefining a snapshot name that does not exist, the hypervisor may validate that reverting to the snapshot appears to be possible (for example, disk images have snapshot contents by the requested name). Not all hypervisors support these flags. If @flags includes VIR_DOMAIN_SNAPSHOT_CREATE_NO_METADATA, then the domain's disk images are modified according to @xmlDesc, but then the just-created snapshot has its metadata deleted. This flag is incompatible with VIR_DOMAIN_SNAPSHOT_CREATE_REDEFINE. If @flags includes VIR_DOMAIN_SNAPSHOT_CREATE_HALT, then the domain will be inactive after the snapshot completes, regardless of whether it was active before; otherwise, a running domain will still be running after the snapshot. This flag is invalid on transient domains, and is incompatible with VIR_DOMAIN_SNAPSHOT_CREATE_REDEFINE. If @flags includes VIR_DOMAIN_SNAPSHOT_CREATE_DISK_ONLY, then the snapshot will be limited to the disks described in @xmlDesc, and no VM state will be saved. For an active guest, the disk image may be inconsistent (as if power had been pulled), and specifying this with the VIR_DOMAIN_SNAPSHOT_CREATE_HALT flag risks data loss.
domain: | a domain object |
xmlDesc: | string containing an XML description of the domain |
flags: | bitwise-OR of virDomainSnapshotCreateFlags |
Returns: | an (opaque) virDomainSnapshotPtr on success, NULL on failure. |
virDomainSnapshotPtr virDomainSnapshotCurrent (virDomainPtr domain,
unsigned int flags)
Get the current snapshot for a domain, if any.
domain: | a domain object |
flags: | unused flag parameters; callers should pass 0 |
Returns: | a domain snapshot object or NULL in case of failure. If the current domain snapshot cannot be found, then the VIR_ERR_NO_DOMAIN_SNAPSHOT error is raised. |
int virDomainSnapshotDelete (virDomainSnapshotPtr snapshot,
unsigned int flags)
Delete the snapshot. If @flags is 0, then just this snapshot is deleted, and changes from this snapshot are automatically merged into children snapshots. If @flags includes VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN, then this snapshot and any descendant snapshots are deleted. If @flags includes VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN_ONLY, then any descendant snapshots are deleted, but this snapshot remains. These two flags are mutually exclusive. If @flags includes VIR_DOMAIN_SNAPSHOT_DELETE_METADATA_ONLY, then any snapshot metadata tracked by libvirt is removed while keeping the snapshot contents intact; if a hypervisor does not require any libvirt metadata to track snapshots, then this flag is silently ignored.
snapshot: | a domain snapshot object |
flags: | bitwise-or of supported virDomainSnapshotDeleteFlags |
Returns: | 0 if the selected snapshot(s) were successfully deleted, -1 on error. |
int virDomainSnapshotFree (virDomainSnapshotPtr snapshot)
Free the domain snapshot object. The snapshot itself is not modified. The data structure is freed and should not be used thereafter.
snapshot: | a domain snapshot object |
Returns: | 0 in case of success and -1 in case of failure. |
virConnectPtr virDomainSnapshotGetConnect (virDomainSnapshotPtr snapshot)
Get the connection that owns the domain that a snapshot was created for
snapshot: | a snapshot object |
Returns: | the connection or NULL. |
virDomainPtr virDomainSnapshotGetDomain (virDomainSnapshotPtr snapshot)
Get the domain that a snapshot was created for
snapshot: | a snapshot object |
Returns: | the domain or NULL. |
const char * virDomainSnapshotGetName (virDomainSnapshotPtr snapshot)
Get the public name for that snapshot
snapshot: | a snapshot object |
Returns: | a pointer to the name or NULL, the string need not be deallocated as its lifetime will be the same as the snapshot object. |
char * virDomainSnapshotGetXMLDesc (virDomainSnapshotPtr snapshot,
unsigned int flags)
Provide an XML description of the domain snapshot. No security-sensitive data will be included unless @flags contains VIR_DOMAIN_XML_SECURE; this flag is rejected on read-only connections. For this API, @flags should not contain either VIR_DOMAIN_XML_INACTIVE or VIR_DOMAIN_XML_UPDATE_CPU.
snapshot: | a domain snapshot object |
flags: | bitwise-OR of subset of virDomainXMLFlags |
Returns: | a 0 terminated UTF-8 encoded XML instance, or NULL in case of error. the caller must free() the returned value. |
int virDomainSnapshotListNames (virDomainPtr domain,
char ** names,
int nameslen,
unsigned int flags)
Collect the list of domain snapshots for the given domain, and store their names in @names. Caller is responsible for freeing each member of the array. The value to use for @nameslen can be determined by virDomainSnapshotNum() with the same @flags. If @flags includes VIR_DOMAIN_SNAPSHOT_LIST_ROOTS, then the result is filtered to the number of snapshots that have no parents. If @flags includes VIR_DOMAIN_SNAPSHOT_LIST_METADATA, then the result is the number of snapshots that also include metadata that would prevent the removal of the last reference to a domain; this value will either be 0 or the same value as if the flag were not given.
domain: | a domain object |
names: | array to collect the list of names of snapshots |
nameslen: | size of @names |
flags: | bitwise-or of supported virDomainSnapshotListFlags |
Returns: | the number of domain snapshots found or -1 in case of error. |
virDomainSnapshotPtr virDomainSnapshotLookupByName (virDomainPtr domain,
const char * name,
unsigned int flags)
Try to lookup a domain snapshot based on its name.
domain: | a domain object |
name: | name for the domain snapshot |
flags: | unused flag parameters; callers should pass 0 |
Returns: | a domain snapshot object or NULL in case of failure. If the domain snapshot cannot be found, then the VIR_ERR_NO_DOMAIN_SNAPSHOT error is raised. |
int virDomainSnapshotNum (virDomainPtr domain,
unsigned int flags)
Provides the number of domain snapshots for this domain. If @flags includes VIR_DOMAIN_SNAPSHOT_LIST_ROOTS, then the result is filtered to the number of snapshots that have no parents. If @flags includes VIR_DOMAIN_SNAPSHOT_LIST_METADATA, then the result is the number of snapshots that also include metadata that would prevent the removal of the last reference to a domain; this value will either be 0 or the same value as if the flag were not given.
domain: | a domain object |
flags: | bitwise-or of supported virDomainSnapshotListFlags |
Returns: | the number of domain snapshots found or -1 in case of error. |
int virDomainSuspend (virDomainPtr domain)
Suspends an active domain, the process is frozen without further access to CPU resources and I/O but the memory used by the domain at the hypervisor level will stay allocated. Use virDomainResume() to reactivate the domain. This function may require privileged access.
domain: | a domain object |
Returns: | 0 in case of success and -1 in case of failure. |
int virDomainUndefine (virDomainPtr domain)
Undefine a domain. If the domain is running, it's converted to transient domain, without stopping it. If the domain is inactive, the domain configuration is removed. If the domain has a managed save image (see virDomainHasManagedSaveImage()), or if it is inactive and has any snapshot metadata (see virDomainSnapshotNum()), then the undefine will fail. See virDomainUndefineFlags() for more control.
domain: | pointer to a defined domain |
Returns: | 0 in case of success, -1 in case of error |
int virDomainUndefineFlags (virDomainPtr domain,
unsigned int flags)
Undefine a domain. If the domain is running, it's converted to transient domain, without stopping it. If the domain is inactive, the domain configuration is removed. If the domain has a managed save image (see virDomainHasManagedSaveImage()), then including VIR_DOMAIN_UNDEFINE_MANAGED_SAVE in @flags will also remove that file, and omitting the flag will cause the undefine process to fail. If the domain is inactive and has any snapshot metadata (see virDomainSnapshotNum()), then including VIR_DOMAIN_UNDEFINE_SNAPSHOTS_METADATA in @flags will also remove that metadata. Omitting the flag will cause the undefine of an inactive domain to fail. Active snapshots will retain snapshot metadata until the (now-transient) domain halts, regardless of whether this flag is present. On hypervisors where snapshots do not use libvirt metadata, this flag has no effect.
domain: | pointer to a defined domain |
flags: | bitwise-or of supported virDomainUndefineFlagsValues |
Returns: | 0 in case of success, -1 in case of error |
int virDomainUpdateDeviceFlags (virDomainPtr domain,
const char * xml,
unsigned int flags)
Change a virtual device on a domain, using the flags parameter to control how the device is changed. VIR_DOMAIN_AFFECT_CURRENT specifies that the device change is made based on current domain state. VIR_DOMAIN_AFFECT_LIVE specifies that the device shall be changed on the active domain instance only and is not added to the persisted domain configuration. VIR_DOMAIN_AFFECT_CONFIG specifies that the device shall be changed on the persisted domain configuration only. Note that the target hypervisor must return an error if unable to satisfy flags. E.g. the hypervisor driver will return failure if LIVE is specified but it only supports modifying the persisted device allocation. This method is used for actions such changing CDROM/Floppy device media, altering the graphics configuration such as password, reconfiguring the NIC device backend connectivity, etc.
domain: | pointer to domain object |
xml: | pointer to XML description of one device |
flags: | an OR'ed set of virDomainDeviceModifyFlags |
Returns: | 0 in case of success, -1 in case of failure. |
int virEventAddHandle (int fd,
int events,
virEventHandleCallback cb,
void * opaque,
virFreeCallback ff)
fd: | |
events: | |
cb: | |
opaque: | |
ff: | |
Returns: |
int virEventAddTimeout (int timeout,
virEventTimeoutCallback cb,
void * opaque,
virFreeCallback ff)
timeout: | |
cb: | |
opaque: | |
ff: | |
Returns: |
int virEventRegisterDefaultImpl (void)
Registers a default event implementation based on the poll() system call. This is a generic implementation that can be used by any client application which does not have a need to integrate with an external event loop impl. Once registered, the application can invoke virEventRunDefaultImpl in a loop to process events
Returns: | 0 on success, -1 on failure. |
void virEventRegisterImpl (virEventAddHandleFunc addHandle,
virEventUpdateHandleFunc updateHandle,
virEventRemoveHandleFunc removeHandle,
virEventAddTimeoutFunc addTimeout,
virEventUpdateTimeoutFunc updateTimeout,
virEventRemoveTimeoutFunc removeTimeout)
Registers an event implementation, to allow integration with an external event loop. Applications would use this to integrate with the libglib2 event loop, or libevent or the QT event loop. If an application does not need to integrate with an existing event loop implementation, then the virEventRegisterDefaultImpl method can be used to setup the generic libvirt implementation.
addHandle: | the callback to add fd handles |
updateHandle: | the callback to update fd handles |
removeHandle: | the callback to remove fd handles |
addTimeout: | the callback to add a timeout |
updateTimeout: | the callback to update a timeout |
removeTimeout: | the callback to remove a timeout |
int virEventRunDefaultImpl (void)
Run one iteration of the event loop. Applications will generally want to have a thread which invokes this method in an infinite loop static bool quit = false; while (!quit) { if (virEventRunDefaultImpl() < 0) ...print error... }
Returns: | 0 on success, -1 on failure. |
int virGetVersion (unsigned long * libVer,
const char * type,
unsigned long * typeVer)
Provides version information. @libVer is the version of the library and will always be set unless an error occurs, in which case an error code will be returned. @typeVer exists for historical compatibility; if it is not NULL it will duplicate @libVer (it was originally intended to return hypervisor information based on @type, but due to the design of remote clients this is not reliable). To get the version of the running hypervisor use the virConnectGetVersion function instead. To get the libvirt library version used by a connection use the virConnectGetLibVersion instead.
libVer: | return value for the library version (OUT) |
type: | ignored; pass NULL |
typeVer: | pass NULL; for historical purposes duplicates @libVer if non-NULL |
Returns: | -1 in case of failure, 0 otherwise, and values for @libVer and @typeVer have the format major * 1,000,000 + minor * 1,000 + release. |
int virInitialize (void)
Initialize the library. It's better to call this routine at startup in multithreaded applications to avoid potential race when initializing the library. Calling virInitialize is mandatory, unless your first API call is one of virConnectOpen*.
Returns: | 0 in case of success, -1 in case of error |
int virInterfaceChangeBegin (virConnectPtr conn,
unsigned int flags)
This functions creates a restore point to which one can return later by calling virInterfaceChangeRollback(). This function should be called before any transaction with interface configuration. Once knowing, new configuration works, it can be commited via virInterfaceChangeCommit(), which frees the restore point. If virInterfaceChangeBegin() is called when a transaction is already opened, this function will fail, and a VIR_ERR_INVALID_OPERATION will be logged.
conn: | pointer to hypervisor connection |
flags: | flags, not used yet |
Returns: | 0 in case of success and -1 in case of failure. |
int virInterfaceChangeCommit (virConnectPtr conn,
unsigned int flags)
This commits the changes made to interfaces and frees the restore point created by virInterfaceChangeBegin(). If virInterfaceChangeCommit() is called when a transaction is not opened, this function will fail, and a VIR_ERR_INVALID_OPERATION will be logged.
conn: | pointer to hypervisor connection |
flags: | flags, not used yet |
Returns: | 0 in case of success and -1 in case of failure. |
int virInterfaceChangeRollback (virConnectPtr conn,
unsigned int flags)
This cancels changes made to interfaces settings by restoring previous state created by virInterfaceChangeBegin(). If virInterfaceChangeRollback() is called when a transaction is not opened, this function will fail, and a VIR_ERR_INVALID_OPERATION will be logged.
conn: | pointer to hypervisor connection |
flags: | flags, not used yet |
Returns: | 0 in case of success and -1 in case of failure. |
int virInterfaceCreate (virInterfacePtr iface,
unsigned int flags)
Activate an interface (i.e. call "ifup"). If there was an open network config transaction at the time this interface was defined (that is, if virInterfaceChangeBegin() had been called), the interface will be brought back down (and then undefined) if virInterfaceChangeRollback() is called. p *
iface: | pointer to a defined interface |
flags: | and OR'ed set of extraction flags, not used yet |
Returns: | 0 in case of success, -1 in case of error |
virInterfacePtr virInterfaceDefineXML (virConnectPtr conn,
const char * xml,
unsigned int flags)
Define an interface (or modify existing interface configuration). Normally this change in the interface configuration is immediately permanent/persistent, but if virInterfaceChangeBegin() has been previously called (i.e. if an interface config transaction is open), the new interface definition will only become permanent if virInterfaceChangeCommit() is called prior to the next reboot of the system running libvirtd. Prior to that time, it can be explicitly removed using virInterfaceChangeRollback(), or will be automatically removed during the next reboot of the system running libvirtd.
conn: | pointer to the hypervisor connection |
xml: | the XML description for the interface, preferably in UTF-8 |
flags: | and OR'ed set of extraction flags, not used yet |
Returns: | NULL in case of error, a pointer to the interface otherwise |
int virInterfaceDestroy (virInterfacePtr iface,
unsigned int flags)
deactivate an interface (ie call "ifdown") This does not remove the interface from the config, and does not free the associated virInterfacePtr object. If there is an open network config transaction at the time this interface is destroyed (that is, if virInterfaceChangeBegin() had been called), and if the interface is later undefined and then virInterfaceChangeRollback() is called, the restoral of the interface definition will also bring the interface back up.
iface: | an interface object |
flags: | and OR'ed set of extraction flags, not used yet |
Returns: | 0 in case of success and -1 in case of failure. |
int virInterfaceFree (virInterfacePtr iface)
Free the interface object. The interface itself is unaltered. The data structure is freed and should not be used thereafter.
iface: | an interface object |
Returns: | 0 in case of success and -1 in case of failure. |
virConnectPtr virInterfaceGetConnect (virInterfacePtr iface)
Provides the connection pointer associated with an interface. The reference counter on the connection is not increased by this call. WARNING: When writing libvirt bindings in other languages, do not use this function. Instead, store the connection and the interface object together.
iface: | pointer to an interface |
Returns: | the virConnectPtr or NULL in case of failure. |
const char * virInterfaceGetMACString (virInterfacePtr iface)
Get the MAC for an interface as string. For more information about MAC see RFC4122.
iface: | an interface object |
Returns: | a pointer to the MAC address (in null-terminated ASCII format) or NULL, the string need not be deallocated its lifetime will be the same as the interface object. |
const char * virInterfaceGetName (virInterfacePtr iface)
Get the public name for that interface
iface: | an interface object |
Returns: | a pointer to the name or NULL, the string need not be deallocated its lifetime will be the same as the interface object. |
char * virInterfaceGetXMLDesc (virInterfacePtr iface,
unsigned int flags)
VIR_INTERFACE_XML_INACTIVE - return the static configuration, suitable for use redefining the interface via virInterfaceDefineXML() Provide an XML description of the interface. If VIR_INTERFACE_XML_INACTIVE is set, the description may be reused later to redefine the interface with virInterfaceDefineXML(). If it is not set, the ip address and netmask will be the current live setting of the interface, not the settings from the config files.
iface: | an interface object |
flags: | an OR'ed set of extraction flags. Current valid bits: |
Returns: | a 0 terminated UTF-8 encoded XML instance, or NULL in case of error. the caller must free() the returned value. |
int virInterfaceIsActive (virInterfacePtr iface)
Determine if the interface is currently running
iface: | pointer to the interface object |
Returns: | 1 if running, 0 if inactive, -1 on error |
virInterfacePtr virInterfaceLookupByMACString (virConnectPtr conn,
const char * macstr)
Try to lookup an interface on the given hypervisor based on its MAC.
conn: | pointer to the hypervisor connection |
macstr: | the MAC for the interface (null-terminated ASCII format) |
Returns: | a new interface object or NULL in case of failure. If the interface cannot be found, then VIR_ERR_NO_INTERFACE error is raised. |
virInterfacePtr virInterfaceLookupByName (virConnectPtr conn,
const char * name)
Try to lookup an interface on the given hypervisor based on its name.
conn: | pointer to the hypervisor connection |
name: | name for the interface |
Returns: | a new interface object or NULL in case of failure. If the interface cannot be found, then VIR_ERR_NO_INTERFACE error is raised. |
int virInterfaceRef (virInterfacePtr iface)
Increment the reference count on the interface. For each additional call to this method, there shall be a corresponding call to virInterfaceFree to release the reference count, once the caller no longer needs the reference to this object. This method is typically useful for applications where multiple threads are using a connection, and it is required that the connection remain open until all threads have finished using it. ie, each new thread using an interface would increment the reference count.
iface: | the interface to hold a reference on |
Returns: | 0 in case of success, -1 in case of failure. |
int virInterfaceUndefine (virInterfacePtr iface)
Undefine an interface, ie remove it from the config. This does not free the associated virInterfacePtr object. Normally this change in the interface configuration is permanent/persistent, but if virInterfaceChangeBegin() has been previously called (i.e. if an interface config transaction is open), the removal of the interface definition will only become permanent if virInterfaceChangeCommit() is called prior to the next reboot of the system running libvirtd. Prior to that time, the definition can be explicitly restored using virInterfaceChangeRollback(), or will be automatically restored during the next reboot of the system running libvirtd.
iface: | pointer to a defined interface |
Returns: | 0 in case of success, -1 in case of error |
virNWFilterPtr virNWFilterDefineXML (virConnectPtr conn,
const char * xmlDesc)
Define a new network filter, based on an XML description similar to the one returned by virNWFilterGetXMLDesc()
conn: | pointer to the hypervisor connection |
xmlDesc: | an XML description of the nwfilter |
Returns: | a new nwfilter object or NULL in case of failure |
int virNWFilterFree (virNWFilterPtr nwfilter)
Free the nwfilter object. The running instance is kept alive. The data structure is freed and should not be used thereafter.
nwfilter: | a nwfilter object |
Returns: | 0 in case of success and -1 in case of failure. |
const char * virNWFilterGetName (virNWFilterPtr nwfilter)
Get the public name for the network filter
nwfilter: | a nwfilter object |
Returns: | a pointer to the name or NULL, the string need not be deallocated its lifetime will be the same as the nwfilter object. |
int virNWFilterGetUUID (virNWFilterPtr nwfilter,
unsigned char * uuid)
Get the UUID for a network filter
nwfilter: | a nwfilter object |
uuid: | pointer to a VIR_UUID_BUFLEN bytes array |
Returns: | -1 in case of error, 0 in case of success |
int virNWFilterGetUUIDString (virNWFilterPtr nwfilter,
char * buf)
Get the UUID for a network filter as string. For more information about UUID see RFC4122.
nwfilter: | a nwfilter object |
buf: | pointer to a VIR_UUID_STRING_BUFLEN bytes array |
Returns: | -1 in case of error, 0 in case of success |
char * virNWFilterGetXMLDesc (virNWFilterPtr nwfilter,
unsigned int flags)
Provide an XML description of the network filter. The description may be reused later to redefine the network filter with virNWFilterCreateXML().
nwfilter: | a nwfilter object |
flags: | an OR'ed set of extraction flags, not used yet |
Returns: | a 0 terminated UTF-8 encoded XML instance, or NULL in case of error. the caller must free() the returned value. |
virNWFilterPtr virNWFilterLookupByName (virConnectPtr conn,
const char * name)
Try to lookup a network filter on the given hypervisor based on its name.
conn: | pointer to the hypervisor connection |
name: | name for the network filter |
Returns: | a new nwfilter object or NULL in case of failure. If the network filter cannot be found, then VIR_ERR_NO_NWFILTER error is raised. |
virNWFilterPtr virNWFilterLookupByUUID (virConnectPtr conn,
const unsigned char * uuid)
Try to lookup a network filter on the given hypervisor based on its UUID.
conn: | pointer to the hypervisor connection |
uuid: | the raw UUID for the network filter |
Returns: | a new nwfilter object or NULL in case of failure. If the nwfdilter cannot be found, then VIR_ERR_NO_NWFILTER error is raised. |
virNWFilterPtr virNWFilterLookupByUUIDString (virConnectPtr conn,
const char * uuidstr)
Try to lookup an nwfilter on the given hypervisor based on its UUID.
conn: | pointer to the hypervisor connection |
uuidstr: | the string UUID for the nwfilter |
Returns: | a new nwfilter object or NULL in case of failure. If the nwfilter cannot be found, then VIR_ERR_NO_NWFILTER error is raised. |
int virNWFilterRef (virNWFilterPtr nwfilter)
Increment the reference count on the nwfilter. For each additional call to this method, there shall be a corresponding call to virNWFilterFree to release the reference count, once the caller no longer needs the reference to this object. This method is typically useful for applications where multiple threads are using a connection, and it is required that the connection remain open until all threads have finished using it. ie, each new thread using an nwfilter would increment the reference count.
nwfilter: | the nwfilter to hold a reference on |
Returns: | 0 in case of success, -1 in case of failure. |
int virNWFilterUndefine (virNWFilterPtr nwfilter)
Undefine the nwfilter object. This call will not succeed if a running VM is referencing the filter. This does not free the associated virNWFilterPtr object.
nwfilter: | a nwfilter object |
Returns: | 0 in case of success and -1 in case of failure. |
int virNetworkCreate (virNetworkPtr network)
Create and start a defined network. If the call succeed the network moves from the defined to the running networks pools.
network: | pointer to a defined network |
Returns: | 0 in case of success, -1 in case of error |
virNetworkPtr virNetworkCreateXML (virConnectPtr conn,
const char * xmlDesc)
Create and start a new virtual network, based on an XML description similar to the one returned by virNetworkGetXMLDesc()
conn: | pointer to the hypervisor connection |
xmlDesc: | an XML description of the network |
Returns: | a new network object or NULL in case of failure |
virNetworkPtr virNetworkDefineXML (virConnectPtr conn,
const char * xml)
Define a network, but does not create it
conn: | pointer to the hypervisor connection |
xml: | the XML description for the network, preferably in UTF-8 |
Returns: | NULL in case of error, a pointer to the network otherwise |
int virNetworkDestroy (virNetworkPtr network)
Destroy the network object. The running instance is shutdown if not down already and all resources used by it are given back to the hypervisor. This does not free the associated virNetworkPtr object. This function may require privileged access
network: | a network object |
Returns: | 0 in case of success and -1 in case of failure. |
int virNetworkFree (virNetworkPtr network)
Free the network object. The running instance is kept alive. The data structure is freed and should not be used thereafter.
network: | a network object |
Returns: | 0 in case of success and -1 in case of failure. |
int virNetworkGetAutostart (virNetworkPtr network,
int * autostart)
Provides a boolean value indicating whether the network configured to be automatically started when the host machine boots.
network: | a network object |
autostart: | the value returned |
Returns: | -1 in case of error, 0 in case of success |
char * virNetworkGetBridgeName (virNetworkPtr network)
Provides a bridge interface name to which a domain may connect a network interface in order to join the network.
network: | a network object |
Returns: | a 0 terminated interface name, or NULL in case of error. the caller must free() the returned value. |
virConnectPtr virNetworkGetConnect (virNetworkPtr net)
Provides the connection pointer associated with a network. The reference counter on the connection is not increased by this call. WARNING: When writing libvirt bindings in other languages, do not use this function. Instead, store the connection and the network object together.
net: | pointer to a network |
Returns: | the virConnectPtr or NULL in case of failure. |
const char * virNetworkGetName (virNetworkPtr network)
Get the public name for that network
network: | a network object |
Returns: | a pointer to the name or NULL, the string need not be deallocated its lifetime will be the same as the network object. |
int virNetworkGetUUID (virNetworkPtr network,
unsigned char * uuid)
Get the UUID for a network
network: | a network object |
uuid: | pointer to a VIR_UUID_BUFLEN bytes array |
Returns: | -1 in case of error, 0 in case of success |
int virNetworkGetUUIDString (virNetworkPtr network,
char * buf)
Get the UUID for a network as string. For more information about UUID see RFC4122.
network: | a network object |
buf: | pointer to a VIR_UUID_STRING_BUFLEN bytes array |
Returns: | -1 in case of error, 0 in case of success |
char * virNetworkGetXMLDesc (virNetworkPtr network,
unsigned int flags)
Provide an XML description of the network. The description may be reused later to relaunch the network with virNetworkCreateXML().
network: | a network object |
flags: | an OR'ed set of extraction flags, not used yet |
Returns: | a 0 terminated UTF-8 encoded XML instance, or NULL in case of error. the caller must free() the returned value. |
int virNetworkIsActive (virNetworkPtr net)
Determine if the network is currently running
net: | pointer to the network object |
Returns: | 1 if running, 0 if inactive, -1 on error |
int virNetworkIsPersistent (virNetworkPtr net)
Determine if the network has a persistent configuration which means it will still exist after shutting down
net: | pointer to the network object |
Returns: | 1 if persistent, 0 if transient, -1 on error |
virNetworkPtr virNetworkLookupByName (virConnectPtr conn,
const char * name)
Try to lookup a network on the given hypervisor based on its name.
conn: | pointer to the hypervisor connection |
name: | name for the network |
Returns: | a new network object or NULL in case of failure. If the network cannot be found, then VIR_ERR_NO_NETWORK error is raised. |
virNetworkPtr virNetworkLookupByUUID (virConnectPtr conn,
const unsigned char * uuid)
Try to lookup a network on the given hypervisor based on its UUID.
conn: | pointer to the hypervisor connection |
uuid: | the raw UUID for the network |
Returns: | a new network object or NULL in case of failure. If the network cannot be found, then VIR_ERR_NO_NETWORK error is raised. |
virNetworkPtr virNetworkLookupByUUIDString (virConnectPtr conn,
const char * uuidstr)
Try to lookup a network on the given hypervisor based on its UUID.
conn: | pointer to the hypervisor connection |
uuidstr: | the string UUID for the network |
Returns: | a new network object or NULL in case of failure. If the network cannot be found, then VIR_ERR_NO_NETWORK error is raised. |
int virNetworkRef (virNetworkPtr network)
Increment the reference count on the network. For each additional call to this method, there shall be a corresponding call to virNetworkFree to release the reference count, once the caller no longer needs the reference to this object. This method is typically useful for applications where multiple threads are using a connection, and it is required that the connection remain open until all threads have finished using it. ie, each new thread using a network would increment the reference count.
network: | the network to hold a reference on |
Returns: | 0 in case of success, -1 in case of failure. |
int virNetworkSetAutostart (virNetworkPtr network,
int autostart)
Configure the network to be automatically started when the host machine boots.
network: | a network object |
autostart: | whether the network should be automatically started 0 or 1 |
Returns: | -1 in case of error, 0 in case of success |
int virNetworkUndefine (virNetworkPtr network)
Undefine a network but does not stop it if it is running
network: | pointer to a defined network |
Returns: | 0 in case of success, -1 in case of error |
virNodeDevicePtr virNodeDeviceCreateXML (virConnectPtr conn,
const char * xmlDesc,
unsigned int flags)
Create a new device on the VM host machine, for example, virtual HBAs created using vport_create.
conn: | pointer to the hypervisor connection |
xmlDesc: | string containing an XML description of the device to be created |
flags: | callers should always pass 0 |
Returns: | a node device object if successful, NULL in case of failure |
int virNodeDeviceDestroy (virNodeDevicePtr dev)
Destroy the device object. The virtual device is removed from the host operating system. This function may require privileged access
dev: | a device object |
Returns: | 0 in case of success and -1 in case of failure. |
int virNodeDeviceDettach (virNodeDevicePtr dev)
Dettach the node device from the node itself so that it may be assigned to a guest domain. Depending on the hypervisor, this may involve operations such as unbinding any device drivers from the device, binding the device to a dummy device driver and resetting the device. If the device is currently in use by the node, this method may fail. Once the device is not assigned to any guest, it may be re-attached to the node using the virNodeDeviceReattach() method.
dev: | pointer to the node device |
Returns: | 0 in case of success, -1 in case of failure. |
int virNodeDeviceFree (virNodeDevicePtr dev)
Drops a reference to the node device, freeing it if this was the last reference.
dev: | pointer to the node device |
Returns: | the 0 for success, -1 for error. |
const char * virNodeDeviceGetName (virNodeDevicePtr dev)
Just return the device name
dev: | the device |
Returns: | the device name or NULL in case of error |
const char * virNodeDeviceGetParent (virNodeDevicePtr dev)
Accessor for the parent of the device
dev: | the device |
Returns: | the name of the device's parent, or NULL if the device has no parent. |
char * virNodeDeviceGetXMLDesc (virNodeDevicePtr dev,
unsigned int flags)
Fetch an XML document describing all aspects of the device.
dev: | pointer to the node device |
flags: | flags for XML generation (unused, pass 0) |
Returns: | the XML document, or NULL on error |
int virNodeDeviceListCaps (virNodeDevicePtr dev,
char ** const names,
int maxnames)
Lists the names of the capabilities supported by the device.
dev: | the device |
names: | array to collect the list of capability names |
maxnames: | size of @names |
Returns: | the number of capability names listed in @names. |
virNodeDevicePtr virNodeDeviceLookupByName (virConnectPtr conn,
const char * name)
Lookup a node device by its name.
conn: | pointer to the hypervisor connection |
name: | unique device name |
Returns: | a virNodeDevicePtr if found, NULL otherwise. |
int virNodeDeviceNumOfCaps (virNodeDevicePtr dev)
Accessor for the number of capabilities supported by the device.
dev: | the device |
Returns: | the number of capabilities supported by the device. |
int virNodeDeviceReAttach (virNodeDevicePtr dev)
Re-attach a previously dettached node device to the node so that it may be used by the node again. Depending on the hypervisor, this may involve operations such as resetting the device, unbinding it from a dummy device driver and binding it to its appropriate driver. If the device is currently in use by a guest, this method may fail.
dev: | pointer to the node device |
Returns: | 0 in case of success, -1 in case of failure. |
int virNodeDeviceRef (virNodeDevicePtr dev)
Increment the reference count on the dev. For each additional call to this method, there shall be a corresponding call to virNodeDeviceFree to release the reference count, once the caller no longer needs the reference to this object. This method is typically useful for applications where multiple threads are using a connection, and it is required that the connection remain open until all threads have finished using it. ie, each new thread using a dev would increment the reference count.
dev: | the dev to hold a reference on |
Returns: | 0 in case of success, -1 in case of failure. |
int virNodeDeviceReset (virNodeDevicePtr dev)
Reset a previously dettached node device to the node before or after assigning it to a guest. The exact reset semantics depends on the hypervisor and device type but, for example, KVM will attempt to reset PCI devices with a Function Level Reset, Secondary Bus Reset or a Power Management D-State reset. If the reset will affect other devices which are currently in use, this function may fail.
dev: | pointer to the node device |
Returns: | 0 in case of success, -1 in case of failure. |
int virNodeGetCPUStats (virConnectPtr conn,
int cpuNum,
virNodeCPUStatsPtr params,
int * nparams,
unsigned int flags)
This function provides individual cpu statistics of the node. If you want to get total cpu statistics of the node, you must specify VIR_NODE_CPU_STATS_ALL_CPUS to @cpuNum. The @params array will be filled with the values equal to the number of parameters suggested by @nparams As the value of @nparams is dynamic, call the API setting @nparams to 0 and @params as NULL, the API returns the number of parameters supported by the HV by updating @nparams on SUCCESS. The caller should then allocate @params array, i.e. (sizeof(@virNodeCPUStats) * @nparams) bytes and call the API again. Here is a sample code snippet: if ((virNodeGetCPUStats(conn, cpuNum, NULL, &nparams, 0) == 0) && (nparams != 0)) { if ((params = malloc(sizeof(virNodeCPUStats) * nparams)) == NULL) goto error; memset(params, 0, sizeof(virNodeCPUStats) * nparams); if (virNodeGetCPUStats(conn, cpuNum, params, &nparams, 0)) goto error; } This function doesn't require privileged access to the hypervisor. This function expects the caller to allocate the @params. CPU time Statistics: VIR_NODE_CPU_STATS_KERNEL: The cumulative CPU time which spends by kernel, when the node booting up.(nanoseconds) VIR_NODE_CPU_STATS_USER: The cumulative CPU time which spends by user processes, when the node booting up.(nanoseconds) VIR_NODE_CPU_STATS_IDLE: The cumulative idle CPU time, when the node booting up.(nanoseconds) VIR_NODE_CPU_STATS_IOWAIT: The cumulative I/O wait CPU time, when the node booting up.(nanoseconds) VIR_NODE_CPU_STATS_UTILIZATION: The CPU utilization. The usage value is in percent and 100% represents all CPUs on the server.
conn: | pointer to the hypervisor connection. |
cpuNum: | number of node cpu. (VIR_NODE_CPU_STATS_ALL_CPUS means total cpu statistics) |
params: | pointer to node cpu time parameter objects |
nparams: | number of node cpu time parameter (this value should be same or less than the number of parameters supported) |
flags: | currently unused, for future extension. always pass 0. |
Returns: | -1 in case of error, 0 in case of success. |
int virNodeGetCellsFreeMemory (virConnectPtr conn,
unsigned long long * freeMems,
int startCell,
int maxCells)
This call returns the amount of free memory in one or more NUMA cells. The @freeMems array must be allocated by the caller and will be filled with the amount of free memory in bytes for each cell requested, starting with startCell (in freeMems[0]), up to either (startCell + maxCells), or the number of additional cells in the node, whichever is smaller.
conn: | pointer to the hypervisor connection |
freeMems: | pointer to the array of unsigned long long |
startCell: | index of first cell to return freeMems info on. |
maxCells: | Maximum number of cells for which freeMems information can be returned. |
Returns: | the number of entries filled in freeMems, or -1 in case of error. |
unsigned long long virNodeGetFreeMemory (virConnectPtr conn)
provides the free memory available on the Node Note: most libvirt APIs provide memory sizes in kilobytes, but in this function the returned value is in bytes. Divide by 1024 as necessary.
conn: | pointer to the hypervisor connection |
Returns: | the available free memory in bytes or 0 in case of error |
int virNodeGetInfo (virConnectPtr conn,
virNodeInfoPtr info)
Extract hardware information about the node.
conn: | pointer to the hypervisor connection |
info: | pointer to a virNodeInfo structure allocated by the user |
Returns: | 0 in case of success and -1 in case of failure. |
int virNodeGetMemoryStats (virConnectPtr conn,
int cellNum,
virNodeMemoryStatsPtr params,
int * nparams,
unsigned int flags)
This function provides memory stats of the node. If you want to get total cpu statistics of the node, you must specify VIR_NODE_MEMORY_STATS_ALL_CELLS to @cellNum. The @params array will be filled with the values equal to the number of stats suggested by @nparams As the value of @nparams is dynamic, call the API setting @nparams to 0 and @params as NULL, the API returns the number of parameters supported by the HV by updating @nparams on SUCCESS. The caller should then allocate @params array, i.e. (sizeof(@virNodeMemoryStats) * @nparams) bytes and call the API again. Here is the sample code snippet: if ((virNodeGetMemoryStats(conn, cellNum, NULL, &nparams, 0) == 0) && (nparams != 0)) { if ((params = malloc(sizeof(virNodeMemoryStats) * nparams)) == NULL) goto error; memset(params, cellNum, 0, sizeof(virNodeMemoryStats) * nparams); if (virNodeGetMemoryStats(conn, params, &nparams, 0)) goto error; } This function doesn't require privileged access to the hypervisor. This function expects the caller to allocate the @params. Memory Stats: VIR_NODE_MEMORY_STATS_TOTAL: The total memory usage.(KB) VIR_NODE_MEMORY_STATS_FREE: The free memory usage.(KB) On linux, this usage includes buffers and cached. VIR_NODE_MEMORY_STATS_BUFFERS: The buffers memory usage.(KB) VIR_NODE_MEMORY_STATS_CACHED: The cached memory usage.(KB)
conn: | pointer to the hypervisor connection. |
cellNum: | number of node cell. (VIR_NODE_MEMORY_STATS_ALL_CELLS means total cell statistics) |
params: | pointer to node memory stats objects |
nparams: | number of node memory stats (this value should be same or less than the number of stats supported) |
flags: | currently unused, for future extension. always pass 0. |
Returns: | -1 in case of error, 0 in case of success. |
int virNodeGetSecurityModel (virConnectPtr conn,
virSecurityModelPtr secmodel)
Extract the security model of a hypervisor. The 'model' field in the @secmodel argument may be initialized to the empty string if the driver has not activated a security model.
conn: | a connection object |
secmodel: | pointer to a virSecurityModel structure |
Returns: | 0 in case of success, -1 in case of failure |
int virNodeListDevices (virConnectPtr conn,
const char * cap,
char ** const names,
int maxnames,
unsigned int flags)
Collect the list of node devices, and store their names in @names If the optional 'cap' argument is non-NULL, then the count will be restricted to devices with the specified capability
conn: | pointer to the hypervisor connection |
cap: | capability name |
names: | array to collect the list of node device names |
maxnames: | size of @names |
flags: | flags (unused, pass 0) |
Returns: | the number of node devices found or -1 in case of error |
int virNodeNumOfDevices (virConnectPtr conn,
const char * cap,
unsigned int flags)
Provides the number of node devices. If the optional 'cap' argument is non-NULL, then the count will be restricted to devices with the specified capability
conn: | pointer to the hypervisor connection |
cap: | capability name |
flags: | flags (unused, pass 0) |
Returns: | the number of node devices or -1 in case of error |
virSecretPtr virSecretDefineXML (virConnectPtr conn,
const char * xml,
unsigned int flags)
If XML specifies a UUID, locates the specified secret and replaces all attributes of the secret specified by UUID by attributes specified in xml (any attributes not specified in xml are discarded). Otherwise, creates a new secret with an automatically chosen UUID, and initializes its attributes from xml.
conn: | virConnect connection |
xml: | XML describing the secret. |
flags: | flags, use 0 for now |
Returns: | a the secret on success, NULL on failure. |
int virSecretFree (virSecretPtr secret)
Release the secret handle. The underlying secret continues to exist.
secret: | pointer to a secret |
Returns: | 0 on success, or -1 on error |
virConnectPtr virSecretGetConnect (virSecretPtr secret)
Provides the connection pointer associated with a secret. The reference counter on the connection is not increased by this call. WARNING: When writing libvirt bindings in other languages, do not use this function. Instead, store the connection and the secret object together.
secret: | A virSecret secret |
Returns: | the virConnectPtr or NULL in case of failure. |
int virSecretGetUUID (virSecretPtr secret,
unsigned char * uuid)
Fetches the UUID of the secret.
secret: | A virSecret secret |
uuid: | buffer of VIR_UUID_BUFLEN bytes in size |
Returns: | 0 on success with the uuid buffer being filled, or -1 upon failure. |
int virSecretGetUUIDString (virSecretPtr secret,
char * buf)
Get the UUID for a secret as string. For more information about UUID see RFC4122.
secret: | a secret object |
buf: | pointer to a VIR_UUID_STRING_BUFLEN bytes array |
Returns: | -1 in case of error, 0 in case of success |
const char * virSecretGetUsageID (virSecretPtr secret)
Get the unique identifier of the object with which this secret is to be used. The format of the identifier is dependant on the usage type of the secret. For a secret with a usage type of VIR_SECRET_USAGE_TYPE_VOLUME the identifier will be a fully qualfied path name. The identifiers are intended to be unique within the set of all secrets sharing the same usage type. ie, there shall only ever be one secret for each volume path.
secret: | a secret object |
Returns: | a string identifying the object using the secret, or NULL upon error |
int virSecretGetUsageType (virSecretPtr secret)
Get the type of object which uses this secret. The returned value is one of the constants defined in the virSecretUsageType enumeration. More values may be added to this enumeration in the future, so callers should expect to see usage types they do not explicitly know about.
secret: | a secret object |
Returns: | a positive integer identifying the type of object, or -1 upon error. |
unsigned char * virSecretGetValue (virSecretPtr secret,
size_t * value_size,
unsigned int flags)
Fetches the value of a secret.
secret: | A virSecret connection |
value_size: | Place for storing size of the secret value |
flags: | flags, use 0 for now |
Returns: | the secret value on success, NULL on failure. The caller must free() the secret value. |
char * virSecretGetXMLDesc (virSecretPtr secret,
unsigned int flags)
Fetches an XML document describing attributes of the secret.
secret: | A virSecret secret |
flags: | flags, use 0 for now |
Returns: | the XML document on success, NULL on failure. The caller must free() the XML. |
virSecretPtr virSecretLookupByUUID (virConnectPtr conn,
const unsigned char * uuid)
Try to lookup a secret on the given hypervisor based on its UUID. Uses the 16 bytes of raw data to describe the UUID
conn: | pointer to the hypervisor connection |
uuid: | the raw UUID for the secret |
Returns: | a new secret object or NULL in case of failure. If the secret cannot be found, then VIR_ERR_NO_SECRET error is raised. |
virSecretPtr virSecretLookupByUUIDString (virConnectPtr conn,
const char * uuidstr)
Try to lookup a secret on the given hypervisor based on its UUID. Uses the printable string value to describe the UUID
conn: | pointer to the hypervisor connection |
uuidstr: | the string UUID for the secret |
Returns: | a new secret object or NULL in case of failure. If the secret cannot be found, then VIR_ERR_NO_SECRET error is raised. |
virSecretPtr virSecretLookupByUsage (virConnectPtr conn,
int usageType,
const char * usageID)
Try to lookup a secret on the given hypervisor based on its usage The usageID is unique within the set of secrets sharing the same usageType value.
conn: | pointer to the hypervisor connection |
usageType: | the type of secret usage |
usageID: | identifier of the object using the secret |
Returns: | a new secret object or NULL in case of failure. If the secret cannot be found, then VIR_ERR_NO_SECRET error is raised. |
int virSecretRef (virSecretPtr secret)
Increment the reference count on the secret. For each additional call to this method, there shall be a corresponding call to virSecretFree to release the reference count, once the caller no longer needs the reference to this object. This method is typically useful for applications where multiple threads are using a connection, and it is required that the connection remain open until all threads have finished using it. ie, each new thread using a secret would increment the reference count.
secret: | the secret to hold a reference on |
Returns: | 0 in case of success, -1 in case of failure. |
int virSecretSetValue (virSecretPtr secret,
const unsigned char * value,
size_t value_size,
unsigned int flags)
Sets the value of a secret.
secret: | A virSecret secret |
value: | Value of the secret |
value_size: | Size of the value |
flags: | flags, use 0 for now |
Returns: | 0 on success, -1 on failure. |
int virSecretUndefine (virSecretPtr secret)
Deletes the specified secret. This does not free the associated virSecretPtr object.
secret: | A virSecret secret |
Returns: | 0 on success, -1 on failure. |
int virStoragePoolBuild (virStoragePoolPtr pool,
unsigned int flags)
Currently only filesystem pool accepts flags VIR_STORAGE_POOL_BUILD_OVERWRITE and VIR_STORAGE_POOL_BUILD_NO_OVERWRITE. Build the underlying storage pool
pool: | pointer to storage pool |
flags: | flags to control pool build behaviour |
Returns: | 0 on success, or -1 upon failure |
int virStoragePoolCreate (virStoragePoolPtr pool,
unsigned int flags)
Starts an inactive storage pool
pool: | pointer to storage pool |
flags: | future flags, use 0 for now |
Returns: | 0 on success, or -1 if it could not be started |
virStoragePoolPtr virStoragePoolCreateXML (virConnectPtr conn,
const char * xmlDesc,
unsigned int flags)
Create a new storage based on its XML description. The pool is not persistent, so its definition will disappear when it is destroyed, or if the host is restarted
conn: | pointer to hypervisor connection |
xmlDesc: | XML description for new pool |
flags: | future flags, use 0 for now |
Returns: | a virStoragePoolPtr object, or NULL if creation failed |
virStoragePoolPtr virStoragePoolDefineXML (virConnectPtr conn,
const char * xml,
unsigned int flags)
Define a new inactive storage pool based on its XML description. The pool is persistent, until explicitly undefined.
conn: | pointer to hypervisor connection |
xml: | XML description for new pool |
flags: | future flags, use 0 for now |
Returns: | a virStoragePoolPtr object, or NULL if creation failed |
int virStoragePoolDelete (virStoragePoolPtr pool,
unsigned int flags)
Delete the underlying pool resources. This is a non-recoverable operation. The virStoragePoolPtr object itself is not free'd.
pool: | pointer to storage pool |
flags: | flags for obliteration process |
Returns: | 0 on success, or -1 if it could not be obliterate |
int virStoragePoolDestroy (virStoragePoolPtr pool)
Destroy an active storage pool. This will deactivate the pool on the host, but keep any persistent config associated with it. If it has a persistent config it can later be restarted with virStoragePoolCreate(). This does not free the associated virStoragePoolPtr object.
pool: | pointer to storage pool |
Returns: | 0 on success, or -1 if it could not be destroyed |
int virStoragePoolFree (virStoragePoolPtr pool)
Free a storage pool object, releasing all memory associated with it. Does not change the state of the pool on the host.
pool: | pointer to storage pool |
Returns: | 0 on success, or -1 if it could not be free'd. |
int virStoragePoolGetAutostart (virStoragePoolPtr pool,
int * autostart)
Fetches the value of the autostart flag, which determines whether the pool is automatically started at boot time
pool: | pointer to storage pool |
autostart: | location in which to store autostart flag |
Returns: | 0 on success, -1 on failure |
virConnectPtr virStoragePoolGetConnect (virStoragePoolPtr pool)
Provides the connection pointer associated with a storage pool. The reference counter on the connection is not increased by this call. WARNING: When writing libvirt bindings in other languages, do not use this function. Instead, store the connection and the pool object together.
pool: | pointer to a pool |
Returns: | the virConnectPtr or NULL in case of failure. |
int virStoragePoolGetInfo (virStoragePoolPtr pool,
virStoragePoolInfoPtr info)
Get volatile information about the storage pool such as free space / usage summary
pool: | pointer to storage pool |
info: | pointer at which to store info |
Returns: | 0 on success, or -1 on failure. |
const char * virStoragePoolGetName (virStoragePoolPtr pool)
Fetch the locally unique name of the storage pool
pool: | pointer to storage pool |
Returns: | the name of the pool, or NULL on error |
int virStoragePoolGetUUID (virStoragePoolPtr pool,
unsigned char * uuid)
Fetch the globally unique ID of the storage pool
pool: | pointer to storage pool |
uuid: | buffer of VIR_UUID_BUFLEN bytes in size |
Returns: | 0 on success, or -1 on error; |
int virStoragePoolGetUUIDString (virStoragePoolPtr pool,
char * buf)
Fetch the globally unique ID of the storage pool as a string
pool: | pointer to storage pool |
buf: | buffer of VIR_UUID_STRING_BUFLEN bytes in size |
Returns: | 0 on success, or -1 on error; |
char * virStoragePoolGetXMLDesc (virStoragePoolPtr pool,
unsigned int flags)
Fetch an XML document describing all aspects of the storage pool. This is suitable for later feeding back into the virStoragePoolCreateXML method.
pool: | pointer to storage pool |
flags: | flags for XML format options (set of virDomainXMLFlags) |
Returns: | a XML document, or NULL on error |
int virStoragePoolIsActive (virStoragePoolPtr pool)
Determine if the storage pool is currently running
pool: | pointer to the storage pool object |
Returns: | 1 if running, 0 if inactive, -1 on error |
int virStoragePoolIsPersistent (virStoragePoolPtr pool)
Determine if the storage pool has a persistent configuration which means it will still exist after shutting down
pool: | pointer to the storage pool object |
Returns: | 1 if persistent, 0 if transient, -1 on error |
int virStoragePoolListVolumes (virStoragePoolPtr pool,
char ** const names,
int maxnames)
Fetch list of storage volume names, limiting to at most maxnames.
pool: | pointer to storage pool |
names: | array in which to storage volume names |
maxnames: | size of names array |
Returns: | the number of names fetched, or -1 on error |
virStoragePoolPtr virStoragePoolLookupByName (virConnectPtr conn,
const char * name)
Fetch a storage pool based on its unique name
conn: | pointer to hypervisor connection |
name: | name of pool to fetch |
Returns: | a virStoragePoolPtr object, or NULL if no matching pool is found |
virStoragePoolPtr virStoragePoolLookupByUUID (virConnectPtr conn,
const unsigned char * uuid)
Fetch a storage pool based on its globally unique id
conn: | pointer to hypervisor connection |
uuid: | globally unique id of pool to fetch |
Returns: | a virStoragePoolPtr object, or NULL if no matching pool is found |
virStoragePoolPtr virStoragePoolLookupByUUIDString (virConnectPtr conn,
const char * uuidstr)
Fetch a storage pool based on its globally unique id
conn: | pointer to hypervisor connection |
uuidstr: | globally unique id of pool to fetch |
Returns: | a virStoragePoolPtr object, or NULL if no matching pool is found |
virStoragePoolPtr virStoragePoolLookupByVolume (virStorageVolPtr vol)
Fetch a storage pool which contains a particular volume
vol: | pointer to storage volume |
Returns: | a virStoragePoolPtr object, or NULL if no matching pool is found |
int virStoragePoolNumOfVolumes (virStoragePoolPtr pool)
Fetch the number of storage volumes within a pool
pool: | pointer to storage pool |
Returns: | the number of storage pools, or -1 on failure |
int virStoragePoolRef (virStoragePoolPtr pool)
Increment the reference count on the pool. For each additional call to this method, there shall be a corresponding call to virStoragePoolFree to release the reference count, once the caller no longer needs the reference to this object. This method is typically useful for applications where multiple threads are using a connection, and it is required that the connection remain open until all threads have finished using it. ie, each new thread using a pool would increment the reference count.
pool: | the pool to hold a reference on |
Returns: | 0 in case of success, -1 in case of failure. |
int virStoragePoolRefresh (virStoragePoolPtr pool,
unsigned int flags)
Request that the pool refresh its list of volumes. This may involve communicating with a remote server, and/or initializing new devices at the OS layer
pool: | pointer to storage pool |
flags: | flags to control refresh behaviour (currently unused, use 0) |
Returns: | 0 if the volume list was refreshed, -1 on failure |
int virStoragePoolSetAutostart (virStoragePoolPtr pool,
int autostart)
Sets the autostart flag
pool: | pointer to storage pool |
autostart: | new flag setting |
Returns: | 0 on success, -1 on failure |
int virStoragePoolUndefine (virStoragePoolPtr pool)
Undefine an inactive storage pool
pool: | pointer to storage pool |
Returns: | 0 on success, -1 on failure |
virStorageVolPtr virStorageVolCreateXML (virStoragePoolPtr pool,
const char * xmldesc,
unsigned int flags)
Create a storage volume within a pool based on an XML description. Not all pools support creation of volumes
pool: | pointer to storage pool |
xmldesc: | description of volume to create |
flags: | flags for creation (unused, pass 0) |
Returns: | the storage volume, or NULL on error |
virStorageVolPtr virStorageVolCreateXMLFrom (virStoragePoolPtr pool,
const char * xmldesc,
virStorageVolPtr clonevol,
unsigned int flags)
Create a storage volume in the parent pool, using the 'clonevol' volume as input. Information for the new volume (name, perms) are passed via a typical volume XML description.
pool: | pointer to parent pool for the new volume |
xmldesc: | description of volume to create |
clonevol: | storage volume to use as input |
flags: | flags for creation (unused, pass 0) |
Returns: | the storage volume, or NULL on error |
int virStorageVolDelete (virStorageVolPtr vol,
unsigned int flags)
Delete the storage volume from the pool
vol: | pointer to storage volume |
flags: | future flags, use 0 for now |
Returns: | 0 on success, or -1 on error |
int virStorageVolDownload (virStorageVolPtr vol,
virStreamPtr stream,
unsigned long long offset,
unsigned long long length,
unsigned int flags)
Download the content of the volume as a stream. If @length is zero, then the remaining contents of the volume after @offset will be downloaded. This call sets up an asynchronous stream; subsequent use of stream APIs is necessary to transfer the actual data, determine how much data is successfully transferred, and detect any errors. The results will be unpredictable if another active stream is writing to the storage volume.
vol: | pointer to volume to download from |
stream: | stream to use as output |
offset: | position in @vol to start reading from |
length: | limit on amount of data to download |
flags: | future flags (unused, pass 0) |
Returns: | 0, or -1 upon error. |
int virStorageVolFree (virStorageVolPtr vol)
Release the storage volume handle. The underlying storage volume continues to exist.
vol: | pointer to storage volume |
Returns: | 0 on success, or -1 on error |
virConnectPtr virStorageVolGetConnect (virStorageVolPtr vol)
Provides the connection pointer associated with a storage volume. The reference counter on the connection is not increased by this call. WARNING: When writing libvirt bindings in other languages, do not use this function. Instead, store the connection and the volume object together.
vol: | pointer to a pool |
Returns: | the virConnectPtr or NULL in case of failure. |
int virStorageVolGetInfo (virStorageVolPtr vol,
virStorageVolInfoPtr info)
Fetches volatile information about the storage volume such as its current allocation
vol: | pointer to storage volume |
info: | pointer at which to store info |
Returns: | 0 on success, or -1 on failure |
const char * virStorageVolGetKey (virStorageVolPtr vol)
Fetch the storage volume key. This is globally unique, so the same volume will have the same key no matter what host it is accessed from
vol: | pointer to storage volume |
Returns: | the volume key, or NULL on error |
const char * virStorageVolGetName (virStorageVolPtr vol)
Fetch the storage volume name. This is unique within the scope of a pool
vol: | pointer to storage volume |
Returns: | the volume name, or NULL on error |
char * virStorageVolGetPath (virStorageVolPtr vol)
Fetch the storage volume path. Depending on the pool configuration this is either persistent across hosts, or dynamically assigned at pool startup. Consult pool documentation for information on getting the persistent naming
vol: | pointer to storage volume |
Returns: | the storage volume path, or NULL on error. The caller must free() the returned path after use. |
char * virStorageVolGetXMLDesc (virStorageVolPtr vol,
unsigned int flags)
Fetch an XML document describing all aspects of the storage volume
vol: | pointer to storage volume |
flags: | flags for XML generation (unused, pass 0) |
Returns: | the XML document, or NULL on error |
virStorageVolPtr virStorageVolLookupByKey (virConnectPtr conn,
const char * key)
Fetch a pointer to a storage volume based on its globally unique key
conn: | pointer to hypervisor connection |
key: | globally unique key |
Returns: | a storage volume, or NULL if not found / error |
virStorageVolPtr virStorageVolLookupByName (virStoragePoolPtr pool,
const char * name)
Fetch a pointer to a storage volume based on its name within a pool
pool: | pointer to storage pool |
name: | name of storage volume |
Returns: | a storage volume, or NULL if not found / error |
virStorageVolPtr virStorageVolLookupByPath (virConnectPtr conn,
const char * path)
Fetch a pointer to a storage volume based on its locally (host) unique path
conn: | pointer to hypervisor connection |
path: | locally unique path |
Returns: | a storage volume, or NULL if not found / error |
int virStorageVolRef (virStorageVolPtr vol)
Increment the reference count on the vol. For each additional call to this method, there shall be a corresponding call to virStorageVolFree to release the reference count, once the caller no longer needs the reference to this object. This method is typically useful for applications where multiple threads are using a connection, and it is required that the connection remain open until all threads have finished using it. ie, each new thread using a vol would increment the reference count.
vol: | the vol to hold a reference on |
Returns: | 0 in case of success, -1 in case of failure. |
int virStorageVolUpload (virStorageVolPtr vol,
virStreamPtr stream,
unsigned long long offset,
unsigned long long length,
unsigned int flags)
Upload new content to the volume from a stream. This call will fail if @offset + @length exceeds the size of the volume. Otherwise, if @length is non-zero, an error will be raised if an attempt is made to upload greater than @length bytes of data. This call sets up an asynchronous stream; subsequent use of stream APIs is necessary to transfer the actual data, determine how much data is successfully transferred, and detect any errors. The results will be unpredictable if another active stream is writing to the storage volume.
vol: | pointer to volume to upload |
stream: | stream to use as input |
offset: | position to start writing to |
length: | limit on amount of data to upload |
flags: | flags for creation (unused, pass 0) |
Returns: | 0, or -1 upon error. |
int virStorageVolWipe (virStorageVolPtr vol,
unsigned int flags)
Ensure data previously on a volume is not accessible to future reads
vol: | pointer to storage volume |
flags: | future flags, use 0 for now |
Returns: | 0 on success, or -1 on error |
int virStreamAbort (virStreamPtr stream)
Request that the in progress data transfer be cancelled abnormally before the end of the stream has been reached. For output streams this can be used to inform the driver that the stream is being terminated early. For input streams this can be used to inform the driver that it should stop sending data.
stream: | pointer to the stream object |
Returns: | 0 on success, -1 upon error |
int virStreamEventAddCallback (virStreamPtr stream,
int events,
virStreamEventCallback cb,
void * opaque,
virFreeCallback ff)
Register a callback to be notified when a stream becomes writable, or readable. This is most commonly used in conjunction with non-blocking data streams to integrate into an event loop
stream: | pointer to the stream object |
events: | set of events to monitor |
cb: | callback to invoke when an event occurs |
opaque: | application defined data |
ff: | callback to free @opaque data |
Returns: | 0 on success, -1 upon error |
int virStreamEventRemoveCallback (virStreamPtr stream)
Remove an event callback from the stream
stream: | pointer to the stream object |
Returns: | 0 on success, -1 on error |
int virStreamEventUpdateCallback (virStreamPtr stream,
int events)
Changes the set of events to monitor for a stream. This allows for event notification to be changed without having to unregister & register the callback completely. This method is guaranteed to succeed if a callback is already registered
stream: | pointer to the stream object |
events: | set of events to monitor |
Returns: | 0 on success, -1 if no callback is registered |
int virStreamFinish (virStreamPtr stream)
Indicate that there is no further data is to be transmitted on the stream. For output streams this should be called once all data has been written. For input streams this should be called once virStreamRecv returns end-of-file. This method is a synchronization point for all asynchronous errors, so if this returns a success code the application can be sure that all data has been successfully processed.
stream: | pointer to the stream object |
Returns: | 0 on success, -1 upon error |
int virStreamFree (virStreamPtr stream)
Decrement the reference count on a stream, releasing the stream object if the reference count has hit zero. There must not be an active data transfer in progress when releasing the stream. If a stream needs to be disposed of prior to end of stream being reached, then the virStreamAbort function should be called first.
stream: | pointer to the stream object |
Returns: | 0 upon success, or -1 on error |
virStreamPtr virStreamNew (virConnectPtr conn,
unsigned int flags)
Creates a new stream object which can be used to perform streamed I/O with other public API function. When no longer needed, a stream object must be released with virStreamFree. If a data stream has been used, then the application must call virStreamFinish or virStreamAbort before free'ing to, in order to notify the driver of termination. If a non-blocking data stream is required passed VIR_STREAM_NONBLOCK for flags, otherwise pass 0.
conn: | pointer to the connection |
flags: | control features of the stream |
Returns: | the new stream, or NULL upon error |
int virStreamRecv (virStreamPtr stream,
char * data,
size_t nbytes)
Reads a series of bytes from the stream. This method may block the calling application for an arbitrary amount of time. Errors are not guaranteed to be reported synchronously with the call, but may instead be delayed until a subsequent call. An example using this with a hypothetical file download API looks like virStreamPtr st = virStreamNew(conn, 0); int fd = open("demo.iso", O_WRONLY, 0600) virConnectDownloadFile(conn, "demo.iso", st); while (1) { char buf[1024]; int got = virStreamRecv(st, buf, 1024); if (got < 0) break; if (got == 0) { virStreamFinish(st); break; } int offset = 0; while (offset < got) { int sent = write(fd, buf+offset, got-offset) if (sent < 0) { virStreamAbort(st); goto done; } offset += sent; } } if (virStreamFinish(st) < 0) ... report an error .... done: virStreamFree(st); close(fd);
stream: | pointer to the stream object |
data: | buffer to read into from stream |
nbytes: | size of @data buffer |
Returns: | the number of bytes read, which may be less than requested. Returns 0 when the end of the stream is reached, at which time the caller should invoke virStreamFinish() to get confirmation of stream completion. Returns -1 upon error, at which time the stream will be marked as aborted, and the caller should now release the stream with virStreamFree. Returns -2 if there is no data pending to be read & the stream is marked as non-blocking. |
int virStreamRecvAll (virStreamPtr stream,
virStreamSinkFunc handler,
void * opaque)
Receive the entire data stream, sending the data to the requested data sink. This is simply a convenient alternative to virStreamRecv, for apps that do blocking-I/o. An example using this with a hypothetical file download API looks like int mysink(virStreamPtr st, const char *buf, int nbytes, void *opaque) { int *fd = opaque; return write(*fd, buf, nbytes); } virStreamPtr st = virStreamNew(conn, 0); int fd = open("demo.iso", O_WRONLY) virConnectUploadFile(conn, st); if (virStreamRecvAll(st, mysink, &fd) < 0) { ...report an error ... goto done; } if (virStreamFinish(st) < 0) ...report an error... virStreamFree(st); close(fd);
stream: | pointer to the stream object |
handler: | sink callback for writing data to application |
opaque: | application defined data |
Returns: | 0 if all the data was successfully received. The caller should invoke virStreamFinish(st) to flush the stream upon success and then virStreamFree Returns -1 upon any error, with virStreamAbort() already having been called, so the caller need only call virStreamFree() |
int virStreamRef (virStreamPtr stream)
Increment the reference count on the stream. For each additional call to this method, there shall be a corresponding call to virStreamFree to release the reference count, once the caller no longer needs the reference to this object.
stream: | pointer to the stream |
Returns: | 0 in case of success, -1 in case of failure |
int virStreamSend (virStreamPtr stream,
const char * data,
size_t nbytes)
Write a series of bytes to the stream. This method may block the calling application for an arbitrary amount of time. Once an application has finished sending data it should call virStreamFinish to wait for successful confirmation from the driver, or detect any error. This method may not be used if a stream source has been registered. Errors are not guaranteed to be reported synchronously with the call, but may instead be delayed until a subsequent call. An example using this with a hypothetical file upload API looks like virStreamPtr st = virStreamNew(conn, 0); int fd = open("demo.iso", O_RDONLY) virConnectUploadFile(conn, "demo.iso", st); while (1) { char buf[1024]; int got = read(fd, buf, 1024); if (got < 0) { virStreamAbort(st); break; } if (got == 0) { virStreamFinish(st); break; } int offset = 0; while (offset < got) { int sent = virStreamSend(st, buf+offset, got-offset) if (sent < 0) { virStreamAbort(st); goto done; } offset += sent; } } if (virStreamFinish(st) < 0) ... report an error .... done: virStreamFree(st); close(fd);
stream: | pointer to the stream object |
data: | buffer to write to stream |
nbytes: | size of @data buffer |
Returns: | the number of bytes written, which may be less than requested. Returns -1 upon error, at which time the stream will be marked as aborted, and the caller should now release the stream with virStreamFree. Returns -2 if the outgoing transmit buffers are full & the stream is marked as non-blocking. |
int virStreamSendAll (virStreamPtr stream,
virStreamSourceFunc handler,
void * opaque)
Send the entire data stream, reading the data from the requested data source. This is simply a convenient alternative to virStreamSend, for apps that do blocking-I/o. An example using this with a hypothetical file upload API looks like int mysource(virStreamPtr st, char *buf, int nbytes, void *opaque) { int *fd = opaque; return read(*fd, buf, nbytes); } virStreamPtr st = virStreamNew(conn, 0); int fd = open("demo.iso", O_RDONLY) virConnectUploadFile(conn, st); if (virStreamSendAll(st, mysource, &fd) < 0) { ...report an error ... goto done; } if (virStreamFinish(st) < 0) ...report an error... virStreamFree(st); close(fd);
stream: | pointer to the stream object |
handler: | source callback for reading data from application |
opaque: | application defined data |
Returns: | 0 if all the data was successfully sent. The caller should invoke virStreamFinish(st) to flush the stream upon success and then virStreamFree Returns -1 upon any error, with virStreamAbort() already having been called, so the caller need only call virStreamFree() |