• Home
• News
• Downloads
• Documentation

  • Deployment
  • Architecture
  • XML format
  • Drivers
  • API reference

    • libvirt
    • virterror
    • Driver support
  • Language bindings
• Wiki
• FAQ
• Bug reports
• Contact
• Related Links
• Sitemap

Module libvirt from libvirt

Provides the interfaces of the libvirt library to handle virtualized domains

Table of Contents

Macros

#define LIBVIR_VERSION_NUMBER
#define VIR_COPY_CPUMAP
#define VIR_CPU_MAPLEN
#define VIR_CPU_USABLE
#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

Types

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 virDomainBlockStatsStruct * virDomainBlockStatsPtr
typedef struct _virDomainBlockStats virDomainBlockStatsStruct
typedef enum virDomainCreateFlags
typedef enum virDomainEventDefinedDetailType
typedef enum virDomainEventResumedDetailType
typedef enum virDomainEventStartedDetailType
typedef enum virDomainEventStoppedDetailType
typedef enum virDomainEventSuspendedDetailType
typedef enum virDomainEventType
typedef enum virDomainEventUndefinedDetailType
typedef struct _virDomainInfo virDomainInfo
typedef virDomainInfo * virDomainInfoPtr
typedef virDomainInterfaceStatsStruct * virDomainInterfaceStatsPtr
typedef struct _virDomainInterfaceStats virDomainInterfaceStatsStruct
typedef enum virDomainMemoryFlags
typedef enum virDomainMigrateFlags
typedef virDomain * virDomainPtr
typedef enum virDomainState
typedef enum virDomainXMLFlags
typedef enum virEventHandleType
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 _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 _virVcpuInfo virVcpuInfo
typedef virVcpuInfo * virVcpuInfoPtr
typedef enum virVcpuState

Functions

typedef virConnectAuthCallbackPtr
int	virConnectAuthCallbackPtr	(virConnectCredentialPtr cred, 
					 unsigned int ncred, 
					 void * cbdata)

int	virConnectClose			(virConnectPtr conn)
typedef virConnectDomainEventCallback
int	virConnectDomainEventCallback	(virConnectPtr conn, 
					 virDomainPtr dom, 
					 int event, 
					 int detail, 
					 void * opaque)

int	virConnectDomainEventDeregister	(virConnectPtr conn, 
					 virConnectDomainEventCallback cb)
int	virConnectDomainEventRegister	(virConnectPtr conn, 
					 virConnectDomainEventCallback cb, 
					 void * opaque, 
					 virFreeCallback freecb)
char *	virConnectFindStoragePoolSources	(virConnectPtr conn, 
						 const char * type, 
						 const char * srcSpec, 
						 unsigned int flags)
char *	virConnectGetCapabilities	(virConnectPtr conn)
char *	virConnectGetHostname		(virConnectPtr conn)
int	virConnectGetMaxVcpus		(virConnectPtr conn, 
					 const char * type)
const char *	virConnectGetType	(virConnectPtr conn)
char *	virConnectGetURI		(virConnectPtr conn)
int	virConnectGetVersion		(virConnectPtr conn, 
					 unsigned long * hvVer)
int	virConnectListDefinedDomains	(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	virConnectListNetworks		(virConnectPtr conn, 
					 char ** const names, 
					 int maxnames)
int	virConnectListStoragePools	(virConnectPtr conn, 
					 char ** const names, 
					 int maxnames)
int	virConnectNumOfDefinedDomains	(virConnectPtr conn)
int	virConnectNumOfDefinedNetworks	(virConnectPtr conn)
int	virConnectNumOfDefinedStoragePools	(virConnectPtr conn)
int	virConnectNumOfDomains		(virConnectPtr conn)
int	virConnectNumOfNetworks		(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	virDomainAttachDevice		(virDomainPtr domain, 
					 const char * xml)
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)
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	virDomainFree			(virDomainPtr domain)
int	virDomainGetAutostart		(virDomainPtr domain, 
					 int * autostart)
virConnectPtr	virDomainGetConnect	(virDomainPtr dom)
unsigned int	virDomainGetID		(virDomainPtr domain)
int	virDomainGetInfo		(virDomainPtr domain, 
					 virDomainInfoPtr 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	virDomainInterfaceStats		(virDomainPtr dom, 
					 const char * path, 
					 virDomainInterfaceStatsPtr stats, 
					 size_t size)
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	virDomainMemoryPeek		(virDomainPtr dom, 
					 unsigned long long start, 
					 size_t size, 
					 void * buffer, 
					 unsigned int flags)
virDomainPtr	virDomainMigrate	(virDomainPtr domain, 
					 virConnectPtr dconn, 
					 unsigned long flags, 
					 const char * dname, 
					 const char * uri, 
					 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	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)
int	virDomainSuspend		(virDomainPtr domain)
int	virDomainUndefine		(virDomainPtr domain)
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	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)
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)
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)
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	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)
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)

Description

Macros

LIBVIR_VERSION_NUMBER

#define LIBVIR_VERSION_NUMBER

Macro providing the version of the library as version * 1,000,000 + minor * 1000 + micro

VIR_COPY_CPUMAP

#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.

VIR_CPU_MAPLEN

#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.

VIR_CPU_USABLE

#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.

VIR_DOMAIN_SCHED_FIELD_LENGTH

#define VIR_DOMAIN_SCHED_FIELD_LENGTH

Macro providing the field length of virSchedParameter

VIR_GET_CPUMAP

#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.

VIR_NODEINFO_MAXCPUS

#define VIR_NODEINFO_MAXCPUS

This macro is to calculate the total number of CPUs supported but not necessary active in the host.

VIR_SECURITY_DOI_BUFLEN

#define VIR_SECURITY_DOI_BUFLEN

Macro providing the maximum length of the virSecurityModel doi string.

VIR_SECURITY_LABEL_BUFLEN

#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.

VIR_SECURITY_MODEL_BUFLEN

#define VIR_SECURITY_MODEL_BUFLEN

Macro providing the maximum length of the virSecurityModel model string.

VIR_UNUSE_CPU

#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.

VIR_USE_CPU

#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.

VIR_UUID_BUFLEN

#define VIR_UUID_BUFLEN

This macro provides the length of the buffer required for virDomainGetUUID()

VIR_UUID_STRING_BUFLEN

#define VIR_UUID_STRING_BUFLEN

This macro provides the length of the buffer required for virDomainGetUUIDString()

Types

virConnect

struct virConnect{

}

virConnectAuth

struct virConnectAuth{

}

virConnectCredential

struct virConnectCredential{

}

virConnectCredentialType

enum virConnectCredentialType {

}

virConnectFlags

enum virConnectFlags {

}

virDomain

struct virDomain{

}

virDomainBlockStatsStruct

struct virDomainBlockStatsStruct{

}

virDomainCreateFlags

enum virDomainCreateFlags {

}

virDomainEventDefinedDetailType

enum virDomainEventDefinedDetailType {

}

virDomainEventResumedDetailType

enum virDomainEventResumedDetailType {

}

virDomainEventStartedDetailType

enum virDomainEventStartedDetailType {

}

virDomainEventStoppedDetailType

enum virDomainEventStoppedDetailType {

}

virDomainEventSuspendedDetailType

enum virDomainEventSuspendedDetailType {

}

virDomainEventType

enum virDomainEventType {

}

virDomainEventUndefinedDetailType

enum virDomainEventUndefinedDetailType {

}

virDomainInfo

struct virDomainInfo{

}

virDomainInterfaceStatsStruct

struct virDomainInterfaceStatsStruct{

}

virDomainMemoryFlags

enum virDomainMemoryFlags {

}

virDomainMigrateFlags

enum virDomainMigrateFlags {

}

virDomainState

enum virDomainState {

}

virDomainXMLFlags

enum virDomainXMLFlags {

}

virEventHandleType

enum virEventHandleType {

}

virNetwork

struct virNetwork{

}

virNodeDevice

struct virNodeDevice{

}

virNodeInfo

struct virNodeInfo{

}

virSchedParameter

struct virSchedParameter{

}

virSchedParameterType

enum virSchedParameterType {

}

virSecurityLabel

struct virSecurityLabel{

}

virSecurityModel

struct virSecurityModel{

}

virStoragePool

struct virStoragePool{

}

virStoragePoolBuildFlags

enum virStoragePoolBuildFlags {

}

virStoragePoolDeleteFlags

enum virStoragePoolDeleteFlags {

}

virStoragePoolInfo

struct virStoragePoolInfo{

}

virStoragePoolState

enum virStoragePoolState {

}

virStorageVol

struct virStorageVol{

}

virStorageVolDeleteFlags

enum virStorageVolDeleteFlags {

}

virStorageVolInfo

struct virStorageVolInfo{

}

virStorageVolType

enum virStorageVolType {

}

virVcpuInfo

struct virVcpuInfo{

}

virVcpuState

enum virVcpuState {

}

Functions

virConnectAuthCallbackPtr

typedef int	(*virConnectAuthCallbackPtr)	(virConnectCredentialPtr cred, 
					 unsigned int ncred, 
					 void * cbdata)

virConnectClose

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.

virConnectDomainEventCallback

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

virConnectDomainEventDeregister

int	virConnectDomainEventDeregister	(virConnectPtr conn, 
					 virConnectDomainEventCallback cb)

Removes a Domain Event Callback. De-registering for a domain callback will disable delivery of this event type

virConnectDomainEventRegister

int	virConnectDomainEventRegister	(virConnectPtr conn, 
					 virConnectDomainEventCallback cb, 
					 void * opaque, 
					 virFreeCallback freecb)

Adds a Domain Event Callback. Registering for a domain callback will enable delivery of the events 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

virConnectFindStoragePoolSources

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)

virConnectGetCapabilities

char *	virConnectGetCapabilities	(virConnectPtr conn)

Provides capabilities of the hypervisor / driver.

virConnectGetHostname

char *	virConnectGetHostname		(virConnectPtr conn)

This returns the system hostname on which the hypervisor is running (the result of the gethostname(2) system call). If we are connected to a remote system, then this returns the hostname of the remote system.

virConnectGetMaxVcpus

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.

virConnectGetType

const char *	virConnectGetType	(virConnectPtr conn)

Get the name of the Hypervisor software used.

virConnectGetURI

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.

virConnectGetVersion

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.

virConnectListDefinedDomains

int	virConnectListDefinedDomains	(virConnectPtr conn, 
					 char ** const names, 
					 int maxnames)

list the defined but inactive domains, stores the pointers to the names in @names

virConnectListDefinedNetworks

int	virConnectListDefinedNetworks	(virConnectPtr conn, 
					 char ** const names, 
					 int maxnames)

list the inactive networks, stores the pointers to the names in @names

virConnectListDefinedStoragePools

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.

virConnectListDomains

int	virConnectListDomains		(virConnectPtr conn, 
					 int * ids, 
					 int maxids)

Collect the list of active domains, and store their ID in @maxids

virConnectListNetworks

int	virConnectListNetworks		(virConnectPtr conn, 
					 char ** const names, 
					 int maxnames)

Collect the list of active networks, and store their names in @names

virConnectListStoragePools

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.

virConnectNumOfDefinedDomains

int	virConnectNumOfDefinedDomains	(virConnectPtr conn)

Provides the number of defined but inactive domains.

virConnectNumOfDefinedNetworks

int	virConnectNumOfDefinedNetworks	(virConnectPtr conn)

Provides the number of inactive networks.

virConnectNumOfDefinedStoragePools

int	virConnectNumOfDefinedStoragePools	(virConnectPtr conn)

Provides the number of inactive storage pools

virConnectNumOfDomains

int	virConnectNumOfDomains		(virConnectPtr conn)

Provides the number of active domains.

virConnectNumOfNetworks

int	virConnectNumOfNetworks		(virConnectPtr conn)

Provides the number of active networks.

virConnectNumOfStoragePools

int	virConnectNumOfStoragePools	(virConnectPtr conn)

Provides the number of active storage pools

virConnectOpen

virConnectPtr	virConnectOpen		(const char * name)

This function should be called first to get a connection to the Hypervisor and xen store

virConnectOpenAuth

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

virConnectOpenReadOnly

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.

virConnectRef

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.

virDomainAttachDevice

int	virDomainAttachDevice		(virDomainPtr domain, 
					 const char * xml)

Create a virtual device attachment to backend.

virDomainBlockPeek

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.

virDomainBlockStats

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.

virDomainCoreDump

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.

virDomainCreate

int	virDomainCreate			(virDomainPtr domain)

launch a defined domain. If the call succeed the domain moves from the defined to the running domains pools.

virDomainCreateLinux

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 compatability.

virDomainCreateXML

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).

virDomainDefineXML

virDomainPtr	virDomainDefineXML	(virConnectPtr conn, 
					 const char * xml)

Define a domain, but does not start it. This definition is persistent, until explicitly undefined with virDomainUndefine().

virDomainDestroy

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

virDomainDetachDevice

int	virDomainDetachDevice		(virDomainPtr domain, 
					 const char * xml)

Destroy a virtual device attachment to backend.

virDomainFree

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.

virDomainGetAutostart

int	virDomainGetAutostart		(virDomainPtr domain, 
					 int * autostart)

Provides a boolean value indicating whether the domain configured to be automatically started when the host machine boots.

virDomainGetConnect

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.

virDomainGetID

unsigned int	virDomainGetID		(virDomainPtr domain)

Get the hypervisor ID number for the domain

virDomainGetInfo

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.

virDomainGetMaxMemory

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.

virDomainGetMaxVcpus

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.

virDomainGetName

const char *	virDomainGetName	(virDomainPtr domain)

Get the public name for that domain

virDomainGetOSType

char *	virDomainGetOSType		(virDomainPtr domain)

Get the type of domain operation system.

virDomainGetSchedulerParameters

int	virDomainGetSchedulerParameters	(virDomainPtr domain, 
					 virSchedParameterPtr params, 
					 int * nparams)

Get the scheduler parameters, the @params array will be filled with the values.

virDomainGetSchedulerType

char *	virDomainGetSchedulerType	(virDomainPtr domain, 
					 int * nparams)

Get the scheduler type.

virDomainGetSecurityLabel

int	virDomainGetSecurityLabel	(virDomainPtr domain, 
					 virSecurityLabelPtr seclabel)

Extract security label of an active domain.

virDomainGetUUID

int	virDomainGetUUID		(virDomainPtr domain, 
					 unsigned char * uuid)

Get the UUID for a domain

virDomainGetUUIDString

int	virDomainGetUUIDString		(virDomainPtr domain, 
					 char * buf)

Get the UUID for a domain as string. For more information about UUID see RFC4122.

virDomainGetVcpus

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.

virDomainGetXMLDesc

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().

virDomainInterfaceStats

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 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.

virDomainLookupByID

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.

virDomainLookupByName

virDomainPtr	virDomainLookupByName	(virConnectPtr conn, 
					 const char * name)

Try to lookup a domain on the given hypervisor based on its name.

virDomainLookupByUUID

virDomainPtr	virDomainLookupByUUID	(virConnectPtr conn, 
					 const unsigned char * uuid)

Try to lookup a domain on the given hypervisor based on its UUID.

virDomainLookupByUUIDString

virDomainPtr	virDomainLookupByUUIDString	(virConnectPtr conn, 
						 const char * uuidstr)

Try to lookup a domain on the given hypervisor based on its UUID.

virDomainMemoryPeek

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.

virDomainMigrate

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 Attempt a live migration. 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. Since typically the two hypervisors connect directly to each other in order to perform the migration, you may need to specify a path from the source to the destination. This is the purpose of the uri parameter. If uri is NULL, then libvirt will try to find the best method. Uri may specify the hostname or IP address of the destination host as seen from the source. Or uri may be a URI giving transport, hostname, user, port, etc. in the usual form. Refer to driver documentation for the particular URIs supported. 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.

virDomainPinVcpu

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.

virDomainReboot

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.

virDomainRef

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.

virDomainRestore

int	virDomainRestore		(virConnectPtr conn, 
					 const char * from)

This method will restore a domain saved to disk by virDomainSave().

virDomainResume

int	virDomainResume			(virDomainPtr domain)

Resume an suspended domain, the process is restarted from the state where it was frozen by calling virSuspendDomain(). This function may requires privileged access

virDomainSave

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.

virDomainSetAutostart

int	virDomainSetAutostart		(virDomainPtr domain, 
					 int autostart)

Configure the domain to be automatically started when the host machine boots.

virDomainSetMaxMemory

int	virDomainSetMaxMemory		(virDomainPtr domain, 
					 unsigned long memory)

Dynamically change the maximum amount of physical memory allocated to a domain. If domain is NULL, then this change the amount of memory reserved to Domain0 i.e. the domain where the application runs. This function requires privileged access to the hypervisor.

virDomainSetMemory

int	virDomainSetMemory		(virDomainPtr domain, 
					 unsigned long memory)

Dynamically change the target amount of physical memory allocated to a domain. If domain is NULL, then this change the amount of memory reserved to Domain0 i.e. the domain where the application runs. This function may requires privileged access to the hypervisor.

virDomainSetSchedulerParameters

int	virDomainSetSchedulerParameters	(virDomainPtr domain, 
					 virSchedParameterPtr params, 
					 int nparams)

Change the scheduler parameters

virDomainSetVcpus

int	virDomainSetVcpus		(virDomainPtr domain, 
					 unsigned int nvcpus)

Dynamically change the number of virtual CPUs used by the domain. Note that this call may fail if the underlying virtualization hypervisor does not support it or if growing the number is arbitrary limited. This function requires privileged access to the hypervisor.

virDomainShutdown

int	virDomainShutdown		(virDomainPtr domain)

Shutdown a domain, the domain object is still usable there after but the domain OS is being stopped. Note that the guest OS may ignore the request. TODO: should we add an option for reboot, knowing it may not be doable in the general case ?

virDomainSuspend

int	virDomainSuspend		(virDomainPtr domain)

Suspends an active domain, the process is frozen without further access to CPU resources and I/O but the memory used by the domain at the hypervisor level will stay allocated. Use virDomainResume() to reactivate the domain. This function may requires privileged access.

virDomainUndefine

int	virDomainUndefine		(virDomainPtr domain)

Undefine a domain but does not stop it if it is running

virEventAddHandleFunc

typedef int	(*virEventAddHandleFunc	)	(int fd, 
					 int event, 
					 virEventHandleCallback cb, 
					 void * opaque, 
					 virFreeCallback ff)

Part of the EventImpl, this callback Adds a file handle callback to listen for specific events. The same file handle can be registered multiple times provided the requested event sets are non-overlapping If the opaque user data requires free'ing when the handle is unregistered, then a 2nd callback can be supplied for this purpose.

virEventAddTimeoutFunc

typedef int	(*virEventAddTimeoutFunc	)	(int timeout, 
					 virEventTimeoutCallback cb, 
					 void * opaque, 
					 virFreeCallback ff)

Part of the EventImpl, this user-defined callback handles adding an event timeout. If the opaque user data requires free'ing when the handle is unregistered, then a 2nd callback can be supplied for this purpose.

virEventHandleCallback

typedef void	(*virEventHandleCallback	)	(int watch, 
					 int fd, 
					 int events, 
					 void * opaque)

Callback for receiving file handle events. The callback will be invoked once for each event which is pending.

virEventRegisterImpl

void	virEventRegisterImpl		(virEventAddHandleFunc addHandle, 
					 virEventUpdateHandleFunc updateHandle, 
					 virEventRemoveHandleFunc removeHandle, 
					 virEventAddTimeoutFunc addTimeout, 
					 virEventUpdateTimeoutFunc updateTimeout, 
					 virEventRemoveTimeoutFunc removeTimeout)

virEventRemoveHandleFunc

typedef int	(*virEventRemoveHandleFunc)	(int watch)

Part of the EventImpl, this user-provided callback is notified when an fd is no longer being listened on. If a virEventHandleFreeFunc was supplied when the handle was registered, it will be invoked some time during, or after this function call, when it is safe to release the user data.

virEventRemoveTimeoutFunc

typedef int	(*virEventRemoveTimeoutFunc)	(int timer)

Part of the EventImpl, this user-defined callback removes a timer If a virEventTimeoutFreeFunc was supplied when the handle was registered, it will be invoked some time during, or after this function call, when it is safe to release the user data.

virEventTimeoutCallback

typedef void	(*virEventTimeoutCallback	)	(int timer, 
					 void * opaque)

callback for receiving timer events

virEventUpdateHandleFunc

typedef void	(*virEventUpdateHandleFunc)	(int watch, 
					 int event)

Part of the EventImpl, this user-provided callback is notified when events to listen on change

virEventUpdateTimeoutFunc

typedef void	(*virEventUpdateTimeoutFunc)	(int timer, 
					 int timeout)

Part of the EventImpl, this user-defined callback updates an event timeout.

virFreeCallback

typedef void	(*virFreeCallback		)	(void * opaque)

virGetVersion

int	virGetVersion			(unsigned long * libVer, 
					 const char * type, 
					 unsigned long * typeVer)

Provides two information back, @libVer is the version of the library while @typeVer will be the version of the hypervisor type @type against which the library was compiled. If @type is NULL, "Xen" is assumed, if @type is unknown or not available, an error code will be returned and @typeVer will be 0.

virInitialize

int	virInitialize			(void)

Initialize the library. It's better to call this routine at startup in multithreaded applications to avoid potential race when initializing the library.

virNetworkCreate

int	virNetworkCreate		(virNetworkPtr network)

Create and start a defined network. If the call succeed the network moves from the defined to the running networks pools.

virNetworkCreateXML

virNetworkPtr	virNetworkCreateXML	(virConnectPtr conn, 
					 const char * xmlDesc)

Create and start a new virtual network, based on an XML description similar to the one returned by virNetworkGetXMLDesc()

virNetworkDefineXML

virNetworkPtr	virNetworkDefineXML	(virConnectPtr conn, 
					 const char * xml)

Define a network, but does not create it

virNetworkDestroy

int	virNetworkDestroy		(virNetworkPtr network)

Destroy the network object. The running instance is shutdown if not down already and all resources used by it are given back to the hypervisor. This does not free the associated virNetworkPtr object. This function may require privileged access

virNetworkFree

int	virNetworkFree			(virNetworkPtr network)

Free the network object. The running instance is kept alive. The data structure is freed and should not be used thereafter.

virNetworkGetAutostart

int	virNetworkGetAutostart		(virNetworkPtr network, 
					 int * autostart)

Provides a boolean value indicating whether the network configured to be automatically started when the host machine boots.

virNetworkGetBridgeName

char *	virNetworkGetBridgeName		(virNetworkPtr network)

Provides a bridge interface name to which a domain may connect a network interface in order to join the network.

virNetworkGetConnect

virConnectPtr	virNetworkGetConnect	(virNetworkPtr net)

Provides the connection pointer associated with a network. The reference counter on the connection is not increased by this call. WARNING: When writing libvirt bindings in other languages, do not use this function. Instead, store the connection and the network object together.

virNetworkGetName

const char *	virNetworkGetName	(virNetworkPtr network)

Get the public name for that network

virNetworkGetUUID

int	virNetworkGetUUID		(virNetworkPtr network, 
					 unsigned char * uuid)

Get the UUID for a network

virNetworkGetUUIDString

int	virNetworkGetUUIDString		(virNetworkPtr network, 
					 char * buf)

Get the UUID for a network as string. For more information about UUID see RFC4122.

virNetworkGetXMLDesc

char *	virNetworkGetXMLDesc		(virNetworkPtr network, 
					 int flags)

Provide an XML description of the network. The description may be reused later to relaunch the network with virNetworkCreateXML().

virNetworkLookupByName

virNetworkPtr	virNetworkLookupByName	(virConnectPtr conn, 
					 const char * name)

Try to lookup a network on the given hypervisor based on its name.

virNetworkLookupByUUID

virNetworkPtr	virNetworkLookupByUUID	(virConnectPtr conn, 
					 const unsigned char * uuid)

Try to lookup a network on the given hypervisor based on its UUID.

virNetworkLookupByUUIDString

virNetworkPtr	virNetworkLookupByUUIDString	(virConnectPtr conn, 
						 const char * uuidstr)

Try to lookup a network on the given hypervisor based on its UUID.

virNetworkRef

int	virNetworkRef			(virNetworkPtr network)

Increment the reference count on the network. For each additional call to this method, there shall be a corresponding call to virNetworkFree to release the reference count, once the caller no longer needs the reference to this object. This method is typically useful for applications where multiple threads are using a connection, and it is required that the connection remain open until all threads have finished using it. ie, each new thread using a network would increment the reference count.

virNetworkSetAutostart

int	virNetworkSetAutostart		(virNetworkPtr network, 
					 int autostart)

Configure the network to be automatically started when the host machine boots.

virNetworkUndefine

int	virNetworkUndefine		(virNetworkPtr network)

Undefine a network but does not stop it if it is running

virNodeDeviceDettach

int	virNodeDeviceDettach		(virNodeDevicePtr dev)

virNodeDeviceFree

int	virNodeDeviceFree		(virNodeDevicePtr dev)

Drops a reference to the node device, freeing it if this was the last reference.

virNodeDeviceGetName

const char *	virNodeDeviceGetName	(virNodeDevicePtr dev)

Just return the device name

virNodeDeviceGetParent

const char *	virNodeDeviceGetParent	(virNodeDevicePtr dev)

Accessor for the parent of the device

virNodeDeviceGetXMLDesc

char *	virNodeDeviceGetXMLDesc		(virNodeDevicePtr dev, 
					 unsigned int flags)

Fetch an XML document describing all aspects of the device.

virNodeDeviceListCaps

int	virNodeDeviceListCaps		(virNodeDevicePtr dev, 
					 char ** const names, 
					 int maxnames)

Lists the names of the capabilities supported by the device.

virNodeDeviceLookupByName

virNodeDevicePtr	virNodeDeviceLookupByName	(virConnectPtr conn, 
							 const char * name)

Lookup a node device by its name.

virNodeDeviceNumOfCaps

int	virNodeDeviceNumOfCaps		(virNodeDevicePtr dev)

Accessor for the number of capabilities supported by the device.

virNodeDeviceReAttach

int	virNodeDeviceReAttach		(virNodeDevicePtr dev)

Re-attach a previously dettached node device to the node so that it may be used by the node again. Depending on the hypervisor, this may involve operations such as resetting the device, unbinding it from a dummy device driver and binding it to its appropriate driver. If the device is currently in use by a guest, this method may fail.

virNodeDeviceRef

int	virNodeDeviceRef		(virNodeDevicePtr dev)

Increment the reference count on the dev. For each additional call to this method, there shall be a corresponding call to virNodeDeviceFree to release the reference count, once the caller no longer needs the reference to this object. This method is typically useful for applications where multiple threads are using a connection, and it is required that the connection remain open until all threads have finished using it. ie, each new thread using a dev would increment the reference count.

virNodeDeviceReset

int	virNodeDeviceReset		(virNodeDevicePtr dev)

Reset a previously dettached node device to the node before or after assigning it to a guest. The exact reset semantics depends on the hypervisor and device type but, for example, KVM will attempt to reset PCI devices with a Function Level Reset, Secondary Bus Reset or a Power Management D-State reset. If the reset will affect other devices which are currently in use, this function may fail.

virNodeGetCellsFreeMemory

int	virNodeGetCellsFreeMemory	(virConnectPtr conn, 
					 unsigned long long * freeMems, 
					 int startCell, 
					 int maxCells)

This call returns the amount of free memory in one or more NUMA cells. The @freeMems array must be allocated by the caller and will be filled with the amount of free memory in kilobytes for each cell requested, starting with startCell (in freeMems[0]), up to either (startCell + maxCells), or the number of additional cells in the node, whichever is smaller.

virNodeGetFreeMemory

unsigned long long	virNodeGetFreeMemory	(virConnectPtr conn)

provides the free memory available on the Node

virNodeGetInfo

int	virNodeGetInfo			(virConnectPtr conn, 
					 virNodeInfoPtr info)

Extract hardware information about the node.

virNodeGetSecurityModel

int	virNodeGetSecurityModel		(virConnectPtr conn, 
					 virSecurityModelPtr secmodel)

Extract the security model of a hypervisor.

virNodeListDevices

int	virNodeListDevices		(virConnectPtr conn, 
					 const char * cap, 
					 char ** const names, 
					 int maxnames, 
					 unsigned int flags)

Collect the list of node devices, and store their names in @names If the optional 'cap' argument is non-NULL, then the count will be restricted to devices with the specified capability

virNodeNumOfDevices

int	virNodeNumOfDevices		(virConnectPtr conn, 
					 const char * cap, 
					 unsigned int flags)

Provides the number of node devices. If the optional 'cap' argument is non-NULL, then the count will be restricted to devices with the specified capability

virStoragePoolBuild

int	virStoragePoolBuild		(virStoragePoolPtr pool, 
					 unsigned int flags)

Build the underlying storage pool

virStoragePoolCreate

int	virStoragePoolCreate		(virStoragePoolPtr pool, 
					 unsigned int flags)

Starts an inactive storage pool

virStoragePoolCreateXML

virStoragePoolPtr	virStoragePoolCreateXML	(virConnectPtr conn, 
						 const char * xmlDesc, 
						 unsigned int flags)

Create a new storage based on its XML description. The pool is not persistent, so its definition will disappear when it is destroyed, or if the host is restarted

virStoragePoolDefineXML

virStoragePoolPtr	virStoragePoolDefineXML	(virConnectPtr conn, 
						 const char * xml, 
						 unsigned int flags)

Define a new inactive storage pool based on its XML description. The pool is persistent, until explicitly undefined.

virStoragePoolDelete

int	virStoragePoolDelete		(virStoragePoolPtr pool, 
					 unsigned int flags)

Delete the underlying pool resources. This is a non-recoverable operation. The virStoragePoolPtr object itself is not free'd.

virStoragePoolDestroy

int	virStoragePoolDestroy		(virStoragePoolPtr pool)

Destroy an active storage pool. This will deactivate the pool on the host, but keep any persistent config associated with it. If it has a persistent config it can later be restarted with virStoragePoolCreate(). This does not free the associated virStoragePoolPtr object.

virStoragePoolFree

int	virStoragePoolFree		(virStoragePoolPtr pool)

Free a storage pool object, releasing all memory associated with it. Does not change the state of the pool on the host.

virStoragePoolGetAutostart

int	virStoragePoolGetAutostart	(virStoragePoolPtr pool, 
					 int * autostart)

Fetches the value of the autostart flag, which determines whether the pool is automatically started at boot time

virStoragePoolGetConnect

virConnectPtr	virStoragePoolGetConnect	(virStoragePoolPtr pool)

Provides the connection pointer associated with a storage pool. The reference counter on the connection is not increased by this call. WARNING: When writing libvirt bindings in other languages, do not use this function. Instead, store the connection and the pool object together.

virStoragePoolGetInfo

int	virStoragePoolGetInfo		(virStoragePoolPtr pool, 
					 virStoragePoolInfoPtr info)

Get volatile information about the storage pool such as free space / usage summary

virStoragePoolGetName

const char *	virStoragePoolGetName	(virStoragePoolPtr pool)

Fetch the locally unique name of the storage pool

virStoragePoolGetUUID

int	virStoragePoolGetUUID		(virStoragePoolPtr pool, 
					 unsigned char * uuid)

Fetch the globally unique ID of the storage pool

virStoragePoolGetUUIDString

int	virStoragePoolGetUUIDString	(virStoragePoolPtr pool, 
					 char * buf)

Fetch the globally unique ID of the storage pool as a string

virStoragePoolGetXMLDesc

char *	virStoragePoolGetXMLDesc	(virStoragePoolPtr pool, 
					 unsigned int flags)

Fetch an XML document describing all aspects of the storage pool. This is suitable for later feeding back into the virStoragePoolCreateXML method.

virStoragePoolListVolumes

int	virStoragePoolListVolumes	(virStoragePoolPtr pool, 
					 char ** const names, 
					 int maxnames)

Fetch list of storage volume names, limiting to at most maxnames.

virStoragePoolLookupByName

virStoragePoolPtr	virStoragePoolLookupByName	(virConnectPtr conn, 
							 const char * name)

Fetch a storage pool based on its unique name

virStoragePoolLookupByUUID

virStoragePoolPtr	virStoragePoolLookupByUUID	(virConnectPtr conn, 
							 const unsigned char * uuid)

Fetch a storage pool based on its globally unique id

virStoragePoolLookupByUUIDString

virStoragePoolPtr	virStoragePoolLookupByUUIDString	(virConnectPtr conn, 
							 const char * uuidstr)

Fetch a storage pool based on its globally unique id

virStoragePoolLookupByVolume

virStoragePoolPtr	virStoragePoolLookupByVolume	(virStorageVolPtr vol)

Fetch a storage pool which contains a particular volume

virStoragePoolNumOfVolumes

int	virStoragePoolNumOfVolumes	(virStoragePoolPtr pool)

Fetch the number of storage volumes within a pool

virStoragePoolRef

int	virStoragePoolRef		(virStoragePoolPtr pool)

Increment the reference count on the pool. For each additional call to this method, there shall be a corresponding call to virStoragePoolFree to release the reference count, once the caller no longer needs the reference to this object. This method is typically useful for applications where multiple threads are using a connection, and it is required that the connection remain open until all threads have finished using it. ie, each new thread using a pool would increment the reference count.

virStoragePoolRefresh

int	virStoragePoolRefresh		(virStoragePoolPtr pool, 
					 unsigned int flags)

Request that the pool refresh its list of volumes. This may involve communicating with a remote server, and/or initializing new devices at the OS layer

virStoragePoolSetAutostart

int	virStoragePoolSetAutostart	(virStoragePoolPtr pool, 
					 int autostart)

Sets the autostart flag

virStoragePoolUndefine

int	virStoragePoolUndefine		(virStoragePoolPtr pool)

Undefine an inactive storage pool

virStorageVolCreateXML

virStorageVolPtr	virStorageVolCreateXML	(virStoragePoolPtr pool, 
						 const char * xmldesc, 
						 unsigned int flags)

Create a storage volume within a pool based on an XML description. Not all pools support creation of volumes

virStorageVolDelete

int	virStorageVolDelete		(virStorageVolPtr vol, 
					 unsigned int flags)

Delete the storage volume from the pool

virStorageVolFree

int	virStorageVolFree		(virStorageVolPtr vol)

Release the storage volume handle. The underlying storage volume continues to exist.

virStorageVolGetConnect

virConnectPtr	virStorageVolGetConnect	(virStorageVolPtr vol)

Provides the connection pointer associated with a storage volume. The reference counter on the connection is not increased by this call. WARNING: When writing libvirt bindings in other languages, do not use this function. Instead, store the connection and the volume object together.

virStorageVolGetInfo

int	virStorageVolGetInfo		(virStorageVolPtr vol, 
					 virStorageVolInfoPtr info)

Fetches volatile information about the storage volume such as its current allocation

virStorageVolGetKey

const char *	virStorageVolGetKey	(virStorageVolPtr vol)

Fetch the storage volume key. This is globally unique, so the same volume will have the same key no matter what host it is accessed from

virStorageVolGetName

const char *	virStorageVolGetName	(virStorageVolPtr vol)

Fetch the storage volume name. This is unique within the scope of a pool

virStorageVolGetPath

char *	virStorageVolGetPath		(virStorageVolPtr vol)

Fetch the storage volume path. Depending on the pool configuration this is either persistent across hosts, or dynamically assigned at pool startup. Consult pool documentation for information on getting the persistent naming

virStorageVolGetXMLDesc

char *	virStorageVolGetXMLDesc		(virStorageVolPtr vol, 
					 unsigned int flags)

Fetch an XML document describing all aspects of the storage volume

virStorageVolLookupByKey

virStorageVolPtr	virStorageVolLookupByKey	(virConnectPtr conn, 
							 const char * key)

Fetch a pointer to a storage volume based on its globally unique key

virStorageVolLookupByName

virStorageVolPtr	virStorageVolLookupByName	(virStoragePoolPtr pool, 
							 const char * name)

Fetch a pointer to a storage volume based on its name within a pool

virStorageVolLookupByPath

virStorageVolPtr	virStorageVolLookupByPath	(virConnectPtr conn, 
							 const char * path)

Fetch a pointer to a storage volume based on its locally (host) unique path

virStorageVolRef

int	virStorageVolRef		(virStorageVolPtr vol)

Increment the reference count on the vol. For each additional call to this method, there shall be a corresponding call to virStorageVolFree to release the reference count, once the caller no longer needs the reference to this object. This method is typically useful for applications where multiple threads are using a connection, and it is required that the connection remain open until all threads have finished using it. ie, each new thread using a vol would increment the reference count.