libvirt/src/driver.h

1662 lines
67 KiB
C
Raw Normal View History

/*
* 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,
2008-11-19 16:58:23 +00:00
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,
2011-07-13 14:47:01 +00:00
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
2008-11-17 11:03:25 +00:00
(*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);
xml: use long long internally, to centralize overflow checks On 64-bit platforms, unsigned long and unsigned long long are identical, so we don't have to worry about overflow checks. On 32-bit platforms, anywhere we narrow unsigned long long back to unsigned long, we have to worry about overflow; it's easier to do this in one place by having most of the code use the same or wider types, and only doing the narrowing at the last minute. Therefore, the memory set commands remain unsigned long, and the memory get command now centralizes the overflow check into libvirt.c, so that drivers don't have to repeat the work. This also fixes a bug where xen returned the wrong value on failure (most APIs return -1 on failure, but getMaxMemory must return 0 on failure). * src/driver.h (virDrvDomainGetMaxMemory): Use long long. * src/libvirt.c (virDomainGetMaxMemory): Raise overflow. * src/test/test_driver.c (testGetMaxMemory): Fix driver. * src/rpc/gendispatch.pl (name_to_ProcName): Likewise. * src/xen/xen_hypervisor.c (xenHypervisorGetMaxMemory): Likewise. * src/xen/xen_driver.c (xenUnifiedDomainGetMaxMemory): Likewise. * src/xen/xend_internal.c (xenDaemonDomainGetMaxMemory): Likewise. * src/xen/xend_internal.h (xenDaemonDomainGetMaxMemory): Likewise. * src/xen/xm_internal.c (xenXMDomainGetMaxMemory): Likewise. * src/xen/xm_internal.h (xenXMDomainGetMaxMemory): Likewise. * src/xen/xs_internal.c (xenStoreDomainGetMaxMemory): Likewise. * src/xen/xs_internal.h (xenStoreDomainGetMaxMemory): Likewise. * src/xenapi/xenapi_driver.c (xenapiDomainGetMaxMemory): Likewise. * src/esx/esx_driver.c (esxDomainGetMaxMemory): Likewise. * src/libxl/libxl_driver.c (libxlDomainGetMaxMemory): Likewise. * src/qemu/qemu_driver.c (qemudDomainGetMaxMemory): Likewise. * src/lxc/lxc_driver.c (lxcDomainGetMaxMemory): Likewise. * src/uml/uml_driver.c (umlDomainGetMaxMemory): Likewise.
2012-03-03 00:47:16 +00:00
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,
drivers: prefer unsigned int for flags Now that the public APIs always use unsigned flags, the internal driver callbacks might as well do likewise. * src/driver.h (vrDrvOpen, virDrvDomainCoreDump) (virDrvDomainGetXMLDesc, virDrvNetworkGetXMLDesc) (virDrvNWFilterGetXMLDesc): Update type. * src/remote/remote_protocol.x (remote_open_args) (remote_domain_core_dump_args, remote_domain_get_xml_desc_args) (remote_network_get_xml_desc_args) (remote_nwfilter_get_xml_desc_args): Likewise. * src/test/test_driver.c: Update clients. * src/remote/remote_driver.c: Likewise. * src/xen/xen_hypervisor.c: Likewise. * src/xen/xen_hypervisor.h: Likewise. * src/xen/xen_driver.c: Likewise. * src/xen/xend_internal.c: Likewise. * src/xen/xend_internal.h: Likewise. * src/xen/xm_internal.c: Likewise. * src/xen/xm_internal.h: Likewise. * src/xen/xs_internal.c: Likewise. * src/xen/xs_internal.h: Likewise. * src/xen/xen_inotify.c: Likewise. * src/xen/xen_inotify.h: Likewise. * src/phyp/phyp_driver.c: Likewise. * src/openvz/openvz_driver.c: Likewise. * src/vmware/vmware_driver.c: Likewise. * src/vbox/vbox_driver.c: Likewise. * src/vbox/vbox_tmpl.c: Likewise. * src/xenapi/xenapi_driver.c: Likewise. * src/esx/esx_driver.c: Likewise. * src/esx/esx_interface_driver.c: Likewise. * src/esx/esx_network_driver.c: Likewise. * src/esx/esx_storage_driver.c: Likewise. * src/esx/esx_device_monitor.c: Likewise. * src/esx/esx_secret_driver.c: Likewise. * src/esx/esx_nwfilter_driver.c: Likewise. * src/interface/netcf_driver.c: Likewise. * src/nwfilter/nwfilter_driver.c: Likewise. * src/libxl/libxl_driver.c: Likewise. * src/qemu/qemu_driver.c: Likewise. * src/lxc/lxc_driver.c: Likewise. * src/uml/uml_driver.c: Likewise. * src/network/bridge_driver.c: Likewise. * src/secret/secret_driver.c: Likewise. * src/storage/storage_driver.c: Likewise. * src/node_device/node_device_hal.c: Likewise. * src/node_device/node_device_udev.c: Likewise. * src/remote_protocol-structs: Likewise.
2011-07-06 20:40:19 +00:00
unsigned int flags);
typedef char *
(*virDrvDomainScreenshot) (virDomainPtr domain,
virStreamPtr stream,
unsigned int screen,
unsigned int flags);
typedef char *
(*virDrvDomainGetXMLDesc) (virDomainPtr dom,
unsigned int flags);
2009-05-21 13:46:35 +00:00
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);
lib: Add public api to enable atomic listing of guest This patch adds a new public api that lists domains. The new approach is different from those used before. There are key points to this: 1) The list is acquired atomically and contains both active and inactive domains (guests). This eliminates the need to call two different list APIs, where the state might change in between the calls. 2) The returned list consists of virDomainPtrs instead of names or ID's that have to be converted to virDomainPtrs anyways using separate calls for each one of them. This is more convenient and saves hypervisor calls. 3) The returned list is auto-allocated. This saves a lot of hassle for the users. 4) Built in support for filtering. The API call supports various filtering flags that modify the output list according to user needs. Available filter groups: Domain status: VIR_CONNECT_LIST_DOMAINS_ACTIVE, VIR_CONNECT_LIST_DOMAINS_INACTIVE Domain persistence: VIR_CONNECT_LIST_DOMAINS_PERSISTENT, VIR_CONNECT_LIST_DOMAINS_TRANSIENT Domain state: VIR_CONNECT_LIST_DOMAINS_RUNNING, VIR_CONNECT_LIST_DOMAINS_PAUSED, VIR_CONNECT_LIST_DOMAINS_SHUTOFF, VIR_CONNECT_LIST_DOMAINS_OTHER Existence of managed save image: VIR_CONNECT_LIST_DOMAINS_MANAGEDSAVE, VIR_CONNECT_LIST_DOMAINS_NO_MANAGEDSAVE Auto-start option: VIR_CONNECT_LIST_DOMAINS_AUTOSTART, VIR_CONNECT_LIST_DOMAINS_NO_AUTOSTART Existence of snapshot: VIR_CONNECT_LIST_DOMAINS_HAS_SNAPSHOT, VIR_CONNECT_LIST_DOMAINS_NO_SNAPSHOT 5) The python binding returns a list of domain objects that is very neat to work with. The only problem with this approach is no support from code generators so both RPC code and python bindings had to be written manually. *include/libvirt/libvirt.h.in: - add API prototype - clean up whitespace mistakes nearby *python/generator.py: - inhibit generation of the bindings for the new api *src/driver.h: - add driver prototype - clean up some whitespace mistakes nearby *src/libvirt.c: - add public implementation *src/libvirt_public.syms: - export the new symbol
2012-05-18 15:22:02 +00:00
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
(*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
(*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,
libvirt: do not mix internal flags into public API There were two API in driver.c that were silently masking flags bits prior to calling out to the drivers, and several others that were explicitly masking flags bits. This is not forward-compatible - if we ever have that many flags in the future, then talking to an old server that masks out the flags would be indistinguishable from talking to a new server that can honor the flag. In general, libvirt.c should forward _all_ flags on to drivers, and only the drivers should reject unknown flags. In the case of virDrvSecretGetValue, the solution is to separate the internal driver callback function to have two parameters instead of one, with only one parameter affected by the public API. In the case of virDomainGetXMLDesc, it turns out that no one was ever mixing VIR_DOMAIN_XML_INTERNAL_STATUS with the dumpxml path in the first place; that internal flag was only used in saving and restoring state files, which happened to be in functions internal to a single file, so there is no mixing of the internal flag with a public flags argument. Additionally, virDomainMemoryStats passed a flags argument over RPC, but not to the driver. * src/driver.h (VIR_DOMAIN_XML_FLAGS_MASK) (VIR_SECRET_GET_VALUE_FLAGS_MASK): Delete. (virDrvSecretGetValue): Separate out internal flags. (virDrvDomainMemoryStats): Provide missing flags argument. * src/driver.c (verify): Drop unused check. * src/conf/domain_conf.h (virDomainObjParseFile): Delete declaration. (virDomainXMLInternalFlags): Move... * src/conf/domain_conf.c: ...here. Delete redundant include. (virDomainObjParseFile): Make static. * src/libvirt.c (virDomainGetXMLDesc, virSecretGetValue): Update clients. (virDomainMemoryPeek, virInterfaceGetXMLDesc) (virDomainMemoryStats, virDomainBlockPeek, virNetworkGetXMLDesc) (virStoragePoolGetXMLDesc, virStorageVolGetXMLDesc) (virNodeNumOfDevices, virNodeListDevices, virNWFilterGetXMLDesc): Don't mask unknown flags. * src/interface/netcf_driver.c (interfaceGetXMLDesc): Reject unknown flags. * src/secret/secret_driver.c (secretGetValue): Update clients. * src/remote/remote_driver.c (remoteSecretGetValue) (remoteDomainMemoryStats): Likewise. * src/qemu/qemu_process.c (qemuProcessGetVolumeQcowPassphrase): Likewise. * src/qemu/qemu_driver.c (qemudDomainMemoryStats): Likewise. * daemon/remote.c (remoteDispatchDomainMemoryStats): Likewise.
2011-07-13 21:31:56 +00:00
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)
Introduce yet another migration version in API. Migration just seems to go from bad to worse. We already had to introduce a second migration protocol when adding the QEMU driver, since the one from Xen was insufficiently flexible to cope with passing the data the QEMU driver required. It turns out that this protocol still has some flaws that we need to address. The current sequence is * Src: DumpXML - Generate XML to pass to dst * Dst: Prepare - Get ready to accept incoming VM - Generate optional cookie to pass to src * Src: Perform - Start migration and wait for send completion - Kill off VM if successful, resume if failed * Dst: Finish - Wait for recv completion and check status - Kill off VM if unsuccessful The problems with this are: - Since the first step is a generic 'DumpXML' call, we can't add in other migration specific data. eg, we can't include any VM lease data from lock manager plugins - Since the first step is a generic 'DumpXML' call, we can't emit any 'migration begin' event on the source, or have any hook that runs right at the start of the process - Since there is no final step on the source, if the Finish method fails to receive all migration data & has to kill the VM, then there's no way to resume the original VM on the source This patch attempts to introduce a version 3 that uses the improved 5 step sequence * Src: Begin - Generate XML to pass to dst - Generate optional cookie to pass to dst * Dst: Prepare - Get ready to accept incoming VM - Generate optional cookie to pass to src * Src: Perform - Start migration and wait for send completion - Generate optional cookie to pass to dst * Dst: Finish - Wait for recv completion and check status - Kill off VM if failed, resume if success - Generate optional cookie to pass to src * Src: Confirm - Kill off VM if success, resume if failed The API is designed to allow both input and output cookies in all methods where applicable. This lets us pass around arbitrary extra driver specific data between src & dst during migration. Combined with the extra 'Begin' method this lets us pass lease information from source to dst at the start of migration Moving the killing of the source VM out of Perform and into Confirm, means we can now recover if the dst host can't successfully Finish receiving migration data.
2010-11-02 12:43:44 +00:00
(virConnectPtr dconn,
virStreamPtr st,
unsigned long flags,
const char *dname,
unsigned long resource,
const char *dom_xml);
New APIs for checking some object properties Introduce a number of new APIs to expose some boolean properties of objects, which cannot otherwise reliably determined, nor are aspects of the XML configuration. * virDomainIsActive: Checking virDomainGetID is not reliable since it is not possible to distinguish between error condition and inactive domain for ID of -1. * virDomainIsPersistent: Check whether a persistent config exists for the domain * virNetworkIsActive: Check whether the network is active * virNetworkIsPersistent: Check whether a persistent config exists for the network * virStoragePoolIsActive: Check whether the storage pool is active * virStoragePoolIsPersistent: Check whether a persistent config exists for the storage pool * virInterfaceIsActive: Check whether the host interface is active * virConnectIsSecure: whether the communication channel to the hypervisor is secure * virConnectIsEncrypted: whether any network based commnunication channels are encrypted NB, a channel can be secure, even if not encrypted, eg if it does not involve the network, like a UNIX socket, or pipe. * include/libvirt/libvirt.h.in: Define public API * src/driver.h: Define internal driver API * src/libvirt.c: Implement public API entry point * src/libvirt_public.syms: Export API symbols * src/esx/esx_driver.c, src/lxc/lxc_driver.c, src/interface/netcf_driver.c, src/network/bridge_driver.c, src/opennebula/one_driver.c, src/openvz/openvz_driver.c, src/phyp/phyp_driver.c, src/qemu/qemu_driver.c, src/remote/remote_driver.c, src/test/test_driver.c, src/uml/uml_driver.c, src/vbox/vbox_tmpl.c, src/xen/xen_driver.c: Stub out driver tables
2009-10-21 10:49:05 +00:00
typedef int
(*virDrvConnectIsEncrypted)(virConnectPtr conn);
typedef int
(*virDrvConnectIsSecure)(virConnectPtr conn);
typedef int
(*virDrvConnectIsAlive)(virConnectPtr conn);
New APIs for checking some object properties Introduce a number of new APIs to expose some boolean properties of objects, which cannot otherwise reliably determined, nor are aspects of the XML configuration. * virDomainIsActive: Checking virDomainGetID is not reliable since it is not possible to distinguish between error condition and inactive domain for ID of -1. * virDomainIsPersistent: Check whether a persistent config exists for the domain * virNetworkIsActive: Check whether the network is active * virNetworkIsPersistent: Check whether a persistent config exists for the network * virStoragePoolIsActive: Check whether the storage pool is active * virStoragePoolIsPersistent: Check whether a persistent config exists for the storage pool * virInterfaceIsActive: Check whether the host interface is active * virConnectIsSecure: whether the communication channel to the hypervisor is secure * virConnectIsEncrypted: whether any network based commnunication channels are encrypted NB, a channel can be secure, even if not encrypted, eg if it does not involve the network, like a UNIX socket, or pipe. * include/libvirt/libvirt.h.in: Define public API * src/driver.h: Define internal driver API * src/libvirt.c: Implement public API entry point * src/libvirt_public.syms: Export API symbols * src/esx/esx_driver.c, src/lxc/lxc_driver.c, src/interface/netcf_driver.c, src/network/bridge_driver.c, src/opennebula/one_driver.c, src/openvz/openvz_driver.c, src/phyp/phyp_driver.c, src/qemu/qemu_driver.c, src/remote/remote_driver.c, src/test/test_driver.c, src/uml/uml_driver.c, src/vbox/vbox_tmpl.c, src/xen/xen_driver.c: Stub out driver tables
2009-10-21 10:49:05 +00:00
typedef int
(*virDrvDomainIsActive)(virDomainPtr dom);
typedef int
(*virDrvDomainIsPersistent)(virDomainPtr dom);
typedef int
(*virDrvDomainIsUpdated)(virDomainPtr dom);
New APIs for checking some object properties Introduce a number of new APIs to expose some boolean properties of objects, which cannot otherwise reliably determined, nor are aspects of the XML configuration. * virDomainIsActive: Checking virDomainGetID is not reliable since it is not possible to distinguish between error condition and inactive domain for ID of -1. * virDomainIsPersistent: Check whether a persistent config exists for the domain * virNetworkIsActive: Check whether the network is active * virNetworkIsPersistent: Check whether a persistent config exists for the network * virStoragePoolIsActive: Check whether the storage pool is active * virStoragePoolIsPersistent: Check whether a persistent config exists for the storage pool * virInterfaceIsActive: Check whether the host interface is active * virConnectIsSecure: whether the communication channel to the hypervisor is secure * virConnectIsEncrypted: whether any network based commnunication channels are encrypted NB, a channel can be secure, even if not encrypted, eg if it does not involve the network, like a UNIX socket, or pipe. * include/libvirt/libvirt.h.in: Define public API * src/driver.h: Define internal driver API * src/libvirt.c: Implement public API entry point * src/libvirt_public.syms: Export API symbols * src/esx/esx_driver.c, src/lxc/lxc_driver.c, src/interface/netcf_driver.c, src/network/bridge_driver.c, src/opennebula/one_driver.c, src/openvz/openvz_driver.c, src/phyp/phyp_driver.c, src/qemu/qemu_driver.c, src/remote/remote_driver.c, src/test/test_driver.c, src/uml/uml_driver.c, src/vbox/vbox_tmpl.c, src/xen/xen_driver.c: Stub out driver tables
2009-10-21 10:49:05 +00:00
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);
Introduce a new public API for domain events The current API for domain events has a number of problems - Only allows for domain lifecycle change events - Does not allow the same callback to be registered multiple times - Does not allow filtering of events to a specific domain This introduces a new more general purpose domain events API typedef enum { VIR_DOMAIN_EVENT_ID_LIFECYCLE = 0, /* virConnectDomainEventCallback */ ...more events later.. } int virConnectDomainEventRegisterAny(virConnectPtr conn, virDomainPtr dom, /* Optional, to filter */ int eventID, virConnectDomainEventGenericCallback cb, void *opaque, virFreeCallback freecb); int virConnectDomainEventDeregisterAny(virConnectPtr conn, int callbackID); Since different event types can received different data in the callback, the API is defined with a generic callback. Specific events will each have a custom signature for their callback. Thus when registering an event it is neccessary to cast the callback to the generic signature eg int myDomainEventCallback(virConnectPtr conn, virDomainPtr dom, int event, int detail, void *opaque) { ... } virConnectDomainEventRegisterAny(conn, NULL, VIR_DOMAIN_EVENT_ID_LIFECYCLE, VIR_DOMAIN_EVENT_CALLBACK(myDomainEventCallback) NULL, NULL); The VIR_DOMAIN_EVENT_CALLBACK() macro simply does a "bad" cast to the generic signature * include/libvirt/libvirt.h.in: Define new APIs for registering domain events * src/driver.h: Internal driver entry points for new events APIs * src/libvirt.c: Wire up public API to driver API for events APIs * src/libvirt_public.syms: Export new APIs * src/esx/esx_driver.c, src/lxc/lxc_driver.c, src/opennebula/one_driver.c, src/openvz/openvz_driver.c, src/phyp/phyp_driver.c, src/qemu/qemu_driver.c, src/remote/remote_driver.c, src/test/test_driver.c, src/uml/uml_driver.c, src/vbox/vbox_tmpl.c, src/xen/xen_driver.c, src/xenapi/xenapi_driver.c: Stub out new API entries
2010-03-18 13:01:48 +00:00
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);
snapshot: new query APIs Right now, starting from just a virDomainSnapshotPtr, and wanting to know if it is the current snapshot for its respective domain, you have to use virDomainSnapshotGetDomain(), then virDomainSnapshotCurrent(), then compare the two names returned by virDomainSnapshotGetName(). It is a bit easier if we can directly query this information from the snapshot itself. Right now, it is possible to filter a snapshot listing based on whether snapshots have metadata that would prevent domain deletion, but the only way to learn if an individual snapshot has metadata is to see if that snapshot appears in the list returned by a listing. Additionally, I hope to expand the qemu driver in a future patch to use qemu-img to reconstruct snapshot XML corresponding to internal qcow2 snapshot names not otherwise tracked by libvirt (in part, so that libvirt can guarantee that new snapshots are not created with a name that would silently corrupt the existing portion of the qcow2 file); if I ever get that in, then it would no longer be an all-or-none decision on whether snapshots have metadata, and becomes all the more important to be able to directly determine that information from a particular snapshot. Other query functions (such as virDomainIsActive) do not have a flags argument, but since virDomainHasCurrentSnapshot takes a flags argument, I figured it was safer to provide a flags argument here as well. * include/libvirt/libvirt.h.in (virDomainSnapshotIsCurrent) (virDomainSnapshotHasMetadata): New declarations. * src/libvirt.c (virDomainSnapshotIsCurrent) (virDomainSnapshotHasMetadata): New functions. * src/libvirt_public.syms (LIBVIRT_0.9.13): Export them. * src/driver.h (virDrvDomainSnapshotIsCurrent) (virDrvDomainSnapshotHasMetadata): New driver callbacks.
2012-05-23 23:10:39 +00:00
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);
build: use correct type for pid and similar types No thanks to 64-bit windows, with 64-bit pid_t, we have to avoid constructs like 'int pid'. Our API in libvirt-qemu cannot be changed without breaking ABI; but then again, libvirt-qemu can only be used on systems that support UNIX sockets, which rules out Windows (even if qemu could be compiled there) - so for all points on the call chain that interact with this API decision, we require a different variable name to make it clear that we audited the use for safety. Adding a syntax-check rule only solves half the battle; anywhere that uses printf on a pid_t still needs to be converted, but that will be a separate patch. * cfg.mk (sc_correct_id_types): New syntax check. * src/libvirt-qemu.c (virDomainQemuAttach): Document why we didn't use pid_t for pid, and validate for overflow. * include/libvirt/libvirt-qemu.h (virDomainQemuAttach): Tweak name for syntax check. * src/vmware/vmware_conf.c (vmwareExtractPid): Likewise. * src/driver.h (virDrvDomainQemuAttach): Likewise. * tools/virsh.c (cmdQemuAttach): Likewise. * src/remote/qemu_protocol.x (qemu_domain_attach_args): Likewise. * src/qemu_protocol-structs (qemu_domain_attach_args): Likewise. * src/util/cgroup.c (virCgroupPidCode, virCgroupKillInternal): Likewise. * src/qemu/qemu_command.c(qemuParseProcFileStrings): Likewise. (qemuParseCommandLinePid): Use pid_t for pid. * daemon/libvirtd.c (daemonForkIntoBackground): Likewise. * src/conf/domain_conf.h (_virDomainObj): Likewise. * src/probes.d (rpc_socket_new): Likewise. * src/qemu/qemu_command.h (qemuParseCommandLinePid): Likewise. * src/qemu/qemu_driver.c (qemudGetProcessInfo, qemuDomainAttach): Likewise. * src/qemu/qemu_process.c (qemuProcessAttach): Likewise. * src/qemu/qemu_process.h (qemuProcessAttach): Likewise. * src/uml/uml_driver.c (umlGetProcessInfo): Likewise. * src/util/virnetdev.h (virNetDevSetNamespace): Likewise. * src/util/virnetdev.c (virNetDevSetNamespace): Likewise. * tests/testutils.c (virtTestCaptureProgramOutput): Likewise. * src/conf/storage_conf.h (_virStoragePerms): Use mode_t, uid_t, and gid_t rather than int. * src/security/security_dac.c (virSecurityDACSetOwnership): Likewise. * src/conf/storage_conf.c (virStorageDefParsePerms): Avoid compiler warning.
2012-02-10 23:08:11 +00:00
/* Choice of unsigned int rather than pid_t is intentional. */
typedef virDomainPtr
(*virDrvDomainQemuAttach)(virConnectPtr conn,
build: use correct type for pid and similar types No thanks to 64-bit windows, with 64-bit pid_t, we have to avoid constructs like 'int pid'. Our API in libvirt-qemu cannot be changed without breaking ABI; but then again, libvirt-qemu can only be used on systems that support UNIX sockets, which rules out Windows (even if qemu could be compiled there) - so for all points on the call chain that interact with this API decision, we require a different variable name to make it clear that we audited the use for safety. Adding a syntax-check rule only solves half the battle; anywhere that uses printf on a pid_t still needs to be converted, but that will be a separate patch. * cfg.mk (sc_correct_id_types): New syntax check. * src/libvirt-qemu.c (virDomainQemuAttach): Document why we didn't use pid_t for pid, and validate for overflow. * include/libvirt/libvirt-qemu.h (virDomainQemuAttach): Tweak name for syntax check. * src/vmware/vmware_conf.c (vmwareExtractPid): Likewise. * src/driver.h (virDrvDomainQemuAttach): Likewise. * tools/virsh.c (cmdQemuAttach): Likewise. * src/remote/qemu_protocol.x (qemu_domain_attach_args): Likewise. * src/qemu_protocol-structs (qemu_domain_attach_args): Likewise. * src/util/cgroup.c (virCgroupPidCode, virCgroupKillInternal): Likewise. * src/qemu/qemu_command.c(qemuParseProcFileStrings): Likewise. (qemuParseCommandLinePid): Use pid_t for pid. * daemon/libvirtd.c (daemonForkIntoBackground): Likewise. * src/conf/domain_conf.h (_virDomainObj): Likewise. * src/probes.d (rpc_socket_new): Likewise. * src/qemu/qemu_command.h (qemuParseCommandLinePid): Likewise. * src/qemu/qemu_driver.c (qemudGetProcessInfo, qemuDomainAttach): Likewise. * src/qemu/qemu_process.c (qemuProcessAttach): Likewise. * src/qemu/qemu_process.h (qemuProcessAttach): Likewise. * src/uml/uml_driver.c (umlGetProcessInfo): Likewise. * src/util/virnetdev.h (virNetDevSetNamespace): Likewise. * src/util/virnetdev.c (virNetDevSetNamespace): Likewise. * tests/testutils.c (virtTestCaptureProgramOutput): Likewise. * src/conf/storage_conf.h (_virStoragePerms): Use mode_t, uid_t, and gid_t rather than int. * src/security/security_dac.c (virSecurityDACSetOwnership): Likewise. * src/conf/storage_conf.c (virStorageDefParsePerms): Avoid compiler warning.
2012-02-10 23:08:11 +00:00
unsigned int pid_value,
unsigned int flags);
typedef int
(*virDrvDomainOpenConsole)(virDomainPtr dom,
const char *dev_name,
virStreamPtr st,
unsigned int flags);
typedef int
(*virDrvDomainOpenGraphics)(virDomainPtr dom,
unsigned int idx,
int fd,
unsigned int flags);
2011-05-10 08:26:02 +00:00
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);
Introduce yet another migration version in API. Migration just seems to go from bad to worse. We already had to introduce a second migration protocol when adding the QEMU driver, since the one from Xen was insufficiently flexible to cope with passing the data the QEMU driver required. It turns out that this protocol still has some flaws that we need to address. The current sequence is * Src: DumpXML - Generate XML to pass to dst * Dst: Prepare - Get ready to accept incoming VM - Generate optional cookie to pass to src * Src: Perform - Start migration and wait for send completion - Kill off VM if successful, resume if failed * Dst: Finish - Wait for recv completion and check status - Kill off VM if unsuccessful The problems with this are: - Since the first step is a generic 'DumpXML' call, we can't add in other migration specific data. eg, we can't include any VM lease data from lock manager plugins - Since the first step is a generic 'DumpXML' call, we can't emit any 'migration begin' event on the source, or have any hook that runs right at the start of the process - Since there is no final step on the source, if the Finish method fails to receive all migration data & has to kill the VM, then there's no way to resume the original VM on the source This patch attempts to introduce a version 3 that uses the improved 5 step sequence * Src: Begin - Generate XML to pass to dst - Generate optional cookie to pass to dst * Dst: Prepare - Get ready to accept incoming VM - Generate optional cookie to pass to src * Src: Perform - Start migration and wait for send completion - Generate optional cookie to pass to dst * Dst: Finish - Wait for recv completion and check status - Kill off VM if failed, resume if success - Generate optional cookie to pass to src * Src: Confirm - Kill off VM if success, resume if failed The API is designed to allow both input and output cookies in all methods where applicable. This lets us pass around arbitrary extra driver specific data between src & dst during migration. Combined with the extra 'Begin' method this lets us pass lease information from source to dst at the start of migration Moving the killing of the source VM out of Perform and into Confirm, means we can now recover if the dst host can't successfully Finish receiving migration data.
2010-11-02 12:43:44 +00:00
typedef char *
(*virDrvDomainMigrateBegin3)
(virDomainPtr domain,
const char *xmlin,
Introduce yet another migration version in API. Migration just seems to go from bad to worse. We already had to introduce a second migration protocol when adding the QEMU driver, since the one from Xen was insufficiently flexible to cope with passing the data the QEMU driver required. It turns out that this protocol still has some flaws that we need to address. The current sequence is * Src: DumpXML - Generate XML to pass to dst * Dst: Prepare - Get ready to accept incoming VM - Generate optional cookie to pass to src * Src: Perform - Start migration and wait for send completion - Kill off VM if successful, resume if failed * Dst: Finish - Wait for recv completion and check status - Kill off VM if unsuccessful The problems with this are: - Since the first step is a generic 'DumpXML' call, we can't add in other migration specific data. eg, we can't include any VM lease data from lock manager plugins - Since the first step is a generic 'DumpXML' call, we can't emit any 'migration begin' event on the source, or have any hook that runs right at the start of the process - Since there is no final step on the source, if the Finish method fails to receive all migration data & has to kill the VM, then there's no way to resume the original VM on the source This patch attempts to introduce a version 3 that uses the improved 5 step sequence * Src: Begin - Generate XML to pass to dst - Generate optional cookie to pass to dst * Dst: Prepare - Get ready to accept incoming VM - Generate optional cookie to pass to src * Src: Perform - Start migration and wait for send completion - Generate optional cookie to pass to dst * Dst: Finish - Wait for recv completion and check status - Kill off VM if failed, resume if success - Generate optional cookie to pass to src * Src: Confirm - Kill off VM if success, resume if failed The API is designed to allow both input and output cookies in all methods where applicable. This lets us pass around arbitrary extra driver specific data between src & dst during migration. Combined with the extra 'Begin' method this lets us pass lease information from source to dst at the start of migration Moving the killing of the source VM out of Perform and into Confirm, means we can now recover if the dst host can't successfully Finish receiving migration data.
2010-11-02 12:43:44 +00:00
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,
Introduce yet another migration version in API. Migration just seems to go from bad to worse. We already had to introduce a second migration protocol when adding the QEMU driver, since the one from Xen was insufficiently flexible to cope with passing the data the QEMU driver required. It turns out that this protocol still has some flaws that we need to address. The current sequence is * Src: DumpXML - Generate XML to pass to dst * Dst: Prepare - Get ready to accept incoming VM - Generate optional cookie to pass to src * Src: Perform - Start migration and wait for send completion - Kill off VM if successful, resume if failed * Dst: Finish - Wait for recv completion and check status - Kill off VM if unsuccessful The problems with this are: - Since the first step is a generic 'DumpXML' call, we can't add in other migration specific data. eg, we can't include any VM lease data from lock manager plugins - Since the first step is a generic 'DumpXML' call, we can't emit any 'migration begin' event on the source, or have any hook that runs right at the start of the process - Since there is no final step on the source, if the Finish method fails to receive all migration data & has to kill the VM, then there's no way to resume the original VM on the source This patch attempts to introduce a version 3 that uses the improved 5 step sequence * Src: Begin - Generate XML to pass to dst - Generate optional cookie to pass to dst * Dst: Prepare - Get ready to accept incoming VM - Generate optional cookie to pass to src * Src: Perform - Start migration and wait for send completion - Generate optional cookie to pass to dst * Dst: Finish - Wait for recv completion and check status - Kill off VM if failed, resume if success - Generate optional cookie to pass to src * Src: Confirm - Kill off VM if success, resume if failed The API is designed to allow both input and output cookies in all methods where applicable. This lets us pass around arbitrary extra driver specific data between src & dst during migration. Combined with the extra 'Begin' method this lets us pass lease information from source to dst at the start of migration Moving the killing of the source VM out of Perform and into Confirm, means we can now recover if the dst host can't successfully Finish receiving migration data.
2010-11-02 12:43:44 +00:00
const char *cookiein,
int cookieinlen,
char **cookieout,
int *cookieoutlen,
const char *dconnuri,
Introduce yet another migration version in API. Migration just seems to go from bad to worse. We already had to introduce a second migration protocol when adding the QEMU driver, since the one from Xen was insufficiently flexible to cope with passing the data the QEMU driver required. It turns out that this protocol still has some flaws that we need to address. The current sequence is * Src: DumpXML - Generate XML to pass to dst * Dst: Prepare - Get ready to accept incoming VM - Generate optional cookie to pass to src * Src: Perform - Start migration and wait for send completion - Kill off VM if successful, resume if failed * Dst: Finish - Wait for recv completion and check status - Kill off VM if unsuccessful The problems with this are: - Since the first step is a generic 'DumpXML' call, we can't add in other migration specific data. eg, we can't include any VM lease data from lock manager plugins - Since the first step is a generic 'DumpXML' call, we can't emit any 'migration begin' event on the source, or have any hook that runs right at the start of the process - Since there is no final step on the source, if the Finish method fails to receive all migration data & has to kill the VM, then there's no way to resume the original VM on the source This patch attempts to introduce a version 3 that uses the improved 5 step sequence * Src: Begin - Generate XML to pass to dst - Generate optional cookie to pass to dst * Dst: Prepare - Get ready to accept incoming VM - Generate optional cookie to pass to src * Src: Perform - Start migration and wait for send completion - Generate optional cookie to pass to dst * Dst: Finish - Wait for recv completion and check status - Kill off VM if failed, resume if success - Generate optional cookie to pass to src * Src: Confirm - Kill off VM if success, resume if failed The API is designed to allow both input and output cookies in all methods where applicable. This lets us pass around arbitrary extra driver specific data between src & dst during migration. Combined with the extra 'Begin' method this lets us pass lease information from source to dst at the start of migration Moving the killing of the source VM out of Perform and into Confirm, means we can now recover if the dst host can't successfully Finish receiving migration data.
2010-11-02 12:43:44 +00:00
const char *uri,
unsigned long flags,
const char *dname,
unsigned long resource);
typedef virDomainPtr
Introduce yet another migration version in API. Migration just seems to go from bad to worse. We already had to introduce a second migration protocol when adding the QEMU driver, since the one from Xen was insufficiently flexible to cope with passing the data the QEMU driver required. It turns out that this protocol still has some flaws that we need to address. The current sequence is * Src: DumpXML - Generate XML to pass to dst * Dst: Prepare - Get ready to accept incoming VM - Generate optional cookie to pass to src * Src: Perform - Start migration and wait for send completion - Kill off VM if successful, resume if failed * Dst: Finish - Wait for recv completion and check status - Kill off VM if unsuccessful The problems with this are: - Since the first step is a generic 'DumpXML' call, we can't add in other migration specific data. eg, we can't include any VM lease data from lock manager plugins - Since the first step is a generic 'DumpXML' call, we can't emit any 'migration begin' event on the source, or have any hook that runs right at the start of the process - Since there is no final step on the source, if the Finish method fails to receive all migration data & has to kill the VM, then there's no way to resume the original VM on the source This patch attempts to introduce a version 3 that uses the improved 5 step sequence * Src: Begin - Generate XML to pass to dst - Generate optional cookie to pass to dst * Dst: Prepare - Get ready to accept incoming VM - Generate optional cookie to pass to src * Src: Perform - Start migration and wait for send completion - Generate optional cookie to pass to dst * Dst: Finish - Wait for recv completion and check status - Kill off VM if failed, resume if success - Generate optional cookie to pass to src * Src: Confirm - Kill off VM if success, resume if failed The API is designed to allow both input and output cookies in all methods where applicable. This lets us pass around arbitrary extra driver specific data between src & dst during migration. Combined with the extra 'Begin' method this lets us pass lease information from source to dst at the start of migration Moving the killing of the source VM out of Perform and into Confirm, means we can now recover if the dst host can't successfully Finish receiving migration data.
2010-11-02 12:43:44 +00:00
(*virDrvDomainMigrateFinish3)
(virConnectPtr dconn,
const char *dname,
const char *cookiein,
int cookieinlen,
char **cookieout,
int *cookieoutlen,
const char *dconnuri,
Introduce yet another migration version in API. Migration just seems to go from bad to worse. We already had to introduce a second migration protocol when adding the QEMU driver, since the one from Xen was insufficiently flexible to cope with passing the data the QEMU driver required. It turns out that this protocol still has some flaws that we need to address. The current sequence is * Src: DumpXML - Generate XML to pass to dst * Dst: Prepare - Get ready to accept incoming VM - Generate optional cookie to pass to src * Src: Perform - Start migration and wait for send completion - Kill off VM if successful, resume if failed * Dst: Finish - Wait for recv completion and check status - Kill off VM if unsuccessful The problems with this are: - Since the first step is a generic 'DumpXML' call, we can't add in other migration specific data. eg, we can't include any VM lease data from lock manager plugins - Since the first step is a generic 'DumpXML' call, we can't emit any 'migration begin' event on the source, or have any hook that runs right at the start of the process - Since there is no final step on the source, if the Finish method fails to receive all migration data & has to kill the VM, then there's no way to resume the original VM on the source This patch attempts to introduce a version 3 that uses the improved 5 step sequence * Src: Begin - Generate XML to pass to dst - Generate optional cookie to pass to dst * Dst: Prepare - Get ready to accept incoming VM - Generate optional cookie to pass to src * Src: Perform - Start migration and wait for send completion - Generate optional cookie to pass to dst * Dst: Finish - Wait for recv completion and check status - Kill off VM if failed, resume if success - Generate optional cookie to pass to src * Src: Confirm - Kill off VM if success, resume if failed The API is designed to allow both input and output cookies in all methods where applicable. This lets us pass around arbitrary extra driver specific data between src & dst during migration. Combined with the extra 'Begin' method this lets us pass lease information from source to dst at the start of migration Moving the killing of the source VM out of Perform and into Confirm, means we can now recover if the dst host can't successfully Finish receiving migration data.
2010-11-02 12:43:44 +00:00
const char *uri,
unsigned long flags,
int cancelled);
Introduce yet another migration version in API. Migration just seems to go from bad to worse. We already had to introduce a second migration protocol when adding the QEMU driver, since the one from Xen was insufficiently flexible to cope with passing the data the QEMU driver required. It turns out that this protocol still has some flaws that we need to address. The current sequence is * Src: DumpXML - Generate XML to pass to dst * Dst: Prepare - Get ready to accept incoming VM - Generate optional cookie to pass to src * Src: Perform - Start migration and wait for send completion - Kill off VM if successful, resume if failed * Dst: Finish - Wait for recv completion and check status - Kill off VM if unsuccessful The problems with this are: - Since the first step is a generic 'DumpXML' call, we can't add in other migration specific data. eg, we can't include any VM lease data from lock manager plugins - Since the first step is a generic 'DumpXML' call, we can't emit any 'migration begin' event on the source, or have any hook that runs right at the start of the process - Since there is no final step on the source, if the Finish method fails to receive all migration data & has to kill the VM, then there's no way to resume the original VM on the source This patch attempts to introduce a version 3 that uses the improved 5 step sequence * Src: Begin - Generate XML to pass to dst - Generate optional cookie to pass to dst * Dst: Prepare - Get ready to accept incoming VM - Generate optional cookie to pass to src * Src: Perform - Start migration and wait for send completion - Generate optional cookie to pass to dst * Dst: Finish - Wait for recv completion and check status - Kill off VM if failed, resume if success - Generate optional cookie to pass to src * Src: Confirm - Kill off VM if success, resume if failed The API is designed to allow both input and output cookies in all methods where applicable. This lets us pass around arbitrary extra driver specific data between src & dst during migration. Combined with the extra 'Begin' method this lets us pass lease information from source to dst at the start of migration Moving the killing of the source VM out of Perform and into Confirm, means we can now recover if the dst host can't successfully Finish receiving migration data.
2010-11-02 12:43:44 +00:00
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);
block rebase: add new API virDomainBlockRebase Qemu is adding the ability to do a partial rebase. That is, given: base <- intermediate <- current virDomainBlockPull will produce: current but qemu now has the ability to leave base in the chain, to produce: base <- current Note that current qemu can only do a forward merge, and only with the current image as the destination, which is fully described by this API without flags. But in the future, it may be possible to enhance this API for additional scenarios by using flags: Merging the current image back into a previous image (that is, undoing a live snapshot), could be done by passing base as the destination and flags with a bit requesting a backward merge. Merging any other part of the image chain, whether forwards (the backing image contents are pulled into the newer file) or backwards (the deltas recorded in the newer file are merged back into the backing file), could also be done by passing a new flag that says that base should be treated as an XML snippet rather than an absolute path name, where the XML could then supply the additional instructions of which part of the image chain is being merged into any other part. * include/libvirt/libvirt.h.in (virDomainBlockRebase): New declaration. * src/libvirt.c (virDomainBlockRebase): Implement it. * src/libvirt_public.syms (LIBVIRT_0.9.10): Export it. * src/driver.h (virDrvDomainBlockRebase): New driver callback. * src/rpc/gendispatch.pl (long_legacy): Add exemption. * docs/apibuild.py (long_legacy_functions): Likewise.
2012-02-01 04:19:51 +00:00
typedef int
(*virDrvDomainBlockRebase)(virDomainPtr dom, const char *path,
const char *base, 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);
/**
* _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;
virDrvDomainGetVcpus domainGetVcpus;
virDrvDomainGetMaxVcpus domainGetMaxVcpus;
virDrvDomainGetSecurityLabel domainGetSecurityLabel;
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;
virDrvDomainOpenConsole domainOpenConsole;
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;
virDrvSetKeepAlive setKeepAlive;
virDrvConnectIsAlive isAlive;
virDrvNodeSuspendForDuration nodeSuspendForDuration;
virDrvDomainSetBlockIoTune domainSetBlockIoTune;
virDrvDomainGetBlockIoTune domainGetBlockIoTune;
virDrvDomainGetCPUStats domainGetCPUStats;
virDrvDomainGetDiskErrors domainGetDiskErrors;
virDrvDomainSetMetadata domainSetMetadata;
virDrvDomainGetMetadata domainGetMetadata;
};
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 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
(*virDrvNetworkCreate) (virNetworkPtr network);
typedef int
(*virDrvNetworkDestroy) (virNetworkPtr network);
typedef char *
(*virDrvNetworkGetXMLDesc) (virNetworkPtr network,
drivers: prefer unsigned int for flags Now that the public APIs always use unsigned flags, the internal driver callbacks might as well do likewise. * src/driver.h (vrDrvOpen, virDrvDomainCoreDump) (virDrvDomainGetXMLDesc, virDrvNetworkGetXMLDesc) (virDrvNWFilterGetXMLDesc): Update type. * src/remote/remote_protocol.x (remote_open_args) (remote_domain_core_dump_args, remote_domain_get_xml_desc_args) (remote_network_get_xml_desc_args) (remote_nwfilter_get_xml_desc_args): Likewise. * src/test/test_driver.c: Update clients. * src/remote/remote_driver.c: Likewise. * src/xen/xen_hypervisor.c: Likewise. * src/xen/xen_hypervisor.h: Likewise. * src/xen/xen_driver.c: Likewise. * src/xen/xend_internal.c: Likewise. * src/xen/xend_internal.h: Likewise. * src/xen/xm_internal.c: Likewise. * src/xen/xm_internal.h: Likewise. * src/xen/xs_internal.c: Likewise. * src/xen/xs_internal.h: Likewise. * src/xen/xen_inotify.c: Likewise. * src/xen/xen_inotify.h: Likewise. * src/phyp/phyp_driver.c: Likewise. * src/openvz/openvz_driver.c: Likewise. * src/vmware/vmware_driver.c: Likewise. * src/vbox/vbox_driver.c: Likewise. * src/vbox/vbox_tmpl.c: Likewise. * src/xenapi/xenapi_driver.c: Likewise. * src/esx/esx_driver.c: Likewise. * src/esx/esx_interface_driver.c: Likewise. * src/esx/esx_network_driver.c: Likewise. * src/esx/esx_storage_driver.c: Likewise. * src/esx/esx_device_monitor.c: Likewise. * src/esx/esx_secret_driver.c: Likewise. * src/esx/esx_nwfilter_driver.c: Likewise. * src/interface/netcf_driver.c: Likewise. * src/nwfilter/nwfilter_driver.c: Likewise. * src/libxl/libxl_driver.c: Likewise. * src/qemu/qemu_driver.c: Likewise. * src/lxc/lxc_driver.c: Likewise. * src/uml/uml_driver.c: Likewise. * src/network/bridge_driver.c: Likewise. * src/secret/secret_driver.c: Likewise. * src/storage/storage_driver.c: Likewise. * src/node_device/node_device_hal.c: Likewise. * src/node_device/node_device_udev.c: Likewise. * src/remote_protocol-structs: Likewise.
2011-07-06 20:40:19 +00:00
unsigned int flags);
typedef char *
(*virDrvNetworkGetBridgeName) (virNetworkPtr network);
typedef int
(*virDrvNetworkGetAutostart) (virNetworkPtr network,
int *autostart);
typedef int
(*virDrvNetworkSetAutostart) (virNetworkPtr network,
int autostart);
New APIs for checking some object properties Introduce a number of new APIs to expose some boolean properties of objects, which cannot otherwise reliably determined, nor are aspects of the XML configuration. * virDomainIsActive: Checking virDomainGetID is not reliable since it is not possible to distinguish between error condition and inactive domain for ID of -1. * virDomainIsPersistent: Check whether a persistent config exists for the domain * virNetworkIsActive: Check whether the network is active * virNetworkIsPersistent: Check whether a persistent config exists for the network * virStoragePoolIsActive: Check whether the storage pool is active * virStoragePoolIsPersistent: Check whether a persistent config exists for the storage pool * virInterfaceIsActive: Check whether the host interface is active * virConnectIsSecure: whether the communication channel to the hypervisor is secure * virConnectIsEncrypted: whether any network based commnunication channels are encrypted NB, a channel can be secure, even if not encrypted, eg if it does not involve the network, like a UNIX socket, or pipe. * include/libvirt/libvirt.h.in: Define public API * src/driver.h: Define internal driver API * src/libvirt.c: Implement public API entry point * src/libvirt_public.syms: Export API symbols * src/esx/esx_driver.c, src/lxc/lxc_driver.c, src/interface/netcf_driver.c, src/network/bridge_driver.c, src/opennebula/one_driver.c, src/openvz/openvz_driver.c, src/phyp/phyp_driver.c, src/qemu/qemu_driver.c, src/remote/remote_driver.c, src/test/test_driver.c, src/uml/uml_driver.c, src/vbox/vbox_tmpl.c, src/xen/xen_driver.c: Stub out driver tables
2009-10-21 10:49:05 +00:00
typedef int
(*virDrvNetworkIsActive) (virNetworkPtr net);
New APIs for checking some object properties Introduce a number of new APIs to expose some boolean properties of objects, which cannot otherwise reliably determined, nor are aspects of the XML configuration. * virDomainIsActive: Checking virDomainGetID is not reliable since it is not possible to distinguish between error condition and inactive domain for ID of -1. * virDomainIsPersistent: Check whether a persistent config exists for the domain * virNetworkIsActive: Check whether the network is active * virNetworkIsPersistent: Check whether a persistent config exists for the network * virStoragePoolIsActive: Check whether the storage pool is active * virStoragePoolIsPersistent: Check whether a persistent config exists for the storage pool * virInterfaceIsActive: Check whether the host interface is active * virConnectIsSecure: whether the communication channel to the hypervisor is secure * virConnectIsEncrypted: whether any network based commnunication channels are encrypted NB, a channel can be secure, even if not encrypted, eg if it does not involve the network, like a UNIX socket, or pipe. * include/libvirt/libvirt.h.in: Define public API * src/driver.h: Define internal driver API * src/libvirt.c: Implement public API entry point * src/libvirt_public.syms: Export API symbols * src/esx/esx_driver.c, src/lxc/lxc_driver.c, src/interface/netcf_driver.c, src/network/bridge_driver.c, src/opennebula/one_driver.c, src/openvz/openvz_driver.c, src/phyp/phyp_driver.c, src/qemu/qemu_driver.c, src/remote/remote_driver.c, src/test/test_driver.c, src/uml/uml_driver.c, src/vbox/vbox_tmpl.c, src/xen/xen_driver.c: Stub out driver tables
2009-10-21 10:49:05 +00:00
typedef int
(*virDrvNetworkIsPersistent) (virNetworkPtr net);
New APIs for checking some object properties Introduce a number of new APIs to expose some boolean properties of objects, which cannot otherwise reliably determined, nor are aspects of the XML configuration. * virDomainIsActive: Checking virDomainGetID is not reliable since it is not possible to distinguish between error condition and inactive domain for ID of -1. * virDomainIsPersistent: Check whether a persistent config exists for the domain * virNetworkIsActive: Check whether the network is active * virNetworkIsPersistent: Check whether a persistent config exists for the network * virStoragePoolIsActive: Check whether the storage pool is active * virStoragePoolIsPersistent: Check whether a persistent config exists for the storage pool * virInterfaceIsActive: Check whether the host interface is active * virConnectIsSecure: whether the communication channel to the hypervisor is secure * virConnectIsEncrypted: whether any network based commnunication channels are encrypted NB, a channel can be secure, even if not encrypted, eg if it does not involve the network, like a UNIX socket, or pipe. * include/libvirt/libvirt.h.in: Define public API * src/driver.h: Define internal driver API * src/libvirt.c: Implement public API entry point * src/libvirt_public.syms: Export API symbols * src/esx/esx_driver.c, src/lxc/lxc_driver.c, src/interface/netcf_driver.c, src/network/bridge_driver.c, src/opennebula/one_driver.c, src/openvz/openvz_driver.c, src/phyp/phyp_driver.c, src/qemu/qemu_driver.c, src/remote/remote_driver.c, src/test/test_driver.c, src/uml/uml_driver.c, src/vbox/vbox_tmpl.c, src/xen/xen_driver.c: Stub out driver tables
2009-10-21 10:49:05 +00:00
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;
virDrvNetworkLookupByUUID networkLookupByUUID;
virDrvNetworkLookupByName networkLookupByName;
virDrvNetworkCreateXML networkCreateXML;
virDrvNetworkDefineXML networkDefineXML;
virDrvNetworkUndefine networkUndefine;
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 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);
New APIs for checking some object properties Introduce a number of new APIs to expose some boolean properties of objects, which cannot otherwise reliably determined, nor are aspects of the XML configuration. * virDomainIsActive: Checking virDomainGetID is not reliable since it is not possible to distinguish between error condition and inactive domain for ID of -1. * virDomainIsPersistent: Check whether a persistent config exists for the domain * virNetworkIsActive: Check whether the network is active * virNetworkIsPersistent: Check whether a persistent config exists for the network * virStoragePoolIsActive: Check whether the storage pool is active * virStoragePoolIsPersistent: Check whether a persistent config exists for the storage pool * virInterfaceIsActive: Check whether the host interface is active * virConnectIsSecure: whether the communication channel to the hypervisor is secure * virConnectIsEncrypted: whether any network based commnunication channels are encrypted NB, a channel can be secure, even if not encrypted, eg if it does not involve the network, like a UNIX socket, or pipe. * include/libvirt/libvirt.h.in: Define public API * src/driver.h: Define internal driver API * src/libvirt.c: Implement public API entry point * src/libvirt_public.syms: Export API symbols * src/esx/esx_driver.c, src/lxc/lxc_driver.c, src/interface/netcf_driver.c, src/network/bridge_driver.c, src/opennebula/one_driver.c, src/openvz/openvz_driver.c, src/phyp/phyp_driver.c, src/qemu/qemu_driver.c, src/remote/remote_driver.c, src/test/test_driver.c, src/uml/uml_driver.c, src/vbox/vbox_tmpl.c, src/xen/xen_driver.c: Stub out driver tables
2009-10-21 10:49:05 +00:00
typedef int
(*virDrvInterfaceIsActive) (virInterfacePtr iface);
New APIs for checking some object properties Introduce a number of new APIs to expose some boolean properties of objects, which cannot otherwise reliably determined, nor are aspects of the XML configuration. * virDomainIsActive: Checking virDomainGetID is not reliable since it is not possible to distinguish between error condition and inactive domain for ID of -1. * virDomainIsPersistent: Check whether a persistent config exists for the domain * virNetworkIsActive: Check whether the network is active * virNetworkIsPersistent: Check whether a persistent config exists for the network * virStoragePoolIsActive: Check whether the storage pool is active * virStoragePoolIsPersistent: Check whether a persistent config exists for the storage pool * virInterfaceIsActive: Check whether the host interface is active * virConnectIsSecure: whether the communication channel to the hypervisor is secure * virConnectIsEncrypted: whether any network based commnunication channels are encrypted NB, a channel can be secure, even if not encrypted, eg if it does not involve the network, like a UNIX socket, or pipe. * include/libvirt/libvirt.h.in: Define public API * src/driver.h: Define internal driver API * src/libvirt.c: Implement public API entry point * src/libvirt_public.syms: Export API symbols * src/esx/esx_driver.c, src/lxc/lxc_driver.c, src/interface/netcf_driver.c, src/network/bridge_driver.c, src/opennebula/one_driver.c, src/openvz/openvz_driver.c, src/phyp/phyp_driver.c, src/qemu/qemu_driver.c, src/remote/remote_driver.c, src/test/test_driver.c, src/uml/uml_driver.c, src/vbox/vbox_tmpl.c, src/xen/xen_driver.c: Stub out driver tables
2009-10-21 10:49:05 +00:00
typedef int
(*virDrvInterfaceChangeBegin) (virConnectPtr conn,
unsigned int flags);
typedef int
(*virDrvInterfaceChangeCommit) (virConnectPtr conn,
unsigned int flags);
typedef int
(*virDrvInterfaceChangeRollback)(virConnectPtr conn,
unsigned int flags);
New APIs for checking some object properties Introduce a number of new APIs to expose some boolean properties of objects, which cannot otherwise reliably determined, nor are aspects of the XML configuration. * virDomainIsActive: Checking virDomainGetID is not reliable since it is not possible to distinguish between error condition and inactive domain for ID of -1. * virDomainIsPersistent: Check whether a persistent config exists for the domain * virNetworkIsActive: Check whether the network is active * virNetworkIsPersistent: Check whether a persistent config exists for the network * virStoragePoolIsActive: Check whether the storage pool is active * virStoragePoolIsPersistent: Check whether a persistent config exists for the storage pool * virInterfaceIsActive: Check whether the host interface is active * virConnectIsSecure: whether the communication channel to the hypervisor is secure * virConnectIsEncrypted: whether any network based commnunication channels are encrypted NB, a channel can be secure, even if not encrypted, eg if it does not involve the network, like a UNIX socket, or pipe. * include/libvirt/libvirt.h.in: Define public API * src/driver.h: Define internal driver API * src/libvirt.c: Implement public API entry point * src/libvirt_public.syms: Export API symbols * src/esx/esx_driver.c, src/lxc/lxc_driver.c, src/interface/netcf_driver.c, src/network/bridge_driver.c, src/opennebula/one_driver.c, src/openvz/openvz_driver.c, src/phyp/phyp_driver.c, src/qemu/qemu_driver.c, src/remote/remote_driver.c, src/test/test_driver.c, src/uml/uml_driver.c, src/vbox/vbox_tmpl.c, src/xen/xen_driver.c: Stub out driver tables
2009-10-21 10:49:05 +00:00
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;
virDrvInterfaceLookupByName interfaceLookupByName;
virDrvInterfaceLookupByMACString interfaceLookupByMACString;
virDrvInterfaceGetXMLDesc interfaceGetXMLDesc;
virDrvInterfaceDefineXML interfaceDefineXML;
virDrvInterfaceUndefine interfaceUndefine;
virDrvInterfaceCreate interfaceCreate;
virDrvInterfaceDestroy interfaceDestroy;
New APIs for checking some object properties Introduce a number of new APIs to expose some boolean properties of objects, which cannot otherwise reliably determined, nor are aspects of the XML configuration. * virDomainIsActive: Checking virDomainGetID is not reliable since it is not possible to distinguish between error condition and inactive domain for ID of -1. * virDomainIsPersistent: Check whether a persistent config exists for the domain * virNetworkIsActive: Check whether the network is active * virNetworkIsPersistent: Check whether a persistent config exists for the network * virStoragePoolIsActive: Check whether the storage pool is active * virStoragePoolIsPersistent: Check whether a persistent config exists for the storage pool * virInterfaceIsActive: Check whether the host interface is active * virConnectIsSecure: whether the communication channel to the hypervisor is secure * virConnectIsEncrypted: whether any network based commnunication channels are encrypted NB, a channel can be secure, even if not encrypted, eg if it does not involve the network, like a UNIX socket, or pipe. * include/libvirt/libvirt.h.in: Define public API * src/driver.h: Define internal driver API * src/libvirt.c: Implement public API entry point * src/libvirt_public.syms: Export API symbols * src/esx/esx_driver.c, src/lxc/lxc_driver.c, src/interface/netcf_driver.c, src/network/bridge_driver.c, src/opennebula/one_driver.c, src/openvz/openvz_driver.c, src/phyp/phyp_driver.c, src/qemu/qemu_driver.c, src/remote/remote_driver.c, src/test/test_driver.c, src/uml/uml_driver.c, src/vbox/vbox_tmpl.c, src/xen/xen_driver.c: Stub out driver tables
2009-10-21 10:49:05 +00:00
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 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 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);
New APIs for checking some object properties Introduce a number of new APIs to expose some boolean properties of objects, which cannot otherwise reliably determined, nor are aspects of the XML configuration. * virDomainIsActive: Checking virDomainGetID is not reliable since it is not possible to distinguish between error condition and inactive domain for ID of -1. * virDomainIsPersistent: Check whether a persistent config exists for the domain * virNetworkIsActive: Check whether the network is active * virNetworkIsPersistent: Check whether a persistent config exists for the network * virStoragePoolIsActive: Check whether the storage pool is active * virStoragePoolIsPersistent: Check whether a persistent config exists for the storage pool * virInterfaceIsActive: Check whether the host interface is active * virConnectIsSecure: whether the communication channel to the hypervisor is secure * virConnectIsEncrypted: whether any network based commnunication channels are encrypted NB, a channel can be secure, even if not encrypted, eg if it does not involve the network, like a UNIX socket, or pipe. * include/libvirt/libvirt.h.in: Define public API * src/driver.h: Define internal driver API * src/libvirt.c: Implement public API entry point * src/libvirt_public.syms: Export API symbols * src/esx/esx_driver.c, src/lxc/lxc_driver.c, src/interface/netcf_driver.c, src/network/bridge_driver.c, src/opennebula/one_driver.c, src/openvz/openvz_driver.c, src/phyp/phyp_driver.c, src/qemu/qemu_driver.c, src/remote/remote_driver.c, src/test/test_driver.c, src/uml/uml_driver.c, src/vbox/vbox_tmpl.c, src/xen/xen_driver.c: Stub out driver tables
2009-10-21 10:49:05 +00:00
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;
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;
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) (int privileged);
typedef int (*virDrvStateCleanup) (void);
typedef int (*virDrvStateReload) (void);
typedef int (*virDrvStateActive) (void);
typedef struct _virStateDriver virStateDriver;
typedef virStateDriver *virStateDriverPtr;
struct _virStateDriver {
const char *name;
virDrvStateInitialize initialize;
virDrvStateCleanup cleanup;
virDrvStateReload reload;
virDrvStateActive active;
};
# 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 virNodeDevicePtr (*virDevMonDeviceLookupByName)(virConnectPtr conn,
const char *name);
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;
virDevMonDeviceLookupByName deviceLookupByName;
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. */
libvirt: do not mix internal flags into public API There were two API in driver.c that were silently masking flags bits prior to calling out to the drivers, and several others that were explicitly masking flags bits. This is not forward-compatible - if we ever have that many flags in the future, then talking to an old server that masks out the flags would be indistinguishable from talking to a new server that can honor the flag. In general, libvirt.c should forward _all_ flags on to drivers, and only the drivers should reject unknown flags. In the case of virDrvSecretGetValue, the solution is to separate the internal driver callback function to have two parameters instead of one, with only one parameter affected by the public API. In the case of virDomainGetXMLDesc, it turns out that no one was ever mixing VIR_DOMAIN_XML_INTERNAL_STATUS with the dumpxml path in the first place; that internal flag was only used in saving and restoring state files, which happened to be in functions internal to a single file, so there is no mixing of the internal flag with a public flags argument. Additionally, virDomainMemoryStats passed a flags argument over RPC, but not to the driver. * src/driver.h (VIR_DOMAIN_XML_FLAGS_MASK) (VIR_SECRET_GET_VALUE_FLAGS_MASK): Delete. (virDrvSecretGetValue): Separate out internal flags. (virDrvDomainMemoryStats): Provide missing flags argument. * src/driver.c (verify): Drop unused check. * src/conf/domain_conf.h (virDomainObjParseFile): Delete declaration. (virDomainXMLInternalFlags): Move... * src/conf/domain_conf.c: ...here. Delete redundant include. (virDomainObjParseFile): Make static. * src/libvirt.c (virDomainGetXMLDesc, virSecretGetValue): Update clients. (virDomainMemoryPeek, virInterfaceGetXMLDesc) (virDomainMemoryStats, virDomainBlockPeek, virNetworkGetXMLDesc) (virStoragePoolGetXMLDesc, virStorageVolGetXMLDesc) (virNodeNumOfDevices, virNodeListDevices, virNWFilterGetXMLDesc): Don't mask unknown flags. * src/interface/netcf_driver.c (interfaceGetXMLDesc): Reject unknown flags. * src/secret/secret_driver.c (secretGetValue): Update clients. * src/remote/remote_driver.c (remoteSecretGetValue) (remoteDomainMemoryStats): Likewise. * src/qemu/qemu_process.c (qemuProcessGetVolumeQcowPassphrase): Likewise. * src/qemu/qemu_driver.c (qemudDomainMemoryStats): Likewise. * daemon/remote.c (remoteDispatchDomainMemoryStats): Likewise.
2011-07-13 21:31:56 +00:00
VIR_SECRET_GET_VALUE_INTERNAL_CALL = 1 << 0,
};
typedef virSecretPtr
Fix UUID handling in secrets/storage encryption APIs Convert all the secret/storage encryption APIs / wire format to handle UUIDs in raw format instead of non-canonical printable format. Guarentees data format correctness. * docs/schemas/storageencryption.rng: Make UUID mandatory for a secret and validate fully * docs/schemas/secret.rng: Fully validate UUID * include/libvirt/libvirt.h, include/libvirt/libvirt.h.in, Add virSecretLookupByUUID and virSecretGetUUID. Make virSecretGetUUIDString follow normal API design pattern * python/generator.py: Skip generation of virSecretGetUUID, virSecretGetUUIDString and virSecretLookupByUUID * python/libvir.c, python/libvirt-python-api.xml: Manual impl of virSecretGetUUID,virSecretGetUUIDString and virSecretLookupByUUID * qemud/remote.c: s/virSecretLookupByUUIDString/virSecretLookupByUUID/ Fix get_nonnull_secret/make_nonnull_secret to use unsigned char * qemud/remote_protocol.x: Fix remote_nonnull_secret to use a remote_uuid instead of remote_nonnull_string for UUID field. Rename REMOTE_PROC_SECRET_LOOKUP_BY_UUID_STRING to REMOTE_PROC_SECRET_LOOKUP_BY_UUID_STRING and make it take an remote_uuid value * qemud/remote_dispatch_args.h, qemud/remote_dispatch_prototypes.h, qemud/remote_dispatch_ret.h, qemud/remote_dispatch_table.h, qemud/remote_protocol.c, qemud/remote_protocol.h: Re-generate * src/datatypes.h, src/datatypes.c: Store UUID in raw format instead of printable. Change virGetSecret to use raw format UUID * src/driver.h: Rename virDrvSecretLookupByUUIDString to virDrvSecretLookupByUUID and use raw format UUID * src/libvirt.c: Add virSecretLookupByUUID and virSecretGetUUID and re-implement virSecretLookupByUUIDString and virSecretGetUUIDString in terms of those * src/libvirt_public.syms: Add virSecretLookupByUUID and virSecretGetUUID * src/remote_internal.c: Rename remoteSecretLookupByUUIDString to remoteSecretLookupByUUID. Fix typo in args for remoteSecretDefineXML impl. Use raw UUID format for get_nonnull_secret and make_nonnull_secret * src/storage_encryption_conf.c, src/storage_encryption_conf.h: Storage UUID in raw format, and require it to be present in XML. Use UUID parser to validate. * secret_conf.h, secret_conf.c: Generate a UUID if none is provided. Storage UUID in raw format. * src/secret_driver.c: Adjust to deal with raw UUIDs. Save secrets in a filed with printable UUID, instead of base64 UUID. * src/virsh.c: Adjust for changed public API contract of virSecretGetUUIDString. * src/storage_Backend.c: DOn't undefine secret we just generated upon successful volume creation. Fix to handle raw UUIDs. Generate a non-clashing UUID * src/qemu_driver.c: Change to use lookupByUUID instead of lookupByUUIDString
2009-09-10 16:44:12 +00:00
(*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 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;
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 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;
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);
2008-11-21 12:16:08 +00:00
void *virDriverLoadModule(const char *name);
#endif /* __VIR_DRIVER_H__ */