Module libvirt from libvirt
Provides the interfaces of the libvirt library to handle virtualized domains
Table of Contents
#define LIBVIR_VERSION_NUMBER
#define VIR_COPY_CPUMAP
#define VIR_CPU_MAPLEN
#define VIR_CPU_USABLE
#define VIR_DOMAIN_EVENT_CALLBACK
#define VIR_DOMAIN_SCHED_FIELD_LENGTH
#define VIR_GET_CPUMAP
#define VIR_NODEINFO_MAXCPUS
#define VIR_SECURITY_DOI_BUFLEN
#define VIR_SECURITY_LABEL_BUFLEN
#define VIR_SECURITY_MODEL_BUFLEN
#define VIR_UNUSE_CPU
#define VIR_USE_CPU
#define VIR_UUID_BUFLEN
#define VIR_UUID_STRING_BUFLEN
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 virConnectFlags
typedef virConnect * virConnectPtr
typedef struct _virDomain virDomain
typedef struct _virDomainBlockInfo virDomainBlockInfo
typedef virDomainBlockInfo * virDomainBlockInfoPtr
typedef virDomainBlockStatsStruct * virDomainBlockStatsPtr
typedef struct _virDomainBlockStats virDomainBlockStatsStruct
typedef enum virDomainCoreDumpFlags
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 virDomainMemoryStatStruct * virDomainMemoryStatPtr
typedef struct _virDomainMemoryStat virDomainMemoryStatStruct
typedef enum virDomainMemoryStatTags
typedef enum virDomainMigrateFlags
typedef virDomain * virDomainPtr
typedef struct _virDomainSnapshot virDomainSnapshot
typedef enum virDomainSnapshotDeleteFlags
typedef virDomainSnapshot * virDomainSnapshotPtr
typedef enum virDomainState
typedef enum virDomainXMLFlags
typedef enum virEventHandleType
typedef struct _virInterface virInterface
typedef virInterface * virInterfacePtr
typedef enum virInterfaceXMLFlags
typedef struct _virNWFilter virNWFilter
typedef virNWFilter * virNWFilterPtr
typedef struct _virNetwork virNetwork
typedef virNetwork * virNetworkPtr
typedef struct _virNodeDevice virNodeDevice
typedef virNodeDevice * virNodeDevicePtr
typedef struct _virNodeInfo virNodeInfo
typedef virNodeInfo * virNodeInfoPtr
typedef struct _virSchedParameter 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 _virVcpuInfo virVcpuInfo
typedef virVcpuInfo * virVcpuInfoPtr
typedef enum virVcpuState
typedef virConnectAuthCallbackPtr
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 virConnectDomainEventCallback
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 virConnectDomainEventGenericCallback
void virConnectDomainEventGenericCallback (virConnectPtr conn,
virDomainPtr dom,
void * opaque)
typedef virConnectDomainEventGraphicsCallback
void virConnectDomainEventGraphicsCallback (virConnectPtr conn,
virDomainPtr dom,
int phase,
virDomainEventGraphicsAddressPtr local,
virDomainEventGraphicsAddressPtr remote,
const char * authScheme,
virDomainEventGraphicsSubjectPtr subject,
void * opaque)
typedef virConnectDomainEventIOErrorCallback
void virConnectDomainEventIOErrorCallback (virConnectPtr conn,
virDomainPtr dom,
const char * srcPath,
const char * devAlias,
int action,
void * opaque)
typedef virConnectDomainEventIOErrorReasonCallback
void virConnectDomainEventIOErrorReasonCallback (virConnectPtr conn,
virDomainPtr dom,
const char * srcPath,
const char * devAlias,
int action,
const char * reason,
void * opaque)
typedef virConnectDomainEventRTCChangeCallback
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 virConnectDomainEventWatchdogCallback
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)
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,
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 virDomainBlockPeek (virDomainPtr dom,
const char * path,
unsigned long long offset,
size_t size,
void * buffer,
unsigned int flags)
int virDomainBlockStats (virDomainPtr dom,
const char * path,
virDomainBlockStatsPtr stats,
size_t size)
int virDomainCoreDump (virDomainPtr domain,
const char * to,
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 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 virDomainGetBlockInfo (virDomainPtr domain,
const char * path,
virDomainBlockInfoPtr info,
unsigned int flags)
virConnectPtr virDomainGetConnect (virDomainPtr dom)
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)
const char * virDomainGetName (virDomainPtr domain)
char * virDomainGetOSType (virDomainPtr domain)
int virDomainGetSchedulerParameters (virDomainPtr domain,
virSchedParameterPtr params,
int * nparams)
char * virDomainGetSchedulerType (virDomainPtr domain,
int * nparams)
int virDomainGetSecurityLabel (virDomainPtr domain,
virSecurityLabelPtr seclabel)
int virDomainGetUUID (virDomainPtr domain,
unsigned char * uuid)
int virDomainGetUUIDString (virDomainPtr domain,
char * buf)
int virDomainGetVcpus (virDomainPtr domain,
virVcpuInfoPtr info,
int maxinfo,
unsigned char * cpumaps,
int maplen)
char * virDomainGetXMLDesc (virDomainPtr domain,
int flags)
int virDomainHasCurrentSnapshot (virDomainPtr domain,
unsigned int flags)
int virDomainHasManagedSaveImage (virDomainPtr dom,
unsigned int flags)
int virDomainInterfaceStats (virDomainPtr dom,
const char * path,
virDomainInterfaceStatsPtr stats,
size_t size)
int virDomainIsActive (virDomainPtr dom)
int virDomainIsPersistent (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)
int virDomainMigrateSetMaxDowntime (virDomainPtr domain,
unsigned long long downtime,
unsigned int flags)
int virDomainMigrateToURI (virDomainPtr domain,
const char * duri,
unsigned long flags,
const char * dname,
unsigned long bandwidth)
int virDomainPinVcpu (virDomainPtr domain,
unsigned int vcpu,
unsigned char * cpumap,
int maplen)
int virDomainReboot (virDomainPtr domain,
unsigned int flags)
int virDomainRef (virDomainPtr domain)
int virDomainRestore (virConnectPtr conn,
const char * from)
int virDomainResume (virDomainPtr domain)
int virDomainRevertToSnapshot (virDomainSnapshotPtr snapshot,
unsigned int flags)
int virDomainSave (virDomainPtr domain,
const char * to)
int virDomainSetAutostart (virDomainPtr domain,
int autostart)
int virDomainSetMaxMemory (virDomainPtr domain,
unsigned long memory)
int virDomainSetMemory (virDomainPtr domain,
unsigned long memory)
int virDomainSetSchedulerParameters (virDomainPtr domain,
virSchedParameterPtr params,
int nparams)
int virDomainSetVcpus (virDomainPtr domain,
unsigned int nvcpus)
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)
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 virDomainUpdateDeviceFlags (virDomainPtr domain,
const char * xml,
unsigned int flags)
typedef virEventAddHandleFunc
int virEventAddHandleFunc (int fd,
int event,
virEventHandleCallback cb,
void * opaque,
virFreeCallback ff)
typedef virEventAddTimeoutFunc
int virEventAddTimeoutFunc (int timeout,
virEventTimeoutCallback cb,
void * opaque,
virFreeCallback ff)
typedef virEventHandleCallback
void virEventHandleCallback (int watch,
int fd,
int events,
void * opaque)
void virEventRegisterImpl (virEventAddHandleFunc addHandle,
virEventUpdateHandleFunc updateHandle,
virEventRemoveHandleFunc removeHandle,
virEventAddTimeoutFunc addTimeout,
virEventUpdateTimeoutFunc updateTimeout,
virEventRemoveTimeoutFunc removeTimeout)
typedef virEventRemoveHandleFunc
int virEventRemoveHandleFunc (int watch)
typedef virEventRemoveTimeoutFunc
int virEventRemoveTimeoutFunc (int timer)
typedef virEventTimeoutCallback
void virEventTimeoutCallback (int timer,
void * opaque)
typedef virEventUpdateHandleFunc
void virEventUpdateHandleFunc (int watch,
int event)
typedef virEventUpdateTimeoutFunc
void virEventUpdateTimeoutFunc (int timer,
int timeout)
typedef virFreeCallback
void virFreeCallback (void * opaque)
int virGetVersion (unsigned long * libVer,
const char * type,
unsigned long * typeVer)
int virInitialize (void)
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,
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,
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 virNodeGetCellsFreeMemory (virConnectPtr conn,
unsigned long long * freeMems,
int startCell,
int maxCells)
unsigned long long virNodeGetFreeMemory (virConnectPtr conn)
int virNodeGetInfo (virConnectPtr conn,
virNodeInfoPtr info)
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 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 virStorageVolWipe (virStorageVolPtr vol,
unsigned int flags)
int virStreamAbort (virStreamPtr stream)
int virStreamEventAddCallback (virStreamPtr stream,
int events,
virStreamEventCallback cb,
void * opaque,
virFreeCallback ff)
typedef virStreamEventCallback
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 virStreamSinkFunc
int virStreamSinkFunc (virStreamPtr st,
const char * data,
size_t nbytes,
void * opaque)
typedef virStreamSourceFunc
int virStreamSourceFunc (virStreamPtr st,
char * data,
size_t nbytes,
void * opaque)
Description
#define LIBVIR_VERSION_NUMBER
Macro providing the version of the library as version * 1,000,000 + minor * 1000 + micro
#define VIR_COPY_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.
#define VIR_CPU_MAPLEN
This macro is to be used in conjunction with virDomainPinVcpu() API. It returns the length (in bytes) required to store the complete CPU map between a single virtual & all physical CPUs of a domain.
#define VIR_CPU_USABLE
This macro is to be used in conjunction with virDomainGetVcpus() API. VIR_CPU_USABLE macro returns a non zero value (true) if the cpu is usable by the vcpu, and 0 otherwise.
#define VIR_DOMAIN_EVENT_CALLBACK
Used to cast the event specific callback into the generic one for use for virDomainEventRegister
#define VIR_DOMAIN_SCHED_FIELD_LENGTH
Macro providing the field length of virSchedParameter
#define VIR_GET_CPUMAP
This macro is to be used in conjunction with virDomainGetVcpus() and virDomainPinVcpu() APIs. VIR_GET_CPUMAP macro returns a pointer to the cpumap of the specified vcpu from cpumaps array.
#define VIR_NODEINFO_MAXCPUS
This macro is to calculate the total number of CPUs supported but not necessary active in the host.
#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_UNUSE_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.
#define VIR_USE_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.
#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()
enum virCPUCompareResult {
}
struct virConnect{
| The content of this structure is not made public by the API |
}
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 |
}
enum virConnectCredentialType {
}
struct virDomain{
| The content of this structure is not made public by the API |
}
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 |
}
struct virDomainBlockStatsStruct{
| 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'. |
}
enum virDomainCoreDumpFlags {
}
enum virDomainCreateFlags {
}
enum virDomainDeviceModifyFlags {
}
enum virDomainEventDefinedDetailType {
}
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) |
}
enum virDomainEventGraphicsAddressType {
}
enum virDomainEventGraphicsPhase {
}
struct virDomainEventGraphicsSubject{
}
struct virDomainEventGraphicsSubjectIdentity{
| const char * | type | : Type of identity |
| const char * | name | : Identity value |
}
enum virDomainEventID {
}
enum virDomainEventIOErrorAction {
}
enum virDomainEventResumedDetailType {
}
enum virDomainEventStartedDetailType {
}
enum virDomainEventStoppedDetailType {
}
enum virDomainEventSuspendedDetailType {
}
enum virDomainEventType {
}
enum virDomainEventUndefinedDetailType {
}
enum virDomainEventWatchdogAction {
}
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 |
}
struct virDomainInterfaceStatsStruct{
| 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 |
}
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 otherwise specified * and is measuring the job as a whole * * For VIR_DOMAIN_JOB_UNBOUNDED, dataTotal may be less * than the final sum of dataProcessed + dataRemaining * in the event that the hypervisor has to repeat some * data eg due to dirtied pages during migration * * For VIR_DOMAIN_JOB_BOUNDED, dataTotal shall always * equal sum of dataProcessed + dataRemaining * |
| unsigned long long | dataTotal |
| unsigned long long | dataProcessed |
| unsigned long long | dataRemaining | : As above, but only tracking guest memory progress |
| unsigned long long | memTotal |
| unsigned long long | memProcessed |
| unsigned long long | memRemaining | : As above, but only tracking guest disk file progress |
| unsigned long long | fileTotal |
| unsigned long long | fileProcessed |
| unsigned long long | fileRemaining |
}
enum virDomainJobType {
}
enum virDomainMemoryFlags {
}
struct virDomainMemoryStatStruct{
| int | tag |
| unsigned long long | val |
}
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 | : * The number of statistics supported by this version of the interface. * To add new statistics, add them to the enum and increase this value. * |
| VIR_DOMAIN_MEMORY_STAT_NR | = | 6 |
}
enum virDomainMigrateFlags {
}
struct virDomainSnapshot{
| The content of this structure is not made public by the API |
}
enum virDomainSnapshotDeleteFlags {
}
enum virDomainXMLFlags {
}
enum virEventHandleType {
}
struct virInterface{
| The content of this structure is not made public by the API |
}
enum virInterfaceXMLFlags {
}
struct virNWFilter{
| The content of this structure is not made public by the API |
}
struct virNetwork{
| The content of this structure is not made public by the API |
}
struct virNodeDevice{
| The content of this structure is not made public by the API |
}
struct virNodeInfo{
| charmodel[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 uniform mem access |
| unsigned int | sockets | : number of CPU socket per node |
| unsigned int | cores | : number of core per socket |
| unsigned int | threads | : number of threads per core |
}
struct virSchedParameter{
| charfield[VIR_DOMAIN_SCHED_FIELD_LENGTH] | field | : parameter name |
| int | type | : parameter type |
}
enum virSchedParameterType {
}
struct virSecret{
| The content of this structure is not made public by the API |
}
enum virSecretUsageType {
}
struct virSecurityLabel{
| The content of this structure is not made public by the API |
}
struct virSecurityModel{
| The content of this structure is not made public by the API |
}
struct virStoragePool{
| The content of this structure is not made public by the API |
}
enum virStoragePoolBuildFlags {
}
enum virStoragePoolDeleteFlags {
}
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 |
}
enum virStoragePoolState {
}
struct virStorageVol{
| The content of this structure is not made public by the API |
}
enum virStorageVolDeleteFlags {
}
struct virStorageVolInfo{
| int | type | : virStorageVolType flags |
| unsigned long long | capacity | : Logical size bytes |
| unsigned long long | allocation | : Current allocation bytes |
}
enum virStorageVolType {
}
struct virStream{
| The content of this structure is not made public by the API |
}
enum virStreamEventType {
}
struct virVcpuInfo{
| unsigned int | number | : virtual CPU number |
| int | state | : value from virVcpuState |
| unsigned long long | cpuTime | : CPU time used, in nanoseconds |
| int | cpu | : real CPU number, or -1 if offline |
}
typedef int (*virConnectAuthCallbackPtr) (virConnectCredentialPtr cred,
unsigned int ncred,
void * cbdata)
| cred: | |
| ncred: | |
| cbdata: | |
| Returns: | |
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.
| conn: | pointer to the hypervisor connection |
| Returns: | 0 in case of success or -1 in case of error. |
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 |
typedef 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: | |
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 |
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)
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 |
typedef void (*virConnectDomainEventIOErrorCallback) (virConnectPtr conn,
virDomainPtr dom,
const char * srcPath,
const char * devAlias,
int action,
void * opaque)
| conn: | |
| dom: | |
| srcPath: | |
| devAlias: | |
| action: | |
| opaque: | |
typedef void (*virConnectDomainEventIOErrorReasonCallback) (virConnectPtr conn,
virDomainPtr dom,
const char * srcPath,
const char * devAlias,
int action,
const char * reason,
void * opaque)
| conn: | |
| dom: | |
| srcPath: | |
| devAlias: | |
| action: | |
| reason: | |
| opaque: | |
typedef 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 |
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
| 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: | 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. 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
| 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: | 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 Returns a callback identifier on success, -1 on failure |
typedef 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 |
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
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. |
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,
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_DEVICE_MODIFY_CURRENT
specifies that the device allocation is made based on current domain
state. VIR_DOMAIN_DEVICE_MODIFY_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_DEVICE_MODIFY_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 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 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 virDomainCoreDump (virDomainPtr domain,
const char * to,
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.
| domain: | a domain object |
| to: | path for the core file |
| flags: | extra flags, currently unused |
| 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.
| 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.
| 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 requires 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).
| 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
| domain: | a domain object |
| 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_DEVICE_MODIFY_CURRENT
specifies that the device allocation is removed based on current domain
state. VIR_DOMAIN_DEVICE_MODIFY_LIVE specifies that the device shall be
deallocated from the active domain instance only and is not from the
persisted domain configuration. VIR_DOMAIN_DEVICE_MODIFY_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 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. |
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. |
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.
| domain: | pointer to domain object |
| Returns: | the maximum of virtual CPU or -1 in case of error. |
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,
virSchedParameterPtr params,
int * nparams)
Get the scheduler parameters, the @params array will be filled with the
values.
| 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) |
| Returns: | -1 in case of error, 0 in case of success. |
char * virDomainGetSchedulerType (virDomainPtr domain,
int * nparams)
Get the scheduler type.
| domain: | pointer to domain object |
| nparams: | number of scheduler parameters(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 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 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.
| 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. |
char * virDomainGetXMLDesc (virDomainPtr domain,
int flags)
Provide an XML description of the domain. The description may be reused
later to relaunch the domain with virDomainCreateXML().
| 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 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 |
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.
| dom: | pointer to the domain |
| flags: | optional flags currently unused |
| 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).
| 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_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). |
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 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.
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 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 requires 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 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().
| conn: | pointer to the hypervisor connection |
| from: | path to the |
| 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 requires 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.
| snapshot: | a domain snapshot object |
| flags: | unused flag parameters; callers should pass 0 |
| 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 may be a problem).
Use virDomainRestore() to restore a domain after saving.
| domain: | a domain object |
| to: | path for the output file |
| Returns: | 0 in case of success and -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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
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 successautostart)
Configure the domain to be automatically started
when the host machine boots. |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|