mirror of
https://gitlab.com/libvirt/libvirt.git
synced 2024-09-24 08:25:45 +00:00
efed366eb7
Since the name (like scsi_host10) is not stable for vHBA, (it can be changed either after recreating or system rebooting), current API virNodeDeviceLookupByName is not nice to use for management app in this case. (E.g. one wants to destroy the vHBA whose name has been changed after system rebooting, he has to find out current name first). Later patches will support the persistent vHBA via storage pool, with which one can identify the vHBA stably by the wwnn && wwpn pair. So this new API comes.
1784 lines
73 KiB
C
1784 lines
73 KiB
C
/*
|
|
* driver.h: description of the set of interfaces provided by a
|
|
* entry point to the virtualization engine
|
|
*/
|
|
|
|
#ifndef __VIR_DRIVER_H__
|
|
# define __VIR_DRIVER_H__
|
|
|
|
# include "config.h"
|
|
|
|
# include <unistd.h>
|
|
|
|
# include "internal.h"
|
|
# include "viruri.h"
|
|
/*
|
|
* List of registered drivers numbers
|
|
*/
|
|
typedef enum {
|
|
VIR_DRV_XEN_UNIFIED = 1,
|
|
VIR_DRV_TEST = 2,
|
|
VIR_DRV_QEMU = 3,
|
|
VIR_DRV_REMOTE = 4,
|
|
VIR_DRV_OPENVZ = 5,
|
|
VIR_DRV_LXC = 6,
|
|
VIR_DRV_UML = 7,
|
|
VIR_DRV_VBOX = 8,
|
|
VIR_DRV_ONE = 9,
|
|
VIR_DRV_ESX = 10,
|
|
VIR_DRV_PHYP = 11,
|
|
VIR_DRV_XENAPI = 12,
|
|
VIR_DRV_VMWARE = 13,
|
|
VIR_DRV_LIBXL = 14,
|
|
VIR_DRV_HYPERV = 15,
|
|
VIR_DRV_PARALLELS = 16,
|
|
} virDrvNo;
|
|
|
|
|
|
/* Status codes returned from driver open call. */
|
|
typedef enum {
|
|
/* Opened successfully. */
|
|
VIR_DRV_OPEN_SUCCESS = 0,
|
|
|
|
/* 'name' is not for us. */
|
|
VIR_DRV_OPEN_DECLINED = -1,
|
|
|
|
/* 'name' is for us, but there was some error. virConnectOpen will
|
|
* return an error rather than continue probing the other drivers.
|
|
*/
|
|
VIR_DRV_OPEN_ERROR = -2,
|
|
} virDrvOpenStatus;
|
|
|
|
|
|
/* Internal feature-detection macro. Don't call drv->supports_feature
|
|
* directly if you don't have to, because it may be NULL, use this macro
|
|
* instead.
|
|
*
|
|
* Note that this treats a possible error returned by drv->supports_feature
|
|
* the same as not supported. If you care about the error, call
|
|
* drv->supports_feature directly.
|
|
*
|
|
* Returns:
|
|
* != 0 Feature is supported.
|
|
* 0 Feature is not supported.
|
|
*/
|
|
# define VIR_DRV_SUPPORTS_FEATURE(drv,conn,feature) \
|
|
((drv)->supports_feature ? \
|
|
(drv)->supports_feature((conn), (feature)) > 0 : 0)
|
|
|
|
typedef virDrvOpenStatus
|
|
(*virDrvOpen) (virConnectPtr conn,
|
|
virConnectAuthPtr auth,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvClose) (virConnectPtr conn);
|
|
typedef int
|
|
(*virDrvDrvSupportsFeature) (virConnectPtr conn, int feature);
|
|
typedef const char *
|
|
(*virDrvGetType) (virConnectPtr conn);
|
|
typedef int
|
|
(*virDrvGetVersion) (virConnectPtr conn,
|
|
unsigned long *hvVer);
|
|
typedef int
|
|
(*virDrvGetLibVersion) (virConnectPtr conn,
|
|
unsigned long *libVer);
|
|
typedef char *
|
|
(*virDrvGetHostname) (virConnectPtr conn);
|
|
typedef char *
|
|
(*virDrvGetURI) (virConnectPtr conn);
|
|
typedef char *
|
|
(*virDrvGetSysinfo) (virConnectPtr conn,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvGetMaxVcpus) (virConnectPtr conn,
|
|
const char *type);
|
|
typedef int
|
|
(*virDrvNodeGetInfo) (virConnectPtr conn,
|
|
virNodeInfoPtr info);
|
|
typedef char *
|
|
(*virDrvGetCapabilities) (virConnectPtr conn);
|
|
typedef int
|
|
(*virDrvListDomains) (virConnectPtr conn,
|
|
int *ids,
|
|
int maxids);
|
|
typedef int
|
|
(*virDrvNumOfDomains) (virConnectPtr conn);
|
|
typedef virDomainPtr
|
|
(*virDrvDomainCreateXML) (virConnectPtr conn,
|
|
const char *xmlDesc,
|
|
unsigned int flags);
|
|
typedef virDomainPtr
|
|
(*virDrvDomainLookupByID) (virConnectPtr conn,
|
|
int id);
|
|
typedef virDomainPtr
|
|
(*virDrvDomainLookupByUUID) (virConnectPtr conn,
|
|
const unsigned char *uuid);
|
|
typedef virDomainPtr
|
|
(*virDrvDomainLookupByName) (virConnectPtr conn,
|
|
const char *name);
|
|
typedef int
|
|
(*virDrvDomainSuspend) (virDomainPtr domain);
|
|
typedef int
|
|
(*virDrvDomainResume) (virDomainPtr domain);
|
|
typedef int
|
|
(*virDrvDomainPMSuspendForDuration) (virDomainPtr,
|
|
unsigned int target,
|
|
unsigned long long duration,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvDomainPMWakeup) (virDomainPtr domain,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvDomainShutdown) (virDomainPtr domain);
|
|
typedef int
|
|
(*virDrvDomainReboot) (virDomainPtr domain,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvDomainReset) (virDomainPtr domain,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvDomainDestroy) (virDomainPtr domain);
|
|
typedef int
|
|
(*virDrvDomainDestroyFlags) (virDomainPtr domain,
|
|
unsigned int flags);
|
|
typedef char *
|
|
(*virDrvDomainGetOSType) (virDomainPtr domain);
|
|
|
|
typedef char *
|
|
(*virDrvDomainGetHostname) (virDomainPtr domain,
|
|
unsigned int flags);
|
|
|
|
typedef unsigned long long
|
|
(*virDrvDomainGetMaxMemory) (virDomainPtr domain);
|
|
typedef int
|
|
(*virDrvDomainSetMaxMemory) (virDomainPtr domain,
|
|
unsigned long memory);
|
|
typedef int
|
|
(*virDrvDomainSetMemory) (virDomainPtr domain,
|
|
unsigned long memory);
|
|
typedef int
|
|
(*virDrvDomainSetMemoryFlags) (virDomainPtr domain,
|
|
unsigned long memory,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvDomainSetMemoryParameters)
|
|
(virDomainPtr domain,
|
|
virTypedParameterPtr params,
|
|
int nparams,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvDomainGetMemoryParameters)
|
|
(virDomainPtr domain,
|
|
virTypedParameterPtr params,
|
|
int *nparams,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvDomainSetNumaParameters)
|
|
(virDomainPtr domain,
|
|
virTypedParameterPtr params,
|
|
int nparams,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvDomainGetNumaParameters)
|
|
(virDomainPtr domain,
|
|
virTypedParameterPtr params,
|
|
int *nparams,
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvDomainSetBlkioParameters)
|
|
(virDomainPtr domain,
|
|
virTypedParameterPtr params,
|
|
int nparams,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvDomainGetBlkioParameters)
|
|
(virDomainPtr domain,
|
|
virTypedParameterPtr params,
|
|
int *nparams,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvDomainGetInfo) (virDomainPtr domain,
|
|
virDomainInfoPtr info);
|
|
typedef int
|
|
(*virDrvDomainGetState) (virDomainPtr domain,
|
|
int *state,
|
|
int *reason,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvDomainGetControlInfo) (virDomainPtr domain,
|
|
virDomainControlInfoPtr info,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvDomainSave) (virDomainPtr domain,
|
|
const char *to);
|
|
typedef int
|
|
(*virDrvDomainSaveFlags) (virDomainPtr domain,
|
|
const char *to,
|
|
const char *dxml,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvDomainRestore) (virConnectPtr conn,
|
|
const char *from);
|
|
typedef int
|
|
(*virDrvDomainRestoreFlags) (virConnectPtr conn,
|
|
const char *from,
|
|
const char *dxml,
|
|
unsigned int flags);
|
|
typedef char *
|
|
(*virDrvDomainSaveImageGetXMLDesc) (virConnectPtr conn,
|
|
const char *file,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvDomainSaveImageDefineXML) (virConnectPtr conn,
|
|
const char *file,
|
|
const char *dxml,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvDomainCoreDump) (virDomainPtr domain,
|
|
const char *to,
|
|
unsigned int flags);
|
|
typedef char *
|
|
(*virDrvDomainScreenshot) (virDomainPtr domain,
|
|
virStreamPtr stream,
|
|
unsigned int screen,
|
|
unsigned int flags);
|
|
typedef char *
|
|
(*virDrvDomainGetXMLDesc) (virDomainPtr dom,
|
|
unsigned int flags);
|
|
typedef char *
|
|
(*virDrvConnectDomainXMLFromNative) (virConnectPtr conn,
|
|
const char *nativeFormat,
|
|
const char *nativeConfig,
|
|
unsigned int flags);
|
|
typedef char *
|
|
(*virDrvConnectDomainXMLToNative) (virConnectPtr conn,
|
|
const char *nativeFormat,
|
|
const char *domainXml,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvListDefinedDomains) (virConnectPtr conn,
|
|
char **const names,
|
|
int maxnames);
|
|
typedef int
|
|
(*virDrvListAllDomains) (virConnectPtr conn,
|
|
virDomainPtr **domains,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvNumOfDefinedDomains) (virConnectPtr conn);
|
|
typedef int
|
|
(*virDrvDomainCreate) (virDomainPtr dom);
|
|
typedef int
|
|
(*virDrvDomainCreateWithFlags) (virDomainPtr dom,
|
|
unsigned int flags);
|
|
typedef virDomainPtr
|
|
(*virDrvDomainDefineXML) (virConnectPtr conn,
|
|
const char *xml);
|
|
typedef int
|
|
(*virDrvDomainUndefine) (virDomainPtr dom);
|
|
typedef int
|
|
(*virDrvDomainUndefineFlags) (virDomainPtr dom,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvDomainSetVcpus) (virDomainPtr domain,
|
|
unsigned int nvcpus);
|
|
typedef int
|
|
(*virDrvDomainSetVcpusFlags) (virDomainPtr domain,
|
|
unsigned int nvcpus,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvDomainGetVcpusFlags) (virDomainPtr domain,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvDomainPinVcpu) (virDomainPtr domain,
|
|
unsigned int vcpu,
|
|
unsigned char *cpumap,
|
|
int maplen);
|
|
typedef int
|
|
(*virDrvDomainPinVcpuFlags) (virDomainPtr domain,
|
|
unsigned int vcpu,
|
|
unsigned char *cpumap,
|
|
int maplen,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvDomainGetVcpuPinInfo) (virDomainPtr domain,
|
|
int ncpumaps,
|
|
unsigned char *cpumaps,
|
|
int maplen,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvDomainPinEmulator) (virDomainPtr domain,
|
|
unsigned char *cpumap,
|
|
int maplen,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvDomainGetEmulatorPinInfo) (virDomainPtr domain,
|
|
unsigned char *cpumaps,
|
|
int maplen,
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvDomainGetVcpus) (virDomainPtr domain,
|
|
virVcpuInfoPtr info,
|
|
int maxinfo,
|
|
unsigned char *cpumaps,
|
|
int maplen);
|
|
typedef int
|
|
(*virDrvDomainGetMaxVcpus) (virDomainPtr domain);
|
|
|
|
typedef int
|
|
(*virDrvDomainGetSecurityLabel) (virDomainPtr domain,
|
|
virSecurityLabelPtr seclabel);
|
|
typedef int
|
|
(*virDrvDomainGetSecurityLabelList) (virDomainPtr domain,
|
|
virSecurityLabelPtr* seclabels);
|
|
typedef int
|
|
(*virDrvNodeGetSecurityModel) (virConnectPtr conn,
|
|
virSecurityModelPtr secmodel);
|
|
typedef int
|
|
(*virDrvDomainAttachDevice) (virDomainPtr domain,
|
|
const char *xml);
|
|
typedef int
|
|
(*virDrvDomainAttachDeviceFlags) (virDomainPtr domain,
|
|
const char *xml,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvDomainDetachDevice) (virDomainPtr domain,
|
|
const char *xml);
|
|
typedef int
|
|
(*virDrvDomainDetachDeviceFlags) (virDomainPtr domain,
|
|
const char *xml,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvDomainUpdateDeviceFlags) (virDomainPtr domain,
|
|
const char *xml,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvDomainGetAutostart) (virDomainPtr domain,
|
|
int *autostart);
|
|
typedef int
|
|
(*virDrvDomainSetAutostart) (virDomainPtr domain,
|
|
int autostart);
|
|
|
|
typedef char *
|
|
(*virDrvDomainGetSchedulerType) (virDomainPtr domain,
|
|
int *nparams);
|
|
|
|
typedef int
|
|
(*virDrvDomainGetSchedulerParameters)
|
|
(virDomainPtr domain,
|
|
virTypedParameterPtr params,
|
|
int *nparams);
|
|
|
|
typedef int
|
|
(*virDrvDomainGetSchedulerParametersFlags)
|
|
(virDomainPtr domain,
|
|
virTypedParameterPtr params,
|
|
int *nparams,
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvDomainSetSchedulerParameters)
|
|
(virDomainPtr domain,
|
|
virTypedParameterPtr params,
|
|
int nparams);
|
|
|
|
typedef int
|
|
(*virDrvDomainSetSchedulerParametersFlags)
|
|
(virDomainPtr domain,
|
|
virTypedParameterPtr params,
|
|
int nparams,
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvDomainBlockStats)
|
|
(virDomainPtr domain,
|
|
const char *path,
|
|
struct _virDomainBlockStats *stats);
|
|
typedef int
|
|
(*virDrvDomainBlockStatsFlags)
|
|
(virDomainPtr domain,
|
|
const char *path,
|
|
virTypedParameterPtr params,
|
|
int *nparams,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvDomainInterfaceStats)
|
|
(virDomainPtr domain,
|
|
const char *path,
|
|
struct _virDomainInterfaceStats *stats);
|
|
typedef int
|
|
(*virDrvDomainSetInterfaceParameters) (virDomainPtr dom,
|
|
const char *device,
|
|
virTypedParameterPtr params,
|
|
int nparams, unsigned int flags);
|
|
typedef int
|
|
(*virDrvDomainGetInterfaceParameters) (virDomainPtr dom,
|
|
const char *device,
|
|
virTypedParameterPtr params,
|
|
int *nparams, unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvDomainMemoryStats)
|
|
(virDomainPtr domain,
|
|
struct _virDomainMemoryStat *stats,
|
|
unsigned int nr_stats,
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvDomainBlockPeek)
|
|
(virDomainPtr domain,
|
|
const char *path,
|
|
unsigned long long offset, size_t size,
|
|
void *buffer,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvDomainBlockResize)
|
|
(virDomainPtr domain,
|
|
const char *path,
|
|
unsigned long long size,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvDomainMemoryPeek)
|
|
(virDomainPtr domain,
|
|
unsigned long long start, size_t size,
|
|
void *buffer,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvDomainGetBlockInfo)
|
|
(virDomainPtr domain,
|
|
const char *path,
|
|
virDomainBlockInfoPtr info,
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvDomainMigratePrepare)
|
|
(virConnectPtr dconn,
|
|
char **cookie,
|
|
int *cookielen,
|
|
const char *uri_in,
|
|
char **uri_out,
|
|
unsigned long flags,
|
|
const char *dname,
|
|
unsigned long resource);
|
|
|
|
typedef int
|
|
(*virDrvDomainMigratePerform)
|
|
(virDomainPtr domain,
|
|
const char *cookie,
|
|
int cookielen,
|
|
const char *uri,
|
|
unsigned long flags,
|
|
const char *dname,
|
|
unsigned long resource);
|
|
|
|
typedef virDomainPtr
|
|
(*virDrvDomainMigrateFinish)
|
|
(virConnectPtr dconn,
|
|
const char *dname,
|
|
const char *cookie,
|
|
int cookielen,
|
|
const char *uri,
|
|
unsigned long flags);
|
|
|
|
typedef struct _virDriver virDriver;
|
|
typedef virDriver *virDriverPtr;
|
|
|
|
typedef int
|
|
(*virDrvNodeGetCPUStats)
|
|
(virConnectPtr conn,
|
|
int cpuNum,
|
|
virNodeCPUStatsPtr params,
|
|
int *nparams,
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvNodeGetMemoryStats)
|
|
(virConnectPtr conn,
|
|
int cellNum,
|
|
virNodeMemoryStatsPtr params,
|
|
int *nparams,
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvNodeGetCellsFreeMemory)
|
|
(virConnectPtr conn,
|
|
unsigned long long *freeMems,
|
|
int startCell,
|
|
int maxCells);
|
|
|
|
typedef unsigned long long
|
|
(*virDrvNodeGetFreeMemory)
|
|
(virConnectPtr conn);
|
|
|
|
typedef int
|
|
(*virDrvDomainEventRegister)
|
|
(virConnectPtr conn,
|
|
virConnectDomainEventCallback cb,
|
|
void *opaque,
|
|
virFreeCallback freecb);
|
|
|
|
typedef int
|
|
(*virDrvDomainEventDeregister)
|
|
(virConnectPtr conn,
|
|
virConnectDomainEventCallback cb);
|
|
|
|
typedef int
|
|
(*virDrvDomainMigratePrepare2)
|
|
(virConnectPtr dconn,
|
|
char **cookie,
|
|
int *cookielen,
|
|
const char *uri_in,
|
|
char **uri_out,
|
|
unsigned long flags,
|
|
const char *dname,
|
|
unsigned long resource,
|
|
const char *dom_xml);
|
|
|
|
typedef virDomainPtr
|
|
(*virDrvDomainMigrateFinish2)
|
|
(virConnectPtr dconn,
|
|
const char *dname,
|
|
const char *cookie,
|
|
int cookielen,
|
|
const char *uri,
|
|
unsigned long flags,
|
|
int retcode);
|
|
|
|
typedef int
|
|
(*virDrvNodeDeviceDettach)
|
|
(virNodeDevicePtr dev);
|
|
typedef int
|
|
(*virDrvNodeDeviceReAttach)
|
|
(virNodeDevicePtr dev);
|
|
typedef int
|
|
(*virDrvNodeDeviceReset)
|
|
(virNodeDevicePtr dev);
|
|
|
|
typedef int
|
|
(*virDrvDomainMigratePrepareTunnel)
|
|
(virConnectPtr dconn,
|
|
virStreamPtr st,
|
|
unsigned long flags,
|
|
const char *dname,
|
|
unsigned long resource,
|
|
const char *dom_xml);
|
|
|
|
typedef int
|
|
(*virDrvConnectIsEncrypted)(virConnectPtr conn);
|
|
typedef int
|
|
(*virDrvConnectIsSecure)(virConnectPtr conn);
|
|
typedef int
|
|
(*virDrvConnectIsAlive)(virConnectPtr conn);
|
|
typedef int
|
|
(*virDrvDomainIsActive)(virDomainPtr dom);
|
|
typedef int
|
|
(*virDrvDomainIsPersistent)(virDomainPtr dom);
|
|
typedef int
|
|
(*virDrvDomainIsUpdated)(virDomainPtr dom);
|
|
|
|
typedef int
|
|
(*virDrvCompareCPU)(virConnectPtr conn,
|
|
const char *cpu,
|
|
unsigned int flags);
|
|
typedef char *
|
|
(*virDrvBaselineCPU)(virConnectPtr conn,
|
|
const char **xmlCPUs,
|
|
unsigned int ncpus,
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvDomainGetJobInfo)(virDomainPtr domain,
|
|
virDomainJobInfoPtr info);
|
|
|
|
typedef int
|
|
(*virDrvDomainAbortJob)(virDomainPtr domain);
|
|
|
|
typedef int
|
|
(*virDrvDomainMigrateSetMaxDowntime)(virDomainPtr domain,
|
|
unsigned long long downtime,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvDomainMigrateSetMaxSpeed)(virDomainPtr domain,
|
|
unsigned long bandwidth,
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvDomainMigrateGetMaxSpeed)(virDomainPtr domain,
|
|
unsigned long *bandwidth,
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvDomainEventRegisterAny)(virConnectPtr conn,
|
|
virDomainPtr dom,
|
|
int eventID,
|
|
virConnectDomainEventGenericCallback cb,
|
|
void *opaque,
|
|
virFreeCallback freecb);
|
|
|
|
typedef int
|
|
(*virDrvDomainEventDeregisterAny)(virConnectPtr conn,
|
|
int callbackID);
|
|
|
|
typedef int
|
|
(*virDrvDomainManagedSave)(virDomainPtr domain, unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvDomainHasManagedSaveImage)(virDomainPtr domain, unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvDomainManagedSaveRemove)(virDomainPtr domain, unsigned int flags);
|
|
|
|
typedef virDomainSnapshotPtr
|
|
(*virDrvDomainSnapshotCreateXML)(virDomainPtr domain,
|
|
const char *xmlDesc,
|
|
unsigned int flags);
|
|
|
|
typedef char *
|
|
(*virDrvDomainSnapshotGetXMLDesc)(virDomainSnapshotPtr snapshot,
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvDomainSnapshotNum)(virDomainPtr domain, unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvDomainSnapshotListNames)(virDomainPtr domain, char **names,
|
|
int nameslen,
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvDomainListAllSnapshots)(virDomainPtr domain,
|
|
virDomainSnapshotPtr **snaps,
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvDomainSnapshotNumChildren)(virDomainSnapshotPtr snapshot,
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvDomainSnapshotListChildrenNames)(virDomainSnapshotPtr snapshot,
|
|
char **names,
|
|
int nameslen,
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvDomainSnapshotListAllChildren)(virDomainSnapshotPtr snapshot,
|
|
virDomainSnapshotPtr **snaps,
|
|
unsigned int flags);
|
|
|
|
typedef virDomainSnapshotPtr
|
|
(*virDrvDomainSnapshotLookupByName)(virDomainPtr domain,
|
|
const char *name,
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvDomainHasCurrentSnapshot)(virDomainPtr domain, unsigned int flags);
|
|
|
|
typedef virDomainSnapshotPtr
|
|
(*virDrvDomainSnapshotGetParent)(virDomainSnapshotPtr snapshot,
|
|
unsigned int flags);
|
|
|
|
typedef virDomainSnapshotPtr
|
|
(*virDrvDomainSnapshotCurrent)(virDomainPtr domain,
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvDomainSnapshotIsCurrent)(virDomainSnapshotPtr snapshot,
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvDomainSnapshotHasMetadata)(virDomainSnapshotPtr snapshot,
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvDomainRevertToSnapshot)(virDomainSnapshotPtr snapshot,
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvDomainSnapshotDelete)(virDomainSnapshotPtr snapshot,
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvDomainQemuMonitorCommand)(virDomainPtr domain, const char *cmd,
|
|
char **result, unsigned int flags);
|
|
typedef char *
|
|
(*virDrvDomainQemuAgentCommand)(virDomainPtr domain, const char *cmd,
|
|
int timeout, unsigned int flags);
|
|
|
|
/* Choice of unsigned int rather than pid_t is intentional. */
|
|
typedef virDomainPtr
|
|
(*virDrvDomainQemuAttach)(virConnectPtr conn,
|
|
unsigned int pid_value,
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvDomainOpenConsole)(virDomainPtr dom,
|
|
const char *dev_name,
|
|
virStreamPtr st,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvDomainOpenChannel)(virDomainPtr dom,
|
|
const char *name,
|
|
virStreamPtr st,
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvDomainOpenGraphics)(virDomainPtr dom,
|
|
unsigned int idx,
|
|
int fd,
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvDomainInjectNMI)(virDomainPtr dom, unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvDomainSendKey)(virDomainPtr dom, unsigned int codeset,
|
|
unsigned int holdtime,
|
|
unsigned int *keycodes,
|
|
int nkeycodes,
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvDomainSendProcessSignal)(virDomainPtr dom,
|
|
long long pid_value,
|
|
unsigned int signum,
|
|
unsigned int flags);
|
|
|
|
typedef char *
|
|
(*virDrvDomainMigrateBegin3)
|
|
(virDomainPtr domain,
|
|
const char *xmlin,
|
|
char **cookieout,
|
|
int *cookieoutlen,
|
|
unsigned long flags,
|
|
const char *dname,
|
|
unsigned long resource);
|
|
|
|
typedef int
|
|
(*virDrvDomainMigratePrepare3)
|
|
(virConnectPtr dconn,
|
|
const char *cookiein,
|
|
int cookieinlen,
|
|
char **cookieout,
|
|
int *cookieoutlen,
|
|
const char *uri_in,
|
|
char **uri_out,
|
|
unsigned long flags,
|
|
const char *dname,
|
|
unsigned long resource,
|
|
const char *dom_xml);
|
|
|
|
typedef int
|
|
(*virDrvDomainMigratePrepareTunnel3)
|
|
(virConnectPtr dconn,
|
|
virStreamPtr st,
|
|
const char *cookiein,
|
|
int cookieinlen,
|
|
char **cookieout,
|
|
int *cookieoutlen,
|
|
unsigned long flags,
|
|
const char *dname,
|
|
unsigned long resource,
|
|
const char *dom_xml);
|
|
|
|
|
|
typedef int
|
|
(*virDrvDomainMigratePerform3)
|
|
(virDomainPtr dom,
|
|
const char *xmlin,
|
|
const char *cookiein,
|
|
int cookieinlen,
|
|
char **cookieout,
|
|
int *cookieoutlen,
|
|
const char *dconnuri,
|
|
const char *uri,
|
|
unsigned long flags,
|
|
const char *dname,
|
|
unsigned long resource);
|
|
|
|
typedef virDomainPtr
|
|
(*virDrvDomainMigrateFinish3)
|
|
(virConnectPtr dconn,
|
|
const char *dname,
|
|
const char *cookiein,
|
|
int cookieinlen,
|
|
char **cookieout,
|
|
int *cookieoutlen,
|
|
const char *dconnuri,
|
|
const char *uri,
|
|
unsigned long flags,
|
|
int cancelled);
|
|
|
|
typedef int
|
|
(*virDrvDomainMigrateConfirm3)
|
|
(virDomainPtr domain,
|
|
const char *cookiein,
|
|
int cookieinlen,
|
|
unsigned long flags,
|
|
int cancelled);
|
|
|
|
typedef int
|
|
(*virDrvNodeSuspendForDuration)(virConnectPtr conn, unsigned int target,
|
|
unsigned long long duration,
|
|
unsigned int flags);
|
|
|
|
|
|
typedef int
|
|
(*virDrvDomainBlockJobAbort)(virDomainPtr dom, const char *path,
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvDomainGetBlockJobInfo)(virDomainPtr dom, const char *path,
|
|
virDomainBlockJobInfoPtr info,
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvDomainBlockJobSetSpeed)(virDomainPtr dom,
|
|
const char *path, unsigned long bandwidth,
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvDomainBlockPull)(virDomainPtr dom, const char *path,
|
|
unsigned long bandwidth, unsigned int flags);
|
|
typedef int
|
|
(*virDrvDomainBlockRebase)(virDomainPtr dom, const char *path,
|
|
const char *base, unsigned long bandwidth,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvDomainBlockCommit)(virDomainPtr dom, const char *disk,
|
|
const char *base, const char *top,
|
|
unsigned long bandwidth, unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvSetKeepAlive)(virConnectPtr conn,
|
|
int interval,
|
|
unsigned int count);
|
|
|
|
typedef int
|
|
(*virDrvDomainSetBlockIoTune)(virDomainPtr dom,
|
|
const char *disk,
|
|
virTypedParameterPtr params,
|
|
int nparams,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvDomainGetBlockIoTune)(virDomainPtr dom,
|
|
const char *disk,
|
|
virTypedParameterPtr params,
|
|
int *nparams,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvDomainShutdownFlags)(virDomainPtr domain,
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvDomainGetCPUStats)(virDomainPtr domain,
|
|
virTypedParameterPtr params,
|
|
unsigned int nparams,
|
|
int start_cpu,
|
|
unsigned int ncpus,
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvDomainGetDiskErrors)(virDomainPtr dom,
|
|
virDomainDiskErrorPtr errors,
|
|
unsigned int maxerrors,
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvDomainSetMetadata)(virDomainPtr dom,
|
|
int type,
|
|
const char *metadata,
|
|
const char *key,
|
|
const char *uri,
|
|
unsigned int flags);
|
|
|
|
typedef char *
|
|
(*virDrvDomainGetMetadata)(virDomainPtr dom,
|
|
int type,
|
|
const char *uri,
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvNodeGetMemoryParameters)(virConnectPtr conn,
|
|
virTypedParameterPtr params,
|
|
int *nparams,
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvNodeSetMemoryParameters)(virConnectPtr conn,
|
|
virTypedParameterPtr params,
|
|
int nparams,
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvNodeGetCPUMap)(virConnectPtr conn,
|
|
unsigned char **cpumap,
|
|
unsigned int *online,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvDomainFSTrim)(virDomainPtr dom,
|
|
const char *mountPoint,
|
|
unsigned long long minimum,
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvDomainLxcOpenNamespace)(virDomainPtr dom,
|
|
int **fdlist,
|
|
unsigned int flags);
|
|
|
|
/**
|
|
* _virDriver:
|
|
*
|
|
* Structure associated to a virtualization driver, defining the various
|
|
* entry points for it.
|
|
*
|
|
* All drivers must support the following fields/methods:
|
|
* - no
|
|
* - name
|
|
* - open
|
|
* - close
|
|
*/
|
|
struct _virDriver {
|
|
int no; /* the number virDrvNo */
|
|
const char *name; /* the name of the driver */
|
|
virDrvOpen open;
|
|
virDrvClose close;
|
|
virDrvDrvSupportsFeature supports_feature;
|
|
virDrvGetType type;
|
|
virDrvGetVersion version;
|
|
virDrvGetLibVersion libvirtVersion;
|
|
virDrvGetHostname getHostname;
|
|
virDrvGetSysinfo getSysinfo;
|
|
virDrvGetMaxVcpus getMaxVcpus;
|
|
virDrvNodeGetInfo nodeGetInfo;
|
|
virDrvGetCapabilities getCapabilities;
|
|
virDrvListDomains listDomains;
|
|
virDrvNumOfDomains numOfDomains;
|
|
virDrvListAllDomains listAllDomains;
|
|
virDrvDomainCreateXML domainCreateXML;
|
|
virDrvDomainLookupByID domainLookupByID;
|
|
virDrvDomainLookupByUUID domainLookupByUUID;
|
|
virDrvDomainLookupByName domainLookupByName;
|
|
virDrvDomainSuspend domainSuspend;
|
|
virDrvDomainResume domainResume;
|
|
virDrvDomainPMSuspendForDuration domainPMSuspendForDuration;
|
|
virDrvDomainPMWakeup domainPMWakeup;
|
|
virDrvDomainShutdown domainShutdown;
|
|
virDrvDomainShutdownFlags domainShutdownFlags;
|
|
virDrvDomainReboot domainReboot;
|
|
virDrvDomainReset domainReset;
|
|
virDrvDomainDestroy domainDestroy;
|
|
virDrvDomainDestroyFlags domainDestroyFlags;
|
|
virDrvDomainGetOSType domainGetOSType;
|
|
virDrvDomainGetHostname domainGetHostname;
|
|
virDrvDomainGetMaxMemory domainGetMaxMemory;
|
|
virDrvDomainSetMaxMemory domainSetMaxMemory;
|
|
virDrvDomainSetMemory domainSetMemory;
|
|
virDrvDomainSetMemoryFlags domainSetMemoryFlags;
|
|
virDrvDomainSetMemoryParameters domainSetMemoryParameters;
|
|
virDrvDomainGetMemoryParameters domainGetMemoryParameters;
|
|
virDrvDomainSetNumaParameters domainSetNumaParameters;
|
|
virDrvDomainGetNumaParameters domainGetNumaParameters;
|
|
virDrvDomainSetBlkioParameters domainSetBlkioParameters;
|
|
virDrvDomainGetBlkioParameters domainGetBlkioParameters;
|
|
virDrvDomainGetInfo domainGetInfo;
|
|
virDrvDomainGetState domainGetState;
|
|
virDrvDomainGetControlInfo domainGetControlInfo;
|
|
virDrvDomainSave domainSave;
|
|
virDrvDomainSaveFlags domainSaveFlags;
|
|
virDrvDomainRestore domainRestore;
|
|
virDrvDomainRestoreFlags domainRestoreFlags;
|
|
virDrvDomainSaveImageGetXMLDesc domainSaveImageGetXMLDesc;
|
|
virDrvDomainSaveImageDefineXML domainSaveImageDefineXML;
|
|
virDrvDomainCoreDump domainCoreDump;
|
|
virDrvDomainScreenshot domainScreenshot;
|
|
virDrvDomainSetVcpus domainSetVcpus;
|
|
virDrvDomainSetVcpusFlags domainSetVcpusFlags;
|
|
virDrvDomainGetVcpusFlags domainGetVcpusFlags;
|
|
virDrvDomainPinVcpu domainPinVcpu;
|
|
virDrvDomainPinVcpuFlags domainPinVcpuFlags;
|
|
virDrvDomainGetVcpuPinInfo domainGetVcpuPinInfo;
|
|
virDrvDomainPinEmulator domainPinEmulator;
|
|
virDrvDomainGetEmulatorPinInfo domainGetEmulatorPinInfo;
|
|
virDrvDomainGetVcpus domainGetVcpus;
|
|
virDrvDomainGetMaxVcpus domainGetMaxVcpus;
|
|
virDrvDomainGetSecurityLabel domainGetSecurityLabel;
|
|
virDrvDomainGetSecurityLabelList domainGetSecurityLabelList;
|
|
virDrvNodeGetSecurityModel nodeGetSecurityModel;
|
|
virDrvDomainGetXMLDesc domainGetXMLDesc;
|
|
virDrvConnectDomainXMLFromNative domainXMLFromNative;
|
|
virDrvConnectDomainXMLToNative domainXMLToNative;
|
|
virDrvListDefinedDomains listDefinedDomains;
|
|
virDrvNumOfDefinedDomains numOfDefinedDomains;
|
|
virDrvDomainCreate domainCreate;
|
|
virDrvDomainCreateWithFlags domainCreateWithFlags;
|
|
virDrvDomainDefineXML domainDefineXML;
|
|
virDrvDomainUndefine domainUndefine;
|
|
virDrvDomainUndefineFlags domainUndefineFlags;
|
|
virDrvDomainAttachDevice domainAttachDevice;
|
|
virDrvDomainAttachDeviceFlags domainAttachDeviceFlags;
|
|
virDrvDomainDetachDevice domainDetachDevice;
|
|
virDrvDomainDetachDeviceFlags domainDetachDeviceFlags;
|
|
virDrvDomainUpdateDeviceFlags domainUpdateDeviceFlags;
|
|
virDrvDomainGetAutostart domainGetAutostart;
|
|
virDrvDomainSetAutostart domainSetAutostart;
|
|
virDrvDomainGetSchedulerType domainGetSchedulerType;
|
|
virDrvDomainGetSchedulerParameters domainGetSchedulerParameters;
|
|
virDrvDomainGetSchedulerParametersFlags domainGetSchedulerParametersFlags;
|
|
virDrvDomainSetSchedulerParameters domainSetSchedulerParameters;
|
|
virDrvDomainSetSchedulerParametersFlags domainSetSchedulerParametersFlags;
|
|
virDrvDomainMigratePrepare domainMigratePrepare;
|
|
virDrvDomainMigratePerform domainMigratePerform;
|
|
virDrvDomainMigrateFinish domainMigrateFinish;
|
|
virDrvDomainBlockResize domainBlockResize;
|
|
virDrvDomainBlockStats domainBlockStats;
|
|
virDrvDomainBlockStatsFlags domainBlockStatsFlags;
|
|
virDrvDomainInterfaceStats domainInterfaceStats;
|
|
virDrvDomainSetInterfaceParameters domainSetInterfaceParameters;
|
|
virDrvDomainGetInterfaceParameters domainGetInterfaceParameters;
|
|
virDrvDomainMemoryStats domainMemoryStats;
|
|
virDrvDomainBlockPeek domainBlockPeek;
|
|
virDrvDomainMemoryPeek domainMemoryPeek;
|
|
virDrvDomainGetBlockInfo domainGetBlockInfo;
|
|
virDrvNodeGetCPUStats nodeGetCPUStats;
|
|
virDrvNodeGetMemoryStats nodeGetMemoryStats;
|
|
virDrvNodeGetCellsFreeMemory nodeGetCellsFreeMemory;
|
|
virDrvNodeGetFreeMemory nodeGetFreeMemory;
|
|
virDrvDomainEventRegister domainEventRegister;
|
|
virDrvDomainEventDeregister domainEventDeregister;
|
|
virDrvDomainMigratePrepare2 domainMigratePrepare2;
|
|
virDrvDomainMigrateFinish2 domainMigrateFinish2;
|
|
virDrvNodeDeviceDettach nodeDeviceDettach;
|
|
virDrvNodeDeviceReAttach nodeDeviceReAttach;
|
|
virDrvNodeDeviceReset nodeDeviceReset;
|
|
virDrvDomainMigratePrepareTunnel domainMigratePrepareTunnel;
|
|
virDrvConnectIsEncrypted isEncrypted;
|
|
virDrvConnectIsSecure isSecure;
|
|
virDrvDomainIsActive domainIsActive;
|
|
virDrvDomainIsPersistent domainIsPersistent;
|
|
virDrvDomainIsUpdated domainIsUpdated;
|
|
virDrvCompareCPU cpuCompare;
|
|
virDrvBaselineCPU cpuBaseline;
|
|
virDrvDomainGetJobInfo domainGetJobInfo;
|
|
virDrvDomainAbortJob domainAbortJob;
|
|
virDrvDomainMigrateSetMaxDowntime domainMigrateSetMaxDowntime;
|
|
virDrvDomainMigrateGetMaxSpeed domainMigrateGetMaxSpeed;
|
|
virDrvDomainMigrateSetMaxSpeed domainMigrateSetMaxSpeed;
|
|
virDrvDomainEventRegisterAny domainEventRegisterAny;
|
|
virDrvDomainEventDeregisterAny domainEventDeregisterAny;
|
|
virDrvDomainManagedSave domainManagedSave;
|
|
virDrvDomainHasManagedSaveImage domainHasManagedSaveImage;
|
|
virDrvDomainManagedSaveRemove domainManagedSaveRemove;
|
|
virDrvDomainSnapshotCreateXML domainSnapshotCreateXML;
|
|
virDrvDomainSnapshotGetXMLDesc domainSnapshotGetXMLDesc;
|
|
virDrvDomainSnapshotNum domainSnapshotNum;
|
|
virDrvDomainSnapshotListNames domainSnapshotListNames;
|
|
virDrvDomainListAllSnapshots domainListAllSnapshots;
|
|
virDrvDomainSnapshotNumChildren domainSnapshotNumChildren;
|
|
virDrvDomainSnapshotListChildrenNames domainSnapshotListChildrenNames;
|
|
virDrvDomainSnapshotListAllChildren domainSnapshotListAllChildren;
|
|
virDrvDomainSnapshotLookupByName domainSnapshotLookupByName;
|
|
virDrvDomainHasCurrentSnapshot domainHasCurrentSnapshot;
|
|
virDrvDomainSnapshotGetParent domainSnapshotGetParent;
|
|
virDrvDomainSnapshotCurrent domainSnapshotCurrent;
|
|
virDrvDomainSnapshotIsCurrent domainSnapshotIsCurrent;
|
|
virDrvDomainSnapshotHasMetadata domainSnapshotHasMetadata;
|
|
virDrvDomainRevertToSnapshot domainRevertToSnapshot;
|
|
virDrvDomainSnapshotDelete domainSnapshotDelete;
|
|
virDrvDomainQemuMonitorCommand qemuDomainMonitorCommand;
|
|
virDrvDomainQemuAttach qemuDomainAttach;
|
|
virDrvDomainQemuAgentCommand qemuDomainArbitraryAgentCommand;
|
|
virDrvDomainOpenConsole domainOpenConsole;
|
|
virDrvDomainOpenChannel domainOpenChannel;
|
|
virDrvDomainOpenGraphics domainOpenGraphics;
|
|
virDrvDomainInjectNMI domainInjectNMI;
|
|
virDrvDomainMigrateBegin3 domainMigrateBegin3;
|
|
virDrvDomainMigratePrepare3 domainMigratePrepare3;
|
|
virDrvDomainMigratePrepareTunnel3 domainMigratePrepareTunnel3;
|
|
virDrvDomainMigratePerform3 domainMigratePerform3;
|
|
virDrvDomainMigrateFinish3 domainMigrateFinish3;
|
|
virDrvDomainMigrateConfirm3 domainMigrateConfirm3;
|
|
virDrvDomainSendKey domainSendKey;
|
|
virDrvDomainBlockJobAbort domainBlockJobAbort;
|
|
virDrvDomainGetBlockJobInfo domainGetBlockJobInfo;
|
|
virDrvDomainBlockJobSetSpeed domainBlockJobSetSpeed;
|
|
virDrvDomainBlockPull domainBlockPull;
|
|
virDrvDomainBlockRebase domainBlockRebase;
|
|
virDrvDomainBlockCommit domainBlockCommit;
|
|
virDrvSetKeepAlive setKeepAlive;
|
|
virDrvConnectIsAlive isAlive;
|
|
virDrvNodeSuspendForDuration nodeSuspendForDuration;
|
|
virDrvDomainSetBlockIoTune domainSetBlockIoTune;
|
|
virDrvDomainGetBlockIoTune domainGetBlockIoTune;
|
|
virDrvDomainGetCPUStats domainGetCPUStats;
|
|
virDrvDomainGetDiskErrors domainGetDiskErrors;
|
|
virDrvDomainSetMetadata domainSetMetadata;
|
|
virDrvDomainGetMetadata domainGetMetadata;
|
|
virDrvNodeGetMemoryParameters nodeGetMemoryParameters;
|
|
virDrvNodeSetMemoryParameters nodeSetMemoryParameters;
|
|
virDrvNodeGetCPUMap nodeGetCPUMap;
|
|
virDrvDomainFSTrim domainFSTrim;
|
|
virDrvDomainSendProcessSignal domainSendProcessSignal;
|
|
virDrvDomainLxcOpenNamespace domainLxcOpenNamespace;
|
|
};
|
|
|
|
typedef int
|
|
(*virDrvNumOfNetworks) (virConnectPtr conn);
|
|
typedef int
|
|
(*virDrvListNetworks) (virConnectPtr conn,
|
|
char **const names,
|
|
int maxnames);
|
|
typedef int
|
|
(*virDrvNumOfDefinedNetworks) (virConnectPtr conn);
|
|
typedef int
|
|
(*virDrvListDefinedNetworks) (virConnectPtr conn,
|
|
char **const names,
|
|
int maxnames);
|
|
typedef int
|
|
(*virDrvListAllNetworks) (virConnectPtr conn,
|
|
virNetworkPtr **nets,
|
|
unsigned int flags);
|
|
typedef virNetworkPtr
|
|
(*virDrvNetworkLookupByUUID) (virConnectPtr conn,
|
|
const unsigned char *uuid);
|
|
typedef virNetworkPtr
|
|
(*virDrvNetworkLookupByName) (virConnectPtr conn,
|
|
const char *name);
|
|
typedef virNetworkPtr
|
|
(*virDrvNetworkCreateXML) (virConnectPtr conn,
|
|
const char *xmlDesc);
|
|
typedef virNetworkPtr
|
|
(*virDrvNetworkDefineXML) (virConnectPtr conn,
|
|
const char *xml);
|
|
typedef int
|
|
(*virDrvNetworkUndefine) (virNetworkPtr network);
|
|
typedef int
|
|
(*virDrvNetworkUpdate) (virNetworkPtr network,
|
|
unsigned int command, /* virNetworkUpdateCommand */
|
|
unsigned int section, /* virNetworkUpdateSection */
|
|
int parentIndex,
|
|
const char *xml,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvNetworkCreate) (virNetworkPtr network);
|
|
typedef int
|
|
(*virDrvNetworkDestroy) (virNetworkPtr network);
|
|
typedef char *
|
|
(*virDrvNetworkGetXMLDesc) (virNetworkPtr network,
|
|
unsigned int flags);
|
|
typedef char *
|
|
(*virDrvNetworkGetBridgeName) (virNetworkPtr network);
|
|
typedef int
|
|
(*virDrvNetworkGetAutostart) (virNetworkPtr network,
|
|
int *autostart);
|
|
typedef int
|
|
(*virDrvNetworkSetAutostart) (virNetworkPtr network,
|
|
int autostart);
|
|
|
|
typedef int
|
|
(*virDrvNetworkIsActive) (virNetworkPtr net);
|
|
typedef int
|
|
(*virDrvNetworkIsPersistent) (virNetworkPtr net);
|
|
|
|
|
|
|
|
typedef struct _virNetworkDriver virNetworkDriver;
|
|
typedef virNetworkDriver *virNetworkDriverPtr;
|
|
|
|
/**
|
|
* _virNetworkDriver:
|
|
*
|
|
* Structure associated to a network virtualization driver, defining the various
|
|
* entry points for it.
|
|
*
|
|
* All drivers must support the following fields/methods:
|
|
* - open
|
|
* - close
|
|
*/
|
|
struct _virNetworkDriver {
|
|
const char * name; /* the name of the driver */
|
|
virDrvOpen open;
|
|
virDrvClose close;
|
|
virDrvNumOfNetworks numOfNetworks;
|
|
virDrvListNetworks listNetworks;
|
|
virDrvNumOfDefinedNetworks numOfDefinedNetworks;
|
|
virDrvListDefinedNetworks listDefinedNetworks;
|
|
virDrvListAllNetworks listAllNetworks;
|
|
virDrvNetworkLookupByUUID networkLookupByUUID;
|
|
virDrvNetworkLookupByName networkLookupByName;
|
|
virDrvNetworkCreateXML networkCreateXML;
|
|
virDrvNetworkDefineXML networkDefineXML;
|
|
virDrvNetworkUndefine networkUndefine;
|
|
virDrvNetworkUpdate networkUpdate;
|
|
virDrvNetworkCreate networkCreate;
|
|
virDrvNetworkDestroy networkDestroy;
|
|
virDrvNetworkGetXMLDesc networkGetXMLDesc;
|
|
virDrvNetworkGetBridgeName networkGetBridgeName;
|
|
virDrvNetworkGetAutostart networkGetAutostart;
|
|
virDrvNetworkSetAutostart networkSetAutostart;
|
|
virDrvNetworkIsActive networkIsActive;
|
|
virDrvNetworkIsPersistent networkIsPersistent;
|
|
};
|
|
|
|
/*-------*/
|
|
typedef int
|
|
(*virDrvNumOfInterfaces) (virConnectPtr conn);
|
|
typedef int
|
|
(*virDrvListInterfaces) (virConnectPtr conn,
|
|
char **const names,
|
|
int maxnames);
|
|
typedef int
|
|
(*virDrvNumOfDefinedInterfaces) (virConnectPtr conn);
|
|
typedef int
|
|
(*virDrvListDefinedInterfaces) (virConnectPtr conn,
|
|
char **const names,
|
|
int maxnames);
|
|
typedef int
|
|
(*virDrvListAllInterfaces) (virConnectPtr conn,
|
|
virInterfacePtr **ifaces,
|
|
unsigned int flags);
|
|
typedef virInterfacePtr
|
|
(*virDrvInterfaceLookupByName) (virConnectPtr conn,
|
|
const char *name);
|
|
typedef virInterfacePtr
|
|
(*virDrvInterfaceLookupByMACString) (virConnectPtr conn,
|
|
const char *mac);
|
|
|
|
typedef char *
|
|
(*virDrvInterfaceGetXMLDesc) (virInterfacePtr iface,
|
|
unsigned int flags);
|
|
|
|
typedef virInterfacePtr
|
|
(*virDrvInterfaceDefineXML) (virConnectPtr conn,
|
|
const char *xmlDesc,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvInterfaceUndefine) (virInterfacePtr iface);
|
|
typedef int
|
|
(*virDrvInterfaceCreate) (virInterfacePtr iface,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvInterfaceDestroy) (virInterfacePtr iface,
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvInterfaceIsActive) (virInterfacePtr iface);
|
|
|
|
typedef int
|
|
(*virDrvInterfaceChangeBegin) (virConnectPtr conn,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvInterfaceChangeCommit) (virConnectPtr conn,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvInterfaceChangeRollback)(virConnectPtr conn,
|
|
unsigned int flags);
|
|
|
|
typedef struct _virInterfaceDriver virInterfaceDriver;
|
|
typedef virInterfaceDriver *virInterfaceDriverPtr;
|
|
|
|
/**
|
|
* _virInterfaceDriver:
|
|
*
|
|
* Structure associated to a network interface driver, defining the various
|
|
* entry points for it.
|
|
*
|
|
* All drivers must support the following fields/methods:
|
|
* - open
|
|
* - close
|
|
*/
|
|
struct _virInterfaceDriver {
|
|
const char *name; /* the name of the driver */
|
|
virDrvOpen open;
|
|
virDrvClose close;
|
|
virDrvNumOfInterfaces numOfInterfaces;
|
|
virDrvListInterfaces listInterfaces;
|
|
virDrvNumOfDefinedInterfaces numOfDefinedInterfaces;
|
|
virDrvListDefinedInterfaces listDefinedInterfaces;
|
|
virDrvListAllInterfaces listAllInterfaces;
|
|
virDrvInterfaceLookupByName interfaceLookupByName;
|
|
virDrvInterfaceLookupByMACString interfaceLookupByMACString;
|
|
virDrvInterfaceGetXMLDesc interfaceGetXMLDesc;
|
|
virDrvInterfaceDefineXML interfaceDefineXML;
|
|
virDrvInterfaceUndefine interfaceUndefine;
|
|
virDrvInterfaceCreate interfaceCreate;
|
|
virDrvInterfaceDestroy interfaceDestroy;
|
|
virDrvInterfaceIsActive interfaceIsActive;
|
|
virDrvInterfaceChangeBegin interfaceChangeBegin;
|
|
virDrvInterfaceChangeCommit interfaceChangeCommit;
|
|
virDrvInterfaceChangeRollback interfaceChangeRollback;
|
|
};
|
|
|
|
|
|
typedef int
|
|
(*virDrvConnectNumOfStoragePools) (virConnectPtr conn);
|
|
typedef int
|
|
(*virDrvConnectListStoragePools) (virConnectPtr conn,
|
|
char **const names,
|
|
int maxnames);
|
|
typedef int
|
|
(*virDrvConnectNumOfDefinedStoragePools) (virConnectPtr conn);
|
|
typedef int
|
|
(*virDrvConnectListDefinedStoragePools) (virConnectPtr conn,
|
|
char **const names,
|
|
int maxnames);
|
|
typedef int
|
|
(*virDrvConnectListAllStoragePools) (virConnectPtr conn,
|
|
virStoragePoolPtr **pools,
|
|
unsigned int flags);
|
|
typedef char *
|
|
(*virDrvConnectFindStoragePoolSources) (virConnectPtr conn,
|
|
const char *type,
|
|
const char *srcSpec,
|
|
unsigned int flags);
|
|
typedef virStoragePoolPtr
|
|
(*virDrvStoragePoolLookupByName) (virConnectPtr conn,
|
|
const char *name);
|
|
typedef virStoragePoolPtr
|
|
(*virDrvStoragePoolLookupByUUID) (virConnectPtr conn,
|
|
const unsigned char *uuid);
|
|
typedef virStoragePoolPtr
|
|
(*virDrvStoragePoolLookupByVolume) (virStorageVolPtr vol);
|
|
typedef virStoragePoolPtr
|
|
(*virDrvStoragePoolCreateXML) (virConnectPtr conn,
|
|
const char *xmlDesc,
|
|
unsigned int flags);
|
|
typedef virStoragePoolPtr
|
|
(*virDrvStoragePoolDefineXML) (virConnectPtr conn,
|
|
const char *xmlDesc,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvStoragePoolUndefine) (virStoragePoolPtr pool);
|
|
typedef int
|
|
(*virDrvStoragePoolBuild) (virStoragePoolPtr pool,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvStoragePoolCreate) (virStoragePoolPtr pool,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvStoragePoolDestroy) (virStoragePoolPtr pool);
|
|
typedef int
|
|
(*virDrvStoragePoolDelete) (virStoragePoolPtr pool,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvStoragePoolRefresh) (virStoragePoolPtr pool,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvStoragePoolGetInfo) (virStoragePoolPtr vol,
|
|
virStoragePoolInfoPtr info);
|
|
typedef char *
|
|
(*virDrvStoragePoolGetXMLDesc) (virStoragePoolPtr pool,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvStoragePoolGetAutostart) (virStoragePoolPtr pool,
|
|
int *autostart);
|
|
typedef int
|
|
(*virDrvStoragePoolSetAutostart) (virStoragePoolPtr pool,
|
|
int autostart);
|
|
typedef int
|
|
(*virDrvStoragePoolNumOfVolumes) (virStoragePoolPtr pool);
|
|
typedef int
|
|
(*virDrvStoragePoolListVolumes) (virStoragePoolPtr pool,
|
|
char **const names,
|
|
int maxnames);
|
|
typedef int
|
|
(*virDrvStoragePoolListAllVolumes) (virStoragePoolPtr pool,
|
|
virStorageVolPtr **vols,
|
|
unsigned int flags);
|
|
|
|
typedef virStorageVolPtr
|
|
(*virDrvStorageVolLookupByName) (virStoragePoolPtr pool,
|
|
const char *name);
|
|
typedef virStorageVolPtr
|
|
(*virDrvStorageVolLookupByKey) (virConnectPtr pool,
|
|
const char *key);
|
|
typedef virStorageVolPtr
|
|
(*virDrvStorageVolLookupByPath) (virConnectPtr pool,
|
|
const char *path);
|
|
|
|
|
|
typedef virStorageVolPtr
|
|
(*virDrvStorageVolCreateXML) (virStoragePoolPtr pool,
|
|
const char *xmldesc,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvStorageVolDelete) (virStorageVolPtr vol,
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvStorageVolWipe) (virStorageVolPtr vol,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvStorageVolWipePattern) (virStorageVolPtr vol,
|
|
unsigned int algorithm,
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvStorageVolGetInfo) (virStorageVolPtr vol,
|
|
virStorageVolInfoPtr info);
|
|
typedef char *
|
|
(*virDrvStorageVolGetXMLDesc) (virStorageVolPtr pool,
|
|
unsigned int flags);
|
|
typedef char *
|
|
(*virDrvStorageVolGetPath) (virStorageVolPtr vol);
|
|
|
|
typedef virStorageVolPtr
|
|
(*virDrvStorageVolCreateXMLFrom) (virStoragePoolPtr pool,
|
|
const char *xmldesc,
|
|
virStorageVolPtr clone,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvStorageVolDownload) (virStorageVolPtr vol,
|
|
virStreamPtr stream,
|
|
unsigned long long offset,
|
|
unsigned long long length,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvStorageVolUpload) (virStorageVolPtr vol,
|
|
virStreamPtr stream,
|
|
unsigned long long offset,
|
|
unsigned long long length,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvStorageVolResize) (virStorageVolPtr vol,
|
|
unsigned long long capacity,
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
(*virDrvStoragePoolIsActive)(virStoragePoolPtr pool);
|
|
typedef int
|
|
(*virDrvStoragePoolIsPersistent)(virStoragePoolPtr pool);
|
|
|
|
|
|
|
|
typedef struct _virStorageDriver virStorageDriver;
|
|
typedef virStorageDriver *virStorageDriverPtr;
|
|
|
|
/**
|
|
* _virStorageDriver:
|
|
*
|
|
* Structure associated to a storage driver, defining the various
|
|
* entry points for it.
|
|
*
|
|
* All drivers must support the following fields/methods:
|
|
* - open
|
|
* - close
|
|
*/
|
|
struct _virStorageDriver {
|
|
const char * name; /* the name of the driver */
|
|
virDrvOpen open;
|
|
virDrvClose close;
|
|
|
|
virDrvConnectNumOfStoragePools numOfPools;
|
|
virDrvConnectListStoragePools listPools;
|
|
virDrvConnectNumOfDefinedStoragePools numOfDefinedPools;
|
|
virDrvConnectListDefinedStoragePools listDefinedPools;
|
|
virDrvConnectListAllStoragePools listAllPools;
|
|
virDrvConnectFindStoragePoolSources findPoolSources;
|
|
virDrvStoragePoolLookupByName poolLookupByName;
|
|
virDrvStoragePoolLookupByUUID poolLookupByUUID;
|
|
virDrvStoragePoolLookupByVolume poolLookupByVolume;
|
|
virDrvStoragePoolCreateXML poolCreateXML;
|
|
virDrvStoragePoolDefineXML poolDefineXML;
|
|
virDrvStoragePoolBuild poolBuild;
|
|
virDrvStoragePoolUndefine poolUndefine;
|
|
virDrvStoragePoolCreate poolCreate;
|
|
virDrvStoragePoolDestroy poolDestroy;
|
|
virDrvStoragePoolDelete poolDelete;
|
|
virDrvStoragePoolRefresh poolRefresh;
|
|
virDrvStoragePoolGetInfo poolGetInfo;
|
|
virDrvStoragePoolGetXMLDesc poolGetXMLDesc;
|
|
virDrvStoragePoolGetAutostart poolGetAutostart;
|
|
virDrvStoragePoolSetAutostart poolSetAutostart;
|
|
virDrvStoragePoolNumOfVolumes poolNumOfVolumes;
|
|
virDrvStoragePoolListVolumes poolListVolumes;
|
|
virDrvStoragePoolListAllVolumes poolListAllVolumes;
|
|
|
|
virDrvStorageVolLookupByName volLookupByName;
|
|
virDrvStorageVolLookupByKey volLookupByKey;
|
|
virDrvStorageVolLookupByPath volLookupByPath;
|
|
virDrvStorageVolCreateXML volCreateXML;
|
|
virDrvStorageVolCreateXMLFrom volCreateXMLFrom;
|
|
virDrvStorageVolDownload volDownload;
|
|
virDrvStorageVolUpload volUpload;
|
|
virDrvStorageVolDelete volDelete;
|
|
virDrvStorageVolWipe volWipe;
|
|
virDrvStorageVolWipePattern volWipePattern;
|
|
virDrvStorageVolGetInfo volGetInfo;
|
|
virDrvStorageVolGetXMLDesc volGetXMLDesc;
|
|
virDrvStorageVolGetPath volGetPath;
|
|
virDrvStorageVolResize volResize;
|
|
virDrvStoragePoolIsActive poolIsActive;
|
|
virDrvStoragePoolIsPersistent poolIsPersistent;
|
|
};
|
|
|
|
# ifdef WITH_LIBVIRTD
|
|
|
|
typedef int (*virDrvStateInitialize) (bool privileged,
|
|
virStateInhibitCallback callback,
|
|
void *opaque);
|
|
typedef int (*virDrvStateCleanup) (void);
|
|
typedef int (*virDrvStateReload) (void);
|
|
typedef int (*virDrvStateStop) (void);
|
|
|
|
typedef struct _virStateDriver virStateDriver;
|
|
typedef virStateDriver *virStateDriverPtr;
|
|
|
|
struct _virStateDriver {
|
|
const char *name;
|
|
virDrvStateInitialize initialize;
|
|
virDrvStateCleanup cleanup;
|
|
virDrvStateReload reload;
|
|
virDrvStateStop stop;
|
|
};
|
|
# endif
|
|
|
|
|
|
typedef struct _virDeviceMonitor virDeviceMonitor;
|
|
typedef virDeviceMonitor *virDeviceMonitorPtr;
|
|
|
|
typedef int (*virDevMonNumOfDevices)(virConnectPtr conn,
|
|
const char *cap,
|
|
unsigned int flags);
|
|
|
|
typedef int (*virDevMonListDevices)(virConnectPtr conn,
|
|
const char *cap,
|
|
char **const names,
|
|
int maxnames,
|
|
unsigned int flags);
|
|
typedef int (*virDevMonListAllNodeDevices)(virConnectPtr conn,
|
|
virNodeDevicePtr **devices,
|
|
unsigned int flags);
|
|
|
|
typedef virNodeDevicePtr (*virDevMonDeviceLookupByName)(virConnectPtr conn,
|
|
const char *name);
|
|
|
|
typedef virNodeDevicePtr (*virDevMonDeviceLookupSCSIHostByWWN)(virConnectPtr conn,
|
|
const char *wwnn,
|
|
const char *wwpn,
|
|
unsigned int flags);
|
|
|
|
typedef char * (*virDevMonDeviceGetXMLDesc)(virNodeDevicePtr dev,
|
|
unsigned int flags);
|
|
|
|
typedef char * (*virDevMonDeviceGetParent)(virNodeDevicePtr dev);
|
|
|
|
typedef int (*virDevMonDeviceNumOfCaps)(virNodeDevicePtr dev);
|
|
|
|
typedef int (*virDevMonDeviceListCaps)(virNodeDevicePtr dev,
|
|
char **const names,
|
|
int maxnames);
|
|
|
|
typedef virNodeDevicePtr (*virDrvNodeDeviceCreateXML)(virConnectPtr conn,
|
|
const char *xmlDesc,
|
|
unsigned int flags);
|
|
typedef int (*virDrvNodeDeviceDestroy)(virNodeDevicePtr dev);
|
|
|
|
/**
|
|
* _virDeviceMonitor:
|
|
*
|
|
* Structure associated with monitoring the devices
|
|
* on a virtualized node.
|
|
*
|
|
*/
|
|
struct _virDeviceMonitor {
|
|
const char * name; /* the name of the driver */
|
|
virDrvOpen open;
|
|
virDrvClose close;
|
|
virDevMonNumOfDevices numOfDevices;
|
|
virDevMonListDevices listDevices;
|
|
virDevMonListAllNodeDevices listAllNodeDevices;
|
|
virDevMonDeviceLookupByName deviceLookupByName;
|
|
virDevMonDeviceLookupSCSIHostByWWN deviceLookupSCSIHostByWWN;
|
|
virDevMonDeviceGetXMLDesc deviceGetXMLDesc;
|
|
virDevMonDeviceGetParent deviceGetParent;
|
|
virDevMonDeviceNumOfCaps deviceNumOfCaps;
|
|
virDevMonDeviceListCaps deviceListCaps;
|
|
virDrvNodeDeviceCreateXML deviceCreateXML;
|
|
virDrvNodeDeviceDestroy deviceDestroy;
|
|
};
|
|
|
|
enum {
|
|
/* This getValue call is inside libvirt, override the "private" flag.
|
|
This flag cannot be set by outside callers. */
|
|
VIR_SECRET_GET_VALUE_INTERNAL_CALL = 1 << 0,
|
|
};
|
|
|
|
typedef virSecretPtr
|
|
(*virDrvSecretLookupByUUID) (virConnectPtr conn,
|
|
const unsigned char *uuid);
|
|
typedef virSecretPtr
|
|
(*virDrvSecretLookupByUsage) (virConnectPtr conn,
|
|
int usageType,
|
|
const char *usageID);
|
|
typedef virSecretPtr
|
|
(*virDrvSecretDefineXML) (virConnectPtr conn,
|
|
const char *xml,
|
|
unsigned int flags);
|
|
typedef char *
|
|
(*virDrvSecretGetXMLDesc) (virSecretPtr secret,
|
|
unsigned int flags);
|
|
typedef int
|
|
(*virDrvSecretSetValue) (virSecretPtr secret,
|
|
const unsigned char *value,
|
|
size_t value_size,
|
|
unsigned int flags);
|
|
typedef unsigned char *
|
|
(*virDrvSecretGetValue) (virSecretPtr secret,
|
|
size_t *value_size,
|
|
unsigned int flags,
|
|
unsigned int internalFlags);
|
|
typedef int
|
|
(*virDrvSecretUndefine) (virSecretPtr secret);
|
|
typedef int
|
|
(*virDrvNumOfSecrets) (virConnectPtr conn);
|
|
typedef int
|
|
(*virDrvListSecrets) (virConnectPtr conn,
|
|
char **uuids,
|
|
int maxuuids);
|
|
typedef int
|
|
(*virDrvListAllSecrets) (virConnectPtr conn,
|
|
virSecretPtr **secrets,
|
|
unsigned int flags);
|
|
|
|
typedef struct _virSecretDriver virSecretDriver;
|
|
typedef virSecretDriver *virSecretDriverPtr;
|
|
|
|
/**
|
|
* _virSecretDriver:
|
|
*
|
|
* Structure associated to a driver for storing secrets, defining the various
|
|
* entry points for it.
|
|
*
|
|
* All drivers must support the following fields/methods:
|
|
* - open
|
|
* - close
|
|
*/
|
|
struct _virSecretDriver {
|
|
const char *name;
|
|
virDrvOpen open;
|
|
virDrvClose close;
|
|
|
|
virDrvNumOfSecrets numOfSecrets;
|
|
virDrvListSecrets listSecrets;
|
|
virDrvListAllSecrets listAllSecrets;
|
|
virDrvSecretLookupByUUID lookupByUUID;
|
|
virDrvSecretLookupByUsage lookupByUsage;
|
|
virDrvSecretDefineXML defineXML;
|
|
virDrvSecretGetXMLDesc getXMLDesc;
|
|
virDrvSecretSetValue setValue;
|
|
virDrvSecretGetValue getValue;
|
|
virDrvSecretUndefine undefine;
|
|
};
|
|
|
|
|
|
typedef struct _virStreamDriver virStreamDriver;
|
|
typedef virStreamDriver *virStreamDriverPtr;
|
|
|
|
typedef int (*virDrvStreamSend)(virStreamPtr st,
|
|
const char *data,
|
|
size_t nbytes);
|
|
typedef int (*virDrvStreamRecv)(virStreamPtr st,
|
|
char *data,
|
|
size_t nbytes);
|
|
|
|
typedef int (*virDrvStreamEventAddCallback)(virStreamPtr stream,
|
|
int events,
|
|
virStreamEventCallback cb,
|
|
void *opaque,
|
|
virFreeCallback ff);
|
|
|
|
typedef int (*virDrvStreamEventUpdateCallback)(virStreamPtr stream,
|
|
int events);
|
|
typedef int (*virDrvStreamEventRemoveCallback)(virStreamPtr stream);
|
|
typedef int (*virDrvStreamFinish)(virStreamPtr st);
|
|
typedef int (*virDrvStreamAbort)(virStreamPtr st);
|
|
|
|
|
|
struct _virStreamDriver {
|
|
virDrvStreamSend streamSend;
|
|
virDrvStreamRecv streamRecv;
|
|
virDrvStreamEventAddCallback streamAddCallback;
|
|
virDrvStreamEventUpdateCallback streamUpdateCallback;
|
|
virDrvStreamEventRemoveCallback streamRemoveCallback;
|
|
virDrvStreamFinish streamFinish;
|
|
virDrvStreamAbort streamAbort;
|
|
};
|
|
|
|
|
|
typedef int
|
|
(*virDrvConnectNumOfNWFilters) (virConnectPtr conn);
|
|
typedef int
|
|
(*virDrvConnectListNWFilters) (virConnectPtr conn,
|
|
char **const names,
|
|
int maxnames);
|
|
typedef int
|
|
(*virDrvConnectListAllNWFilters) (virConnectPtr conn,
|
|
virNWFilterPtr **filters,
|
|
unsigned int flags);
|
|
typedef virNWFilterPtr
|
|
(*virDrvNWFilterLookupByName) (virConnectPtr conn,
|
|
const char *name);
|
|
typedef virNWFilterPtr
|
|
(*virDrvNWFilterLookupByUUID) (virConnectPtr conn,
|
|
const unsigned char *uuid);
|
|
typedef virNWFilterPtr
|
|
(*virDrvNWFilterDefineXML) (virConnectPtr conn,
|
|
const char *xmlDesc);
|
|
typedef int
|
|
(*virDrvNWFilterUndefine) (virNWFilterPtr nwfilter);
|
|
|
|
typedef char *
|
|
(*virDrvNWFilterGetXMLDesc) (virNWFilterPtr nwfilter,
|
|
unsigned int flags);
|
|
|
|
|
|
typedef struct _virNWFilterDriver virNWFilterDriver;
|
|
typedef virNWFilterDriver *virNWFilterDriverPtr;
|
|
|
|
/**
|
|
* _virNWFilterDriver:
|
|
*
|
|
* Structure associated to a network filter driver, defining the various
|
|
* entry points for it.
|
|
*
|
|
* All drivers must support the following fields/methods:
|
|
* - open
|
|
* - close
|
|
*/
|
|
struct _virNWFilterDriver {
|
|
const char * name; /* the name of the driver */
|
|
virDrvOpen open;
|
|
virDrvClose close;
|
|
|
|
virDrvConnectNumOfNWFilters numOfNWFilters;
|
|
virDrvConnectListNWFilters listNWFilters;
|
|
virDrvConnectListAllNWFilters listAllNWFilters;
|
|
virDrvNWFilterLookupByName nwfilterLookupByName;
|
|
virDrvNWFilterLookupByUUID nwfilterLookupByUUID;
|
|
virDrvNWFilterDefineXML defineXML;
|
|
virDrvNWFilterUndefine undefine;
|
|
virDrvNWFilterGetXMLDesc getXMLDesc;
|
|
};
|
|
|
|
|
|
/*
|
|
* Registration
|
|
* TODO: also need ways to (des)activate a given driver
|
|
* lookup based on the URI given in a virConnectOpen(ReadOnly)
|
|
*/
|
|
int virRegisterDriver(virDriverPtr);
|
|
int virRegisterNetworkDriver(virNetworkDriverPtr);
|
|
int virRegisterInterfaceDriver(virInterfaceDriverPtr);
|
|
int virRegisterStorageDriver(virStorageDriverPtr);
|
|
int virRegisterDeviceMonitor(virDeviceMonitorPtr);
|
|
int virRegisterSecretDriver(virSecretDriverPtr);
|
|
int virRegisterNWFilterDriver(virNWFilterDriverPtr);
|
|
# ifdef WITH_LIBVIRTD
|
|
int virRegisterStateDriver(virStateDriverPtr);
|
|
# endif
|
|
void virDriverModuleInitialize(const char *defmoddir);
|
|
void *virDriverLoadModule(const char *name);
|
|
|
|
#endif /* __VIR_DRIVER_H__ */
|