2006-03-20 17:49:28 +00:00
|
|
|
/*
|
2008-02-05 19:27:37 +00:00
|
|
|
* driver.h: description of the set of interfaces provided by a
|
2006-03-20 17:49:28 +00:00
|
|
|
* entry point to the virtualization engine
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef __VIR_DRIVER_H__
|
2010-03-09 18:22:22 +00:00
|
|
|
# define __VIR_DRIVER_H__
|
2006-03-20 17:49:28 +00:00
|
|
|
|
2010-03-09 18:22:22 +00:00
|
|
|
# include "config.h"
|
2009-08-14 19:42:19 +00:00
|
|
|
|
2010-03-09 18:22:22 +00:00
|
|
|
# include <libxml/uri.h>
|
2007-11-14 11:40:57 +00:00
|
|
|
|
2010-03-09 18:22:22 +00:00
|
|
|
# include "internal.h"
|
2006-06-21 12:56:19 +00:00
|
|
|
/*
|
|
|
|
* List of registered drivers numbers
|
|
|
|
*/
|
|
|
|
typedef enum {
|
2007-04-04 14:19:49 +00:00
|
|
|
VIR_DRV_XEN_UNIFIED = 1,
|
|
|
|
VIR_DRV_TEST = 2,
|
|
|
|
VIR_DRV_QEMU = 3,
|
2007-06-11 11:43:41 +00:00
|
|
|
VIR_DRV_REMOTE = 4,
|
2007-07-17 13:27:26 +00:00
|
|
|
VIR_DRV_OPENVZ = 5,
|
2008-11-19 16:58:23 +00:00
|
|
|
VIR_DRV_LXC = 6,
|
|
|
|
VIR_DRV_UML = 7,
|
2009-04-17 16:09:07 +00:00
|
|
|
VIR_DRV_VBOX = 8,
|
2009-05-25 11:56:00 +00:00
|
|
|
VIR_DRV_ONE = 9,
|
2009-07-23 20:21:08 +00:00
|
|
|
VIR_DRV_ESX = 10,
|
2009-07-24 14:17:06 +00:00
|
|
|
VIR_DRV_PHYP = 11,
|
2010-12-17 10:28:20 +00:00
|
|
|
VIR_DRV_XENAPI = 12,
|
|
|
|
VIR_DRV_VMWARE = 13
|
2006-06-21 12:56:19 +00:00
|
|
|
} virDrvNo;
|
|
|
|
|
|
|
|
|
2007-04-04 14:19:49 +00:00
|
|
|
/* 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;
|
|
|
|
|
2008-11-14 08:42:47 +00:00
|
|
|
|
2007-08-21 09:03:55 +00:00
|
|
|
/* Internal feature-detection macro. Don't call drv->supports_feature
|
2010-12-03 08:31:48 +00:00
|
|
|
* directly if you don't have to, because it may be NULL, use this macro
|
|
|
|
* instead.
|
2007-08-21 09:03:55 +00:00
|
|
|
*
|
2010-12-03 08:31:48 +00:00
|
|
|
* 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.
|
2007-08-21 09:03:55 +00:00
|
|
|
*
|
|
|
|
* Returns:
|
2010-12-03 08:31:48 +00:00
|
|
|
* != 0 Feature is supported.
|
2007-08-21 09:03:55 +00:00
|
|
|
* 0 Feature is not supported.
|
|
|
|
*/
|
2010-12-03 08:31:48 +00:00
|
|
|
# define VIR_DRV_SUPPORTS_FEATURE(drv,conn,feature) \
|
|
|
|
((drv)->supports_feature ? \
|
|
|
|
(drv)->supports_feature((conn), (feature)) > 0 : 0)
|
2007-08-21 09:03:55 +00:00
|
|
|
|
2007-04-04 14:19:49 +00:00
|
|
|
typedef virDrvOpenStatus
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvOpen) (virConnectPtr conn,
|
2007-12-05 18:28:05 +00:00
|
|
|
virConnectAuthPtr auth,
|
|
|
|
int flags);
|
2006-03-20 17:49:28 +00:00
|
|
|
typedef int
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvClose) (virConnectPtr conn);
|
2007-08-21 09:03:55 +00:00
|
|
|
typedef int
|
2008-11-17 11:03:25 +00:00
|
|
|
(*virDrvDrvSupportsFeature) (virConnectPtr conn, int feature);
|
2006-03-20 17:49:28 +00:00
|
|
|
typedef const char *
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvGetType) (virConnectPtr conn);
|
2006-03-20 17:49:28 +00:00
|
|
|
typedef int
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvGetVersion) (virConnectPtr conn,
|
|
|
|
unsigned long *hvVer);
|
2009-11-12 15:53:26 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvGetLibVersion) (virConnectPtr conn,
|
|
|
|
unsigned long *libVer);
|
2007-06-26 11:42:46 +00:00
|
|
|
typedef char *
|
|
|
|
(*virDrvGetHostname) (virConnectPtr conn);
|
|
|
|
typedef char *
|
|
|
|
(*virDrvGetURI) (virConnectPtr conn);
|
2011-02-07 21:14:56 +00:00
|
|
|
typedef char *
|
|
|
|
(*virDrvGetSysinfo) (virConnectPtr conn,
|
|
|
|
unsigned int flags);
|
2007-03-08 08:31:07 +00:00
|
|
|
typedef int
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvGetMaxVcpus) (virConnectPtr conn,
|
|
|
|
const char *type);
|
2006-03-29 12:46:03 +00:00
|
|
|
typedef int
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvNodeGetInfo) (virConnectPtr conn,
|
|
|
|
virNodeInfoPtr info);
|
2007-03-15 17:24:56 +00:00
|
|
|
typedef char *
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvGetCapabilities) (virConnectPtr conn);
|
2006-03-20 17:49:28 +00:00
|
|
|
typedef int
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvListDomains) (virConnectPtr conn,
|
|
|
|
int *ids,
|
|
|
|
int maxids);
|
2006-03-20 17:49:28 +00:00
|
|
|
typedef int
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvNumOfDomains) (virConnectPtr conn);
|
2006-03-20 17:49:28 +00:00
|
|
|
typedef virDomainPtr
|
2008-10-10 09:32:27 +00:00
|
|
|
(*virDrvDomainCreateXML) (virConnectPtr conn,
|
2008-04-10 16:54:54 +00:00
|
|
|
const char *xmlDesc,
|
|
|
|
unsigned int flags);
|
2006-03-20 17:49:28 +00:00
|
|
|
typedef virDomainPtr
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvDomainLookupByID) (virConnectPtr conn,
|
|
|
|
int id);
|
2006-03-20 17:49:28 +00:00
|
|
|
typedef virDomainPtr
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvDomainLookupByUUID) (virConnectPtr conn,
|
|
|
|
const unsigned char *uuid);
|
2006-03-20 17:49:28 +00:00
|
|
|
typedef virDomainPtr
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvDomainLookupByName) (virConnectPtr conn,
|
|
|
|
const char *name);
|
2006-03-20 17:49:28 +00:00
|
|
|
typedef int
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvDomainSuspend) (virDomainPtr domain);
|
2006-03-20 17:49:28 +00:00
|
|
|
typedef int
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvDomainResume) (virDomainPtr domain);
|
2006-03-20 17:49:28 +00:00
|
|
|
typedef int
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvDomainShutdown) (virDomainPtr domain);
|
2006-04-03 13:46:43 +00:00
|
|
|
typedef int
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvDomainReboot) (virDomainPtr domain,
|
|
|
|
unsigned int flags);
|
2006-03-20 17:49:28 +00:00
|
|
|
typedef int
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvDomainDestroy) (virDomainPtr domain);
|
2006-03-20 17:49:28 +00:00
|
|
|
typedef char *
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvDomainGetOSType) (virDomainPtr domain);
|
2006-03-20 17:49:28 +00:00
|
|
|
typedef unsigned long
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvDomainGetMaxMemory) (virDomainPtr domain);
|
2006-03-20 17:49:28 +00:00
|
|
|
typedef int
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvDomainSetMaxMemory) (virDomainPtr domain,
|
|
|
|
unsigned long memory);
|
2006-04-13 17:18:49 +00:00
|
|
|
typedef int
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvDomainSetMemory) (virDomainPtr domain,
|
|
|
|
unsigned long memory);
|
2011-03-02 08:07:48 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvDomainSetMemoryFlags) (virDomainPtr domain,
|
|
|
|
unsigned long memory,
|
|
|
|
unsigned int flags);
|
2010-10-12 14:03:24 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvDomainSetMemoryParameters)
|
|
|
|
(virDomainPtr domain,
|
|
|
|
virMemoryParameterPtr params,
|
|
|
|
int nparams,
|
|
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
|
|
(*virDrvDomainGetMemoryParameters)
|
|
|
|
(virDomainPtr domain,
|
|
|
|
virMemoryParameterPtr params,
|
|
|
|
int *nparams,
|
|
|
|
unsigned int flags);
|
2011-02-22 05:31:57 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvDomainSetBlkioParameters)
|
|
|
|
(virDomainPtr domain,
|
|
|
|
virBlkioParameterPtr params,
|
|
|
|
int nparams,
|
|
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
|
|
(*virDrvDomainGetBlkioParameters)
|
|
|
|
(virDomainPtr domain,
|
|
|
|
virBlkioParameterPtr params,
|
|
|
|
int *nparams,
|
|
|
|
unsigned int flags);
|
2006-03-20 17:49:28 +00:00
|
|
|
typedef int
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvDomainGetInfo) (virDomainPtr domain,
|
|
|
|
virDomainInfoPtr info);
|
2006-03-20 17:49:28 +00:00
|
|
|
typedef int
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvDomainSave) (virDomainPtr domain,
|
|
|
|
const char *to);
|
2006-03-20 17:49:28 +00:00
|
|
|
typedef int
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvDomainRestore) (virConnectPtr conn,
|
|
|
|
const char *from);
|
2006-11-22 17:48:29 +00:00
|
|
|
typedef int
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvDomainCoreDump) (virDomainPtr domain,
|
|
|
|
const char *to,
|
|
|
|
int flags);
|
2006-08-09 15:21:16 +00:00
|
|
|
typedef char *
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvDomainDumpXML) (virDomainPtr dom,
|
|
|
|
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);
|
2006-08-30 14:21:03 +00:00
|
|
|
typedef int
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvListDefinedDomains) (virConnectPtr conn,
|
|
|
|
char **const names,
|
|
|
|
int maxnames);
|
2006-08-30 14:21:03 +00:00
|
|
|
typedef int
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvNumOfDefinedDomains) (virConnectPtr conn);
|
2006-08-30 14:21:03 +00:00
|
|
|
typedef int
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvDomainCreate) (virDomainPtr dom);
|
2010-06-10 13:28:05 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvDomainCreateWithFlags) (virDomainPtr dom,
|
|
|
|
unsigned int flags);
|
2006-08-30 14:21:03 +00:00
|
|
|
typedef virDomainPtr
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvDomainDefineXML) (virConnectPtr conn,
|
|
|
|
const char *xml);
|
2006-08-30 14:21:03 +00:00
|
|
|
typedef int
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvDomainUndefine) (virDomainPtr dom);
|
2006-08-08 22:22:55 +00:00
|
|
|
typedef int
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvDomainSetVcpus) (virDomainPtr domain,
|
|
|
|
unsigned int nvcpus);
|
2010-09-27 15:18:22 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvDomainSetVcpusFlags) (virDomainPtr domain,
|
|
|
|
unsigned int nvcpus,
|
|
|
|
unsigned int flags);
|
|
|
|
typedef int
|
|
|
|
(*virDrvDomainGetVcpusFlags) (virDomainPtr domain,
|
|
|
|
unsigned int flags);
|
2006-08-08 22:22:55 +00:00
|
|
|
typedef int
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvDomainPinVcpu) (virDomainPtr domain,
|
|
|
|
unsigned int vcpu,
|
|
|
|
unsigned char *cpumap,
|
|
|
|
int maplen);
|
2006-08-08 22:22:55 +00:00
|
|
|
typedef int
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvDomainGetVcpus) (virDomainPtr domain,
|
|
|
|
virVcpuInfoPtr info,
|
|
|
|
int maxinfo,
|
|
|
|
unsigned char *cpumaps,
|
|
|
|
int maplen);
|
2007-03-08 08:31:07 +00:00
|
|
|
typedef int
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvDomainGetMaxVcpus) (virDomainPtr domain);
|
2009-03-03 09:14:28 +00:00
|
|
|
|
|
|
|
typedef int
|
|
|
|
(*virDrvDomainGetSecurityLabel) (virDomainPtr domain,
|
|
|
|
virSecurityLabelPtr seclabel);
|
|
|
|
typedef int
|
|
|
|
(*virDrvNodeGetSecurityModel) (virConnectPtr conn,
|
|
|
|
virSecurityModelPtr secmodel);
|
2006-11-16 18:11:28 +00:00
|
|
|
typedef int
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvDomainAttachDevice) (virDomainPtr domain,
|
|
|
|
const char *xml);
|
2010-01-14 01:31:14 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvDomainAttachDeviceFlags) (virDomainPtr domain,
|
|
|
|
const char *xml,
|
|
|
|
unsigned int flags);
|
2006-11-16 18:11:28 +00:00
|
|
|
typedef int
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvDomainDetachDevice) (virDomainPtr domain,
|
|
|
|
const char *xml);
|
2010-01-14 01:31:14 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvDomainDetachDeviceFlags) (virDomainPtr domain,
|
|
|
|
const char *xml,
|
|
|
|
unsigned int flags);
|
Introduce a new virDomainUpdateDeviceFlags public API
The current virDomainAttachDevice API can be (ab)used to change
the media of an existing CDROM/Floppy device. Going forward there
will be more devices that can be configured on the fly and overloading
virDomainAttachDevice for this is not too pleasant. This patch adds
a new virDomainUpdateDeviceFlags() explicitly just for modifying
existing devices.
* include/libvirt/libvirt.h.in: Add virDomainUpdateDeviceFlags
* src/driver.h: Internal API for virDomainUpdateDeviceFlags
* src/libvirt.c, src/libvirt_public.syms: Glue public API to
driver API
* 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: Add
stubs for new driver entry point
2010-03-22 12:23:41 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvDomainUpdateDeviceFlags) (virDomainPtr domain,
|
|
|
|
const char *xml,
|
|
|
|
unsigned int flags);
|
2007-02-23 08:51:30 +00:00
|
|
|
typedef int
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvDomainGetAutostart) (virDomainPtr domain,
|
|
|
|
int *autostart);
|
2007-02-23 08:51:30 +00:00
|
|
|
typedef int
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvDomainSetAutostart) (virDomainPtr domain,
|
|
|
|
int autostart);
|
2006-08-08 22:22:55 +00:00
|
|
|
|
2007-06-05 12:06:08 +00:00
|
|
|
typedef char *
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvDomainGetSchedulerType) (virDomainPtr domain,
|
|
|
|
int *nparams);
|
2007-06-05 12:06:08 +00:00
|
|
|
|
2008-02-05 19:27:37 +00:00
|
|
|
typedef int
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvDomainGetSchedulerParameters)
|
|
|
|
(virDomainPtr domain,
|
|
|
|
virSchedParameterPtr params,
|
|
|
|
int *nparams);
|
2007-06-05 12:06:08 +00:00
|
|
|
|
|
|
|
typedef int
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvDomainSetSchedulerParameters)
|
|
|
|
(virDomainPtr domain,
|
|
|
|
virSchedParameterPtr params,
|
|
|
|
int nparams);
|
2007-06-05 12:06:08 +00:00
|
|
|
|
2007-08-21 10:08:12 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvDomainBlockStats)
|
|
|
|
(virDomainPtr domain,
|
|
|
|
const char *path,
|
|
|
|
struct _virDomainBlockStats *stats);
|
|
|
|
typedef int
|
|
|
|
(*virDrvDomainInterfaceStats)
|
|
|
|
(virDomainPtr domain,
|
|
|
|
const char *path,
|
|
|
|
struct _virDomainInterfaceStats *stats);
|
|
|
|
|
2009-12-20 12:28:42 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvDomainMemoryStats)
|
|
|
|
(virDomainPtr domain,
|
|
|
|
struct _virDomainMemoryStat *stats,
|
|
|
|
unsigned int nr_stats);
|
|
|
|
|
virDomainBlockPeek call
* configure.in: Document AC_SYS_LARGEFILE.
* docs/hvsupport.html.in: Document HV support for virDomainBlockPeek.
* include/libvirt/libvirt.h.in, src/driver.h, src/libvirt.c,
src/libvirt_sym.version: Add virDomainBlockPeek infrastructure.
* src/qemu_driver.c, src/test.c: Null versions of this call.
* src/xen_unified.c, src/xend_internal.c, src/xend_internal.h,
src/xm_internal.c, src/xm_internal.h: Xen implementation.
* tests/sexpr2xmldata/sexpr2xml-curmem.xml,
tests/sexpr2xmldata/sexpr2xml-no-source-cdrom.xml: XML output
has been reordered slightly in the Xen driver, but should be
functionally the same.
2008-06-05 13:17:45 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvDomainBlockPeek)
|
|
|
|
(virDomainPtr domain,
|
|
|
|
const char *path,
|
|
|
|
unsigned long long offset, size_t size,
|
2008-06-05 21:12:26 +00:00
|
|
|
void *buffer,
|
|
|
|
unsigned int flags);
|
virDomainBlockPeek call
* configure.in: Document AC_SYS_LARGEFILE.
* docs/hvsupport.html.in: Document HV support for virDomainBlockPeek.
* include/libvirt/libvirt.h.in, src/driver.h, src/libvirt.c,
src/libvirt_sym.version: Add virDomainBlockPeek infrastructure.
* src/qemu_driver.c, src/test.c: Null versions of this call.
* src/xen_unified.c, src/xend_internal.c, src/xend_internal.h,
src/xm_internal.c, src/xm_internal.h: Xen implementation.
* tests/sexpr2xmldata/sexpr2xml-curmem.xml,
tests/sexpr2xmldata/sexpr2xml-no-source-cdrom.xml: XML output
has been reordered slightly in the Xen driver, but should be
functionally the same.
2008-06-05 13:17:45 +00:00
|
|
|
|
2008-06-10 10:43:28 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvDomainMemoryPeek)
|
|
|
|
(virDomainPtr domain,
|
|
|
|
unsigned long long start, size_t size,
|
|
|
|
void *buffer,
|
|
|
|
unsigned int flags);
|
Internal driver API infrastructure for virDomainGetBlockInfo
This defines the internal driver API and stubs out each driver
* src/driver.h: Define virDrvDomainGetBlockInfo signature
* src/libvirt.c, src/libvirt_public.syms: Glue public API to drivers
* 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/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 driver
2010-04-27 19:27:34 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvDomainGetBlockInfo)
|
|
|
|
(virDomainPtr domain,
|
|
|
|
const char *path,
|
|
|
|
virDomainBlockInfoPtr info,
|
|
|
|
unsigned int flags);
|
2008-06-10 10:43:28 +00:00
|
|
|
|
2007-08-21 09:31:12 +00:00
|
|
|
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);
|
|
|
|
|
2006-03-20 17:49:28 +00:00
|
|
|
typedef struct _virDriver virDriver;
|
|
|
|
typedef virDriver *virDriverPtr;
|
|
|
|
|
2007-09-28 14:28:12 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvNodeGetCellsFreeMemory)
|
|
|
|
(virConnectPtr conn,
|
|
|
|
unsigned long long *freeMems,
|
|
|
|
int startCell,
|
|
|
|
int maxCells);
|
|
|
|
|
2007-09-30 13:09:07 +00:00
|
|
|
typedef unsigned long long
|
|
|
|
(*virDrvNodeGetFreeMemory)
|
2008-04-10 16:54:54 +00:00
|
|
|
(virConnectPtr conn);
|
2007-09-30 13:09:07 +00:00
|
|
|
|
2008-10-23 13:18:18 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvDomainEventRegister)
|
|
|
|
(virConnectPtr conn,
|
2008-12-17 21:48:20 +00:00
|
|
|
virConnectDomainEventCallback cb,
|
2008-11-19 15:25:24 +00:00
|
|
|
void *opaque,
|
|
|
|
virFreeCallback freecb);
|
2008-10-23 13:18:18 +00:00
|
|
|
|
|
|
|
typedef int
|
|
|
|
(*virDrvDomainEventDeregister)
|
|
|
|
(virConnectPtr conn,
|
2008-12-17 21:48:20 +00:00
|
|
|
virConnectDomainEventCallback cb);
|
2008-10-23 13:18:18 +00:00
|
|
|
|
2008-11-14 08:42:47 +00:00
|
|
|
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);
|
|
|
|
|
2009-03-02 16:25:13 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvNodeDeviceDettach)
|
|
|
|
(virNodeDevicePtr dev);
|
|
|
|
typedef int
|
|
|
|
(*virDrvNodeDeviceReAttach)
|
|
|
|
(virNodeDevicePtr dev);
|
|
|
|
typedef int
|
|
|
|
(*virDrvNodeDeviceReset)
|
|
|
|
(virNodeDevicePtr dev);
|
|
|
|
|
2009-09-30 10:51:54 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvDomainMigratePrepareTunnel)
|
|
|
|
(virConnectPtr conn,
|
|
|
|
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
|
|
|
|
(*virDrvDomainIsActive)(virDomainPtr dom);
|
|
|
|
typedef int
|
|
|
|
(*virDrvDomainIsPersistent)(virDomainPtr dom);
|
2010-11-15 03:23:33 +00:00
|
|
|
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
|
|
|
|
2009-12-18 13:59:39 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvCPUCompare)(virConnectPtr conn,
|
|
|
|
const char *cpu,
|
|
|
|
unsigned int flags);
|
2010-02-02 11:34:01 +00:00
|
|
|
typedef char *
|
|
|
|
(*virDrvCPUBaseline)(virConnectPtr conn,
|
|
|
|
const char **xmlCPUs,
|
|
|
|
unsigned int ncpus,
|
|
|
|
unsigned int flags);
|
2009-12-18 13:59:39 +00:00
|
|
|
|
Stub out internal driver entry points for job processing
The internal glue layer for the new pubic API
* src/driver.h: Define internal driver API contract
* src/libvirt.c, src/libvirt_public.syms: Wire up public
API to internal driver API
* 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: Stub new entry point
2010-02-03 11:32:24 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvDomainGetJobInfo)(virDomainPtr domain,
|
|
|
|
virDomainJobInfoPtr info);
|
|
|
|
|
Wire up internal entry points for virDomainAbortJob API
This provides the internal glue for the driver API
* src/driver.h: Internal API contract
* src/libvirt.c, src/libvirt_public.syms: Connect public API
to driver API
* 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: Stub out entry points
2010-02-04 16:16:35 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvDomainAbortJob)(virDomainPtr domain);
|
|
|
|
|
2010-03-12 13:55:08 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvDomainMigrateSetMaxDowntime)(virDomainPtr domain,
|
|
|
|
unsigned long long downtime,
|
|
|
|
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);
|
|
|
|
|
2010-04-01 08:46:28 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvDomainManagedSave)(virDomainPtr domain, unsigned int flags);
|
|
|
|
|
|
|
|
typedef int
|
|
|
|
(*virDrvDomainHasManagedSaveImage)(virDomainPtr domain, unsigned int flags);
|
|
|
|
|
|
|
|
typedef int
|
|
|
|
(*virDrvDomainManagedSaveRemove)(virDomainPtr domain, unsigned int flags);
|
|
|
|
|
2010-03-31 20:33:13 +00:00
|
|
|
typedef virDomainSnapshotPtr
|
|
|
|
(*virDrvDomainSnapshotCreateXML)(virDomainPtr domain,
|
|
|
|
const char *xmlDesc,
|
|
|
|
unsigned int flags);
|
|
|
|
|
|
|
|
typedef char *
|
|
|
|
(*virDrvDomainSnapshotDumpXML)(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 virDomainSnapshotPtr
|
|
|
|
(*virDrvDomainSnapshotLookupByName)(virDomainPtr domain,
|
|
|
|
const char *name,
|
|
|
|
unsigned int flags);
|
|
|
|
|
|
|
|
typedef int
|
|
|
|
(*virDrvDomainHasCurrentSnapshot)(virDomainPtr domain, unsigned int flags);
|
|
|
|
|
|
|
|
typedef virDomainSnapshotPtr
|
|
|
|
(*virDrvDomainSnapshotCurrent)(virDomainPtr domain,
|
|
|
|
unsigned int flags);
|
|
|
|
|
|
|
|
typedef int
|
|
|
|
(*virDrvDomainRevertToSnapshot)(virDomainSnapshotPtr snapshot,
|
|
|
|
unsigned int flags);
|
|
|
|
|
|
|
|
typedef int
|
|
|
|
(*virDrvDomainSnapshotDelete)(virDomainSnapshotPtr snapshot,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2010-04-13 18:02:46 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvQemuDomainMonitorCommand)(virDomainPtr domain, const char *cmd,
|
|
|
|
char **result, unsigned int flags);
|
|
|
|
|
Introduce a virDomainOpenConsole API
To enable virsh console (or equivalent) to be used remotely
it is necessary to provide remote access to the /dev/pts/XXX
pseudo-TTY associated with the console/serial/parallel device
in the guest. The virStream API provide a bi-directional I/O
stream capability that can be used for this purpose. This
patch thus introduces a virDomainOpenConsole API that uses
the stream APIs.
* src/libvirt.c, src/libvirt_public.syms,
include/libvirt/libvirt.h.in, src/driver.h: Define the
new virDomainOpenConsole API
* 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
API entry point
2010-07-23 12:34:31 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvDomainOpenConsole)(virDomainPtr dom,
|
|
|
|
const char *devname,
|
|
|
|
virStreamPtr st,
|
|
|
|
unsigned int flags);
|
2010-04-13 18:02:46 +00:00
|
|
|
|
2010-03-31 20:33:13 +00:00
|
|
|
|
2006-03-20 17:49:28 +00:00
|
|
|
/**
|
|
|
|
* _virDriver:
|
|
|
|
*
|
|
|
|
* Structure associated to a virtualization driver, defining the various
|
|
|
|
* entry points for it.
|
2007-04-04 14:19:49 +00:00
|
|
|
*
|
|
|
|
* All drivers must support the following fields/methods:
|
|
|
|
* - no
|
|
|
|
* - name
|
|
|
|
* - open
|
|
|
|
* - close
|
2006-03-20 17:49:28 +00:00
|
|
|
*/
|
|
|
|
struct _virDriver {
|
2010-06-10 13:28:05 +00:00
|
|
|
int no; /* the number virDrvNo */
|
2008-02-26 07:05:18 +00:00
|
|
|
const char * name; /* the name of the driver */
|
|
|
|
virDrvOpen open;
|
|
|
|
virDrvClose close;
|
2008-11-17 11:03:25 +00:00
|
|
|
virDrvDrvSupportsFeature supports_feature;
|
2008-02-26 07:05:18 +00:00
|
|
|
virDrvGetType type;
|
|
|
|
virDrvGetVersion version;
|
2009-11-12 15:53:26 +00:00
|
|
|
virDrvGetLibVersion libvirtVersion;
|
2007-06-26 11:42:46 +00:00
|
|
|
virDrvGetHostname getHostname;
|
2011-02-07 21:14:56 +00:00
|
|
|
virDrvGetSysinfo getSysinfo;
|
2008-02-26 07:05:18 +00:00
|
|
|
virDrvGetMaxVcpus getMaxVcpus;
|
|
|
|
virDrvNodeGetInfo nodeGetInfo;
|
|
|
|
virDrvGetCapabilities getCapabilities;
|
|
|
|
virDrvListDomains listDomains;
|
|
|
|
virDrvNumOfDomains numOfDomains;
|
2008-10-10 09:32:27 +00:00
|
|
|
virDrvDomainCreateXML domainCreateXML;
|
2008-02-26 07:05:18 +00:00
|
|
|
virDrvDomainLookupByID domainLookupByID;
|
|
|
|
virDrvDomainLookupByUUID domainLookupByUUID;
|
|
|
|
virDrvDomainLookupByName domainLookupByName;
|
|
|
|
virDrvDomainSuspend domainSuspend;
|
|
|
|
virDrvDomainResume domainResume;
|
|
|
|
virDrvDomainShutdown domainShutdown;
|
|
|
|
virDrvDomainReboot domainReboot;
|
|
|
|
virDrvDomainDestroy domainDestroy;
|
|
|
|
virDrvDomainGetOSType domainGetOSType;
|
|
|
|
virDrvDomainGetMaxMemory domainGetMaxMemory;
|
|
|
|
virDrvDomainSetMaxMemory domainSetMaxMemory;
|
|
|
|
virDrvDomainSetMemory domainSetMemory;
|
2011-03-02 08:07:48 +00:00
|
|
|
virDrvDomainSetMemoryFlags domainSetMemoryFlags;
|
2011-02-22 05:31:57 +00:00
|
|
|
virDrvDomainSetMemoryParameters domainSetMemoryParameters;
|
|
|
|
virDrvDomainGetMemoryParameters domainGetMemoryParameters;
|
|
|
|
virDrvDomainSetBlkioParameters domainSetBlkioParameters;
|
|
|
|
virDrvDomainGetBlkioParameters domainGetBlkioParameters;
|
2008-02-26 07:05:18 +00:00
|
|
|
virDrvDomainGetInfo domainGetInfo;
|
|
|
|
virDrvDomainSave domainSave;
|
|
|
|
virDrvDomainRestore domainRestore;
|
|
|
|
virDrvDomainCoreDump domainCoreDump;
|
|
|
|
virDrvDomainSetVcpus domainSetVcpus;
|
2010-09-27 15:18:22 +00:00
|
|
|
virDrvDomainSetVcpusFlags domainSetVcpusFlags;
|
|
|
|
virDrvDomainGetVcpusFlags domainGetVcpusFlags;
|
2008-02-26 07:05:18 +00:00
|
|
|
virDrvDomainPinVcpu domainPinVcpu;
|
|
|
|
virDrvDomainGetVcpus domainGetVcpus;
|
|
|
|
virDrvDomainGetMaxVcpus domainGetMaxVcpus;
|
2009-03-03 09:14:28 +00:00
|
|
|
virDrvDomainGetSecurityLabel domainGetSecurityLabel;
|
|
|
|
virDrvNodeGetSecurityModel nodeGetSecurityModel;
|
2008-02-26 07:05:18 +00:00
|
|
|
virDrvDomainDumpXML domainDumpXML;
|
2009-05-21 13:46:35 +00:00
|
|
|
virDrvConnectDomainXMLFromNative domainXMLFromNative;
|
|
|
|
virDrvConnectDomainXMLToNative domainXMLToNative;
|
2008-02-26 07:05:18 +00:00
|
|
|
virDrvListDefinedDomains listDefinedDomains;
|
|
|
|
virDrvNumOfDefinedDomains numOfDefinedDomains;
|
|
|
|
virDrvDomainCreate domainCreate;
|
2010-06-10 13:28:05 +00:00
|
|
|
virDrvDomainCreateWithFlags domainCreateWithFlags;
|
2008-02-26 07:05:18 +00:00
|
|
|
virDrvDomainDefineXML domainDefineXML;
|
|
|
|
virDrvDomainUndefine domainUndefine;
|
|
|
|
virDrvDomainAttachDevice domainAttachDevice;
|
2010-01-14 01:31:14 +00:00
|
|
|
virDrvDomainAttachDeviceFlags domainAttachDeviceFlags;
|
2008-02-26 07:05:18 +00:00
|
|
|
virDrvDomainDetachDevice domainDetachDevice;
|
2010-01-14 01:31:14 +00:00
|
|
|
virDrvDomainDetachDeviceFlags domainDetachDeviceFlags;
|
Introduce a new virDomainUpdateDeviceFlags public API
The current virDomainAttachDevice API can be (ab)used to change
the media of an existing CDROM/Floppy device. Going forward there
will be more devices that can be configured on the fly and overloading
virDomainAttachDevice for this is not too pleasant. This patch adds
a new virDomainUpdateDeviceFlags() explicitly just for modifying
existing devices.
* include/libvirt/libvirt.h.in: Add virDomainUpdateDeviceFlags
* src/driver.h: Internal API for virDomainUpdateDeviceFlags
* src/libvirt.c, src/libvirt_public.syms: Glue public API to
driver API
* 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: Add
stubs for new driver entry point
2010-03-22 12:23:41 +00:00
|
|
|
virDrvDomainUpdateDeviceFlags domainUpdateDeviceFlags;
|
2008-02-26 07:05:18 +00:00
|
|
|
virDrvDomainGetAutostart domainGetAutostart;
|
|
|
|
virDrvDomainSetAutostart domainSetAutostart;
|
|
|
|
virDrvDomainGetSchedulerType domainGetSchedulerType;
|
|
|
|
virDrvDomainGetSchedulerParameters domainGetSchedulerParameters;
|
|
|
|
virDrvDomainSetSchedulerParameters domainSetSchedulerParameters;
|
2007-08-21 09:31:12 +00:00
|
|
|
virDrvDomainMigratePrepare domainMigratePrepare;
|
|
|
|
virDrvDomainMigratePerform domainMigratePerform;
|
|
|
|
virDrvDomainMigrateFinish domainMigrateFinish;
|
2007-08-21 10:08:12 +00:00
|
|
|
virDrvDomainBlockStats domainBlockStats;
|
|
|
|
virDrvDomainInterfaceStats domainInterfaceStats;
|
2009-12-20 12:28:42 +00:00
|
|
|
virDrvDomainMemoryStats domainMemoryStats;
|
virDomainBlockPeek call
* configure.in: Document AC_SYS_LARGEFILE.
* docs/hvsupport.html.in: Document HV support for virDomainBlockPeek.
* include/libvirt/libvirt.h.in, src/driver.h, src/libvirt.c,
src/libvirt_sym.version: Add virDomainBlockPeek infrastructure.
* src/qemu_driver.c, src/test.c: Null versions of this call.
* src/xen_unified.c, src/xend_internal.c, src/xend_internal.h,
src/xm_internal.c, src/xm_internal.h: Xen implementation.
* tests/sexpr2xmldata/sexpr2xml-curmem.xml,
tests/sexpr2xmldata/sexpr2xml-no-source-cdrom.xml: XML output
has been reordered slightly in the Xen driver, but should be
functionally the same.
2008-06-05 13:17:45 +00:00
|
|
|
virDrvDomainBlockPeek domainBlockPeek;
|
2008-06-10 10:43:28 +00:00
|
|
|
virDrvDomainMemoryPeek domainMemoryPeek;
|
Internal driver API infrastructure for virDomainGetBlockInfo
This defines the internal driver API and stubs out each driver
* src/driver.h: Define virDrvDomainGetBlockInfo signature
* src/libvirt.c, src/libvirt_public.syms: Glue public API to drivers
* 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/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 driver
2010-04-27 19:27:34 +00:00
|
|
|
virDrvDomainGetBlockInfo domainGetBlockInfo;
|
2008-02-26 07:05:18 +00:00
|
|
|
virDrvNodeGetCellsFreeMemory nodeGetCellsFreeMemory;
|
|
|
|
virDrvNodeGetFreeMemory getFreeMemory;
|
2008-10-23 13:18:18 +00:00
|
|
|
virDrvDomainEventRegister domainEventRegister;
|
|
|
|
virDrvDomainEventDeregister domainEventDeregister;
|
2008-11-14 08:42:47 +00:00
|
|
|
virDrvDomainMigratePrepare2 domainMigratePrepare2;
|
|
|
|
virDrvDomainMigrateFinish2 domainMigrateFinish2;
|
2009-03-02 16:25:13 +00:00
|
|
|
virDrvNodeDeviceDettach nodeDeviceDettach;
|
|
|
|
virDrvNodeDeviceReAttach nodeDeviceReAttach;
|
|
|
|
virDrvNodeDeviceReset nodeDeviceReset;
|
2009-09-30 10:51:54 +00:00
|
|
|
virDrvDomainMigratePrepareTunnel domainMigratePrepareTunnel;
|
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
|
|
|
virDrvConnectIsEncrypted isEncrypted;
|
|
|
|
virDrvConnectIsSecure isSecure;
|
|
|
|
virDrvDomainIsActive domainIsActive;
|
|
|
|
virDrvDomainIsPersistent domainIsPersistent;
|
2010-11-15 03:23:33 +00:00
|
|
|
virDrvDomainIsUpdated domainIsUpdated;
|
2009-12-18 13:59:39 +00:00
|
|
|
virDrvCPUCompare cpuCompare;
|
2010-02-02 11:34:01 +00:00
|
|
|
virDrvCPUBaseline cpuBaseline;
|
Stub out internal driver entry points for job processing
The internal glue layer for the new pubic API
* src/driver.h: Define internal driver API contract
* src/libvirt.c, src/libvirt_public.syms: Wire up public
API to internal driver API
* 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: Stub new entry point
2010-02-03 11:32:24 +00:00
|
|
|
virDrvDomainGetJobInfo domainGetJobInfo;
|
Wire up internal entry points for virDomainAbortJob API
This provides the internal glue for the driver API
* src/driver.h: Internal API contract
* src/libvirt.c, src/libvirt_public.syms: Connect public API
to driver API
* 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: Stub out entry points
2010-02-04 16:16:35 +00:00
|
|
|
virDrvDomainAbortJob domainAbortJob;
|
2010-03-12 13:55:08 +00:00
|
|
|
virDrvDomainMigrateSetMaxDowntime domainMigrateSetMaxDowntime;
|
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
|
|
|
virDrvDomainEventRegisterAny domainEventRegisterAny;
|
|
|
|
virDrvDomainEventDeregisterAny domainEventDeregisterAny;
|
2010-04-01 08:46:28 +00:00
|
|
|
virDrvDomainManagedSave domainManagedSave;
|
|
|
|
virDrvDomainHasManagedSaveImage domainHasManagedSaveImage;
|
|
|
|
virDrvDomainManagedSaveRemove domainManagedSaveRemove;
|
2010-03-31 20:33:13 +00:00
|
|
|
virDrvDomainSnapshotCreateXML domainSnapshotCreateXML;
|
|
|
|
virDrvDomainSnapshotDumpXML domainSnapshotDumpXML;
|
|
|
|
virDrvDomainSnapshotNum domainSnapshotNum;
|
|
|
|
virDrvDomainSnapshotListNames domainSnapshotListNames;
|
|
|
|
virDrvDomainSnapshotLookupByName domainSnapshotLookupByName;
|
|
|
|
virDrvDomainHasCurrentSnapshot domainHasCurrentSnapshot;
|
|
|
|
virDrvDomainSnapshotCurrent domainSnapshotCurrent;
|
|
|
|
virDrvDomainRevertToSnapshot domainRevertToSnapshot;
|
|
|
|
virDrvDomainSnapshotDelete domainSnapshotDelete;
|
2010-04-13 18:02:46 +00:00
|
|
|
virDrvQemuDomainMonitorCommand qemuDomainMonitorCommand;
|
Introduce a virDomainOpenConsole API
To enable virsh console (or equivalent) to be used remotely
it is necessary to provide remote access to the /dev/pts/XXX
pseudo-TTY associated with the console/serial/parallel device
in the guest. The virStream API provide a bi-directional I/O
stream capability that can be used for this purpose. This
patch thus introduces a virDomainOpenConsole API that uses
the stream APIs.
* src/libvirt.c, src/libvirt_public.syms,
include/libvirt/libvirt.h.in, src/driver.h: Define the
new virDomainOpenConsole API
* 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
API entry point
2010-07-23 12:34:31 +00:00
|
|
|
virDrvDomainOpenConsole domainOpenConsole;
|
2006-03-20 17:49:28 +00:00
|
|
|
};
|
|
|
|
|
2007-02-14 15:37:18 +00:00
|
|
|
typedef int
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvNumOfNetworks) (virConnectPtr conn);
|
2007-02-14 15:37:18 +00:00
|
|
|
typedef int
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvListNetworks) (virConnectPtr conn,
|
|
|
|
char **const names,
|
|
|
|
int maxnames);
|
2007-02-14 15:37:18 +00:00
|
|
|
typedef int
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvNumOfDefinedNetworks) (virConnectPtr conn);
|
2007-02-14 15:37:18 +00:00
|
|
|
typedef int
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvListDefinedNetworks) (virConnectPtr conn,
|
|
|
|
char **const names,
|
|
|
|
int maxnames);
|
2007-02-14 15:37:18 +00:00
|
|
|
typedef virNetworkPtr
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvNetworkLookupByUUID) (virConnectPtr conn,
|
|
|
|
const unsigned char *uuid);
|
2007-02-14 15:37:18 +00:00
|
|
|
typedef virNetworkPtr
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvNetworkLookupByName) (virConnectPtr conn,
|
|
|
|
const char *name);
|
2007-02-14 15:37:18 +00:00
|
|
|
typedef virNetworkPtr
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvNetworkCreateXML) (virConnectPtr conn,
|
|
|
|
const char *xmlDesc);
|
2007-02-14 15:37:18 +00:00
|
|
|
typedef virNetworkPtr
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvNetworkDefineXML) (virConnectPtr conn,
|
|
|
|
const char *xml);
|
2007-02-14 15:37:18 +00:00
|
|
|
typedef int
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvNetworkUndefine) (virNetworkPtr network);
|
2007-02-14 15:37:18 +00:00
|
|
|
typedef int
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvNetworkCreate) (virNetworkPtr network);
|
2007-02-14 15:37:18 +00:00
|
|
|
typedef int
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvNetworkDestroy) (virNetworkPtr network);
|
2007-02-14 15:37:18 +00:00
|
|
|
typedef char *
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvNetworkDumpXML) (virNetworkPtr network,
|
|
|
|
int flags);
|
2007-02-14 16:20:38 +00:00
|
|
|
typedef char *
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvNetworkGetBridgeName) (virNetworkPtr network);
|
2007-02-23 08:51:30 +00:00
|
|
|
typedef int
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvNetworkGetAutostart) (virNetworkPtr network,
|
|
|
|
int *autostart);
|
2007-02-23 08:51:30 +00:00
|
|
|
typedef int
|
2008-04-10 16:54:54 +00:00
|
|
|
(*virDrvNetworkSetAutostart) (virNetworkPtr network,
|
|
|
|
int autostart);
|
2007-02-23 08:51:30 +00:00
|
|
|
|
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);
|
|
|
|
typedef int
|
|
|
|
(*virDrvNetworkIsPersistent)(virNetworkPtr net);
|
|
|
|
|
|
|
|
|
2007-02-14 15:37:18 +00:00
|
|
|
|
|
|
|
typedef struct _virNetworkDriver virNetworkDriver;
|
|
|
|
typedef virNetworkDriver *virNetworkDriverPtr;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* _virNetworkDriver:
|
|
|
|
*
|
|
|
|
* Structure associated to a network virtualization driver, defining the various
|
|
|
|
* entry points for it.
|
2007-04-04 14:19:49 +00:00
|
|
|
*
|
|
|
|
* All drivers must support the following fields/methods:
|
|
|
|
* - open
|
|
|
|
* - close
|
2007-02-14 15:37:18 +00:00
|
|
|
*/
|
|
|
|
struct _virNetworkDriver {
|
2008-04-10 16:54:54 +00:00
|
|
|
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;
|
|
|
|
virDrvNetworkDumpXML networkDumpXML;
|
|
|
|
virDrvNetworkGetBridgeName networkGetBridgeName;
|
|
|
|
virDrvNetworkGetAutostart networkGetAutostart;
|
|
|
|
virDrvNetworkSetAutostart networkSetAutostart;
|
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
|
|
|
virDrvNetworkIsActive networkIsActive;
|
|
|
|
virDrvNetworkIsPersistent networkIsPersistent;
|
2007-02-14 15:37:18 +00:00
|
|
|
};
|
|
|
|
|
2009-05-20 14:26:49 +00:00
|
|
|
/*-------*/
|
|
|
|
typedef int
|
|
|
|
(*virDrvNumOfInterfaces) (virConnectPtr conn);
|
|
|
|
typedef int
|
|
|
|
(*virDrvListInterfaces) (virConnectPtr conn,
|
|
|
|
char **const names,
|
|
|
|
int maxnames);
|
2009-07-16 15:58:15 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvNumOfDefinedInterfaces) (virConnectPtr conn);
|
|
|
|
typedef int
|
|
|
|
(*virDrvListDefinedInterfaces) (virConnectPtr conn,
|
|
|
|
char **const names,
|
|
|
|
int maxnames);
|
2009-05-20 14:26:49 +00:00
|
|
|
typedef virInterfacePtr
|
|
|
|
(*virDrvInterfaceLookupByName) (virConnectPtr conn,
|
|
|
|
const char *name);
|
|
|
|
typedef virInterfacePtr
|
|
|
|
(*virDrvInterfaceLookupByMACString) (virConnectPtr conn,
|
|
|
|
const char *mac);
|
|
|
|
|
|
|
|
typedef char *
|
2009-05-29 14:29:22 +00:00
|
|
|
(*virDrvInterfaceGetXMLDesc) (virInterfacePtr iface,
|
2009-05-20 14:26:49 +00:00
|
|
|
unsigned int flags);
|
|
|
|
|
|
|
|
typedef virInterfacePtr
|
|
|
|
(*virDrvInterfaceDefineXML) (virConnectPtr conn,
|
|
|
|
const char *xmlDesc,
|
|
|
|
unsigned int flags);
|
|
|
|
typedef int
|
2009-05-29 14:29:22 +00:00
|
|
|
(*virDrvInterfaceUndefine) (virInterfacePtr iface);
|
2009-05-20 14:26:49 +00:00
|
|
|
typedef int
|
2009-05-29 14:29:22 +00:00
|
|
|
(*virDrvInterfaceCreate) (virInterfacePtr iface,
|
2009-05-20 14:26:49 +00:00
|
|
|
unsigned int flags);
|
|
|
|
typedef int
|
2009-05-29 14:29:22 +00:00
|
|
|
(*virDrvInterfaceDestroy) (virInterfacePtr iface,
|
2009-05-20 14:26:49 +00:00
|
|
|
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);
|
|
|
|
|
|
|
|
|
2009-05-20 14:26:49 +00:00
|
|
|
typedef struct _virInterfaceDriver virInterfaceDriver;
|
|
|
|
typedef virInterfaceDriver *virInterfaceDriverPtr;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* _virInterfaceDriver:
|
|
|
|
*
|
|
|
|
* 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 _virInterfaceDriver {
|
|
|
|
const char *name; /* the name of the driver */
|
|
|
|
virDrvOpen open;
|
|
|
|
virDrvClose close;
|
|
|
|
virDrvNumOfInterfaces numOfInterfaces;
|
|
|
|
virDrvListInterfaces listInterfaces;
|
2009-07-16 15:58:15 +00:00
|
|
|
virDrvNumOfDefinedInterfaces numOfDefinedInterfaces;
|
|
|
|
virDrvListDefinedInterfaces listDefinedInterfaces;
|
2009-05-20 14:26:49 +00:00
|
|
|
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;
|
2009-05-20 14:26:49 +00:00
|
|
|
};
|
|
|
|
|
2008-02-20 15:06:53 +00:00
|
|
|
|
|
|
|
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);
|
2008-08-27 20:05:58 +00:00
|
|
|
typedef char *
|
|
|
|
(*virDrvConnectFindStoragePoolSources) (virConnectPtr conn,
|
|
|
|
const char *type,
|
|
|
|
const char *srcSpec,
|
|
|
|
unsigned int flags);
|
2008-02-20 15:06:53 +00:00
|
|
|
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);
|
|
|
|
|
2010-03-01 20:15:16 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvStorageVolWipe) (virStorageVolPtr vol,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2008-02-20 15:06:53 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvStorageVolGetInfo) (virStorageVolPtr vol,
|
|
|
|
virStorageVolInfoPtr info);
|
|
|
|
typedef char *
|
|
|
|
(*virDrvStorageVolGetXMLDesc) (virStorageVolPtr pool,
|
|
|
|
unsigned int flags);
|
|
|
|
typedef char *
|
|
|
|
(*virDrvStorageVolGetPath) (virStorageVolPtr vol);
|
|
|
|
|
2009-05-12 20:10:50 +00:00
|
|
|
typedef virStorageVolPtr
|
|
|
|
(*virDrvStorageVolCreateXMLFrom) (virStoragePoolPtr pool,
|
|
|
|
const char *xmldesc,
|
|
|
|
virStorageVolPtr clone,
|
|
|
|
unsigned int flags);
|
2008-02-20 15:06:53 +00:00
|
|
|
|
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);
|
|
|
|
|
|
|
|
|
2008-02-20 15:06:53 +00:00
|
|
|
|
|
|
|
typedef struct _virStorageDriver virStorageDriver;
|
|
|
|
typedef virStorageDriver *virStorageDriverPtr;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* _virStorageDriver:
|
|
|
|
*
|
|
|
|
* 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 _virStorageDriver {
|
|
|
|
const char * name; /* the name of the driver */
|
|
|
|
virDrvOpen open;
|
|
|
|
virDrvClose close;
|
|
|
|
|
|
|
|
virDrvConnectNumOfStoragePools numOfPools;
|
|
|
|
virDrvConnectListStoragePools listPools;
|
|
|
|
virDrvConnectNumOfDefinedStoragePools numOfDefinedPools;
|
|
|
|
virDrvConnectListDefinedStoragePools listDefinedPools;
|
2008-08-27 20:05:58 +00:00
|
|
|
virDrvConnectFindStoragePoolSources findPoolSources;
|
2008-02-20 15:06:53 +00:00
|
|
|
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;
|
2009-05-12 20:10:50 +00:00
|
|
|
virDrvStorageVolCreateXMLFrom volCreateXMLFrom;
|
2008-02-20 15:06:53 +00:00
|
|
|
virDrvStorageVolDelete volDelete;
|
2010-03-01 20:15:16 +00:00
|
|
|
virDrvStorageVolWipe volWipe;
|
2008-02-20 15:06:53 +00:00
|
|
|
virDrvStorageVolGetInfo volGetInfo;
|
|
|
|
virDrvStorageVolGetXMLDesc volGetXMLDesc;
|
|
|
|
virDrvStorageVolGetPath volGetPath;
|
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
|
|
|
virDrvStoragePoolIsActive poolIsActive;
|
|
|
|
virDrvStoragePoolIsPersistent poolIsPersistent;
|
2008-02-20 15:06:53 +00:00
|
|
|
};
|
|
|
|
|
2010-03-09 18:22:22 +00:00
|
|
|
# ifdef WITH_LIBVIRTD
|
2009-06-12 13:20:13 +00:00
|
|
|
typedef int (*virDrvStateInitialize) (int privileged);
|
2007-06-26 22:56:14 +00:00
|
|
|
typedef int (*virDrvStateCleanup) (void);
|
|
|
|
typedef int (*virDrvStateReload) (void);
|
|
|
|
typedef int (*virDrvStateActive) (void);
|
|
|
|
|
|
|
|
typedef struct _virStateDriver virStateDriver;
|
|
|
|
typedef virStateDriver *virStateDriverPtr;
|
|
|
|
|
|
|
|
struct _virStateDriver {
|
Fix return value in virStateInitialize impl for LXC
The LXC driver was mistakenly returning -1 for lxcStartup()
in scenarios that are not an error. This caused the libvirtd
to quit for unprivileged users. This fixes the return code
of LXC driver, and also adds a "name" field to the virStateDriver
struct and logging to make it easier to find these problems
in the future
* src/driver.h: Add a 'name' field to state driver to allow
easy identification during failures
* src/libvirt.c: Log name of failed driver for virStateInit
failures
* src/lxc/lxc_driver.c: Don't return a failure code for
lxcStartup() if LXC is not available on this host, simply
disable the driver.
* src/network/bridge_driver.c, src/node_device/node_device_devkit.c,
src/node_device/node_device_hal.c, src/opennebula/one_driver.c,
src/qemu/qemu_driver.c, src/remote/remote_driver.c,
src/secret/secret_driver.c, src/storage/storage_driver.c,
src/uml/uml_driver.c, src/xen/xen_driver.c: Fill in name
field in virStateDriver struct
2009-11-02 23:18:19 +00:00
|
|
|
const char *name;
|
2007-06-26 22:56:14 +00:00
|
|
|
virDrvStateInitialize initialize;
|
|
|
|
virDrvStateCleanup cleanup;
|
|
|
|
virDrvStateReload reload;
|
|
|
|
virDrvStateActive active;
|
|
|
|
};
|
2010-03-09 18:22:22 +00:00
|
|
|
# endif
|
2006-03-20 17:49:28 +00:00
|
|
|
|
2008-11-21 12:19:22 +00:00
|
|
|
|
|
|
|
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 * (*virDevMonDeviceDumpXML)(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);
|
|
|
|
|
2009-04-24 13:11:23 +00:00
|
|
|
typedef virNodeDevicePtr (*virDrvNodeDeviceCreateXML)(virConnectPtr conn,
|
|
|
|
const char *xmlDesc,
|
|
|
|
unsigned int flags);
|
|
|
|
typedef int (*virDrvNodeDeviceDestroy)(virNodeDevicePtr dev);
|
|
|
|
|
2008-11-21 12:19:22 +00:00
|
|
|
/**
|
|
|
|
* _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;
|
|
|
|
virDevMonDeviceDumpXML deviceDumpXML;
|
|
|
|
virDevMonDeviceGetParent deviceGetParent;
|
|
|
|
virDevMonDeviceNumOfCaps deviceNumOfCaps;
|
|
|
|
virDevMonDeviceListCaps deviceListCaps;
|
2009-04-24 13:11:23 +00:00
|
|
|
virDrvNodeDeviceCreateXML deviceCreateXML;
|
|
|
|
virDrvNodeDeviceDestroy deviceDestroy;
|
2008-11-21 12:19:22 +00:00
|
|
|
};
|
|
|
|
|
2009-08-14 19:42:19 +00:00
|
|
|
/* bits 16 and above of virDomainXMLFlags are for internal use */
|
2010-03-09 18:22:22 +00:00
|
|
|
# define VIR_DOMAIN_XML_FLAGS_MASK 0xffff
|
2009-08-14 19:42:19 +00:00
|
|
|
|
|
|
|
/* Bits 16 and above of virSecretGetValue flags are for internal use */
|
2010-03-09 18:22:22 +00:00
|
|
|
# define VIR_SECRET_GET_VALUE_FLAGS_MASK 0xffff
|
2009-08-14 19:42:19 +00:00
|
|
|
|
|
|
|
enum {
|
|
|
|
/* This getValue call is inside libvirt, override the "private" flag.
|
|
|
|
This flag can not be set by outside callers. */
|
|
|
|
VIR_SECRET_GET_VALUE_INTERNAL_CALL = 1 << 16
|
|
|
|
};
|
|
|
|
|
2009-08-14 19:42:19 +00:00
|
|
|
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);
|
Add usage type/id as a public API property of virSecret
* include/libvirt/libvirt.h, include/libvirt/libvirt.h.in: Add
virSecretGetUsageType, virSecretGetUsageID and virLookupSecretByUsage
* python/generator.py: Mark virSecretGetUsageType, virSecretGetUsageID
as not throwing exceptions
* qemud/remote.c: Implement dispatch for virLookupSecretByUsage
* qemud/remote_protocol.x: Add usage type & ID as attributes of
remote_nonnull_secret. Add RPC calls for new public APIs
* 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.c, src/datatypes.h: Add usageType and usageID as
properties of virSecretPtr
* src/driver.h: Add virLookupSecretByUsage driver entry point
* src/libvirt.c: Implement virSecretGetUsageType, virSecretGetUsageID
and virLookupSecretByUsage
* src/libvirt_public.syms: Export virSecretGetUsageType, virSecretGetUsageID
and virLookupSecretByUsage
* src/remote_internal.c: Implement virLookupSecretByUsage entry
* src/secret_conf.c, src/secret_conf.h: Remove the
virSecretUsageType enum, now in public API. Make volume
path mandatory when parsing XML
* src/secret_driver.c: Enforce usage uniqueness when defining secrets.
Implement virSecretLookupByUsage api method
* src/virsh.c: Include usage for secret-list command
2009-09-11 13:06:15 +00:00
|
|
|
typedef virSecretPtr
|
|
|
|
(*virDrvSecretLookupByUsage) (virConnectPtr conn,
|
|
|
|
int usageType,
|
|
|
|
const char *usageID);
|
2009-08-14 19:42:19 +00:00
|
|
|
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);
|
|
|
|
typedef int
|
|
|
|
(*virDrvSecretUndefine) (virSecretPtr secret);
|
|
|
|
typedef int
|
|
|
|
(*virDrvSecretNumOfSecrets) (virConnectPtr conn);
|
|
|
|
typedef int
|
|
|
|
(*virDrvSecretListSecrets) (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;
|
|
|
|
|
|
|
|
virDrvSecretNumOfSecrets numOfSecrets;
|
|
|
|
virDrvSecretListSecrets listSecrets;
|
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 lookupByUUID;
|
Add usage type/id as a public API property of virSecret
* include/libvirt/libvirt.h, include/libvirt/libvirt.h.in: Add
virSecretGetUsageType, virSecretGetUsageID and virLookupSecretByUsage
* python/generator.py: Mark virSecretGetUsageType, virSecretGetUsageID
as not throwing exceptions
* qemud/remote.c: Implement dispatch for virLookupSecretByUsage
* qemud/remote_protocol.x: Add usage type & ID as attributes of
remote_nonnull_secret. Add RPC calls for new public APIs
* 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.c, src/datatypes.h: Add usageType and usageID as
properties of virSecretPtr
* src/driver.h: Add virLookupSecretByUsage driver entry point
* src/libvirt.c: Implement virSecretGetUsageType, virSecretGetUsageID
and virLookupSecretByUsage
* src/libvirt_public.syms: Export virSecretGetUsageType, virSecretGetUsageID
and virLookupSecretByUsage
* src/remote_internal.c: Implement virLookupSecretByUsage entry
* src/secret_conf.c, src/secret_conf.h: Remove the
virSecretUsageType enum, now in public API. Make volume
path mandatory when parsing XML
* src/secret_driver.c: Enforce usage uniqueness when defining secrets.
Implement virSecretLookupByUsage api method
* src/virsh.c: Include usage for secret-list command
2009-09-11 13:06:15 +00:00
|
|
|
virDrvSecretLookupByUsage lookupByUsage;
|
2009-08-14 19:42:19 +00:00
|
|
|
virDrvSecretDefineXML defineXML;
|
|
|
|
virDrvSecretGetXMLDesc getXMLDesc;
|
|
|
|
virDrvSecretSetValue setValue;
|
|
|
|
virDrvSecretGetValue getValue;
|
|
|
|
virDrvSecretUndefine undefine;
|
|
|
|
};
|
|
|
|
|
2009-07-10 11:18:12 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2010-03-25 17:46:01 +00:00
|
|
|
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,
|
|
|
|
unsigned int flags);
|
|
|
|
typedef int
|
2011-01-15 15:06:52 +00:00
|
|
|
(*virDrvNWFilterUndefine) (virNWFilterPtr nwfilter);
|
2010-03-25 17:46:01 +00:00
|
|
|
|
|
|
|
typedef char *
|
2011-01-15 15:06:52 +00:00
|
|
|
(*virDrvNWFilterGetXMLDesc) (virNWFilterPtr nwfilter,
|
2010-03-25 17:46:01 +00:00
|
|
|
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;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2006-03-20 17:49:28 +00:00
|
|
|
/*
|
|
|
|
* Registration
|
|
|
|
* TODO: also need ways to (des)activate a given driver
|
|
|
|
* lookup based on the URI given in a virConnectOpen(ReadOnly)
|
|
|
|
*/
|
|
|
|
int virRegisterDriver(virDriverPtr);
|
2007-02-14 15:37:18 +00:00
|
|
|
int virRegisterNetworkDriver(virNetworkDriverPtr);
|
2009-05-20 14:26:49 +00:00
|
|
|
int virRegisterInterfaceDriver(virInterfaceDriverPtr);
|
2008-02-20 15:06:53 +00:00
|
|
|
int virRegisterStorageDriver(virStorageDriverPtr);
|
2008-11-21 12:19:22 +00:00
|
|
|
int virRegisterDeviceMonitor(virDeviceMonitorPtr);
|
2009-08-14 19:42:19 +00:00
|
|
|
int virRegisterSecretDriver(virSecretDriverPtr);
|
2010-03-25 17:46:01 +00:00
|
|
|
int virRegisterNWFilterDriver(virNWFilterDriverPtr);
|
2010-03-09 18:22:22 +00:00
|
|
|
# ifdef WITH_LIBVIRTD
|
2007-06-26 22:56:14 +00:00
|
|
|
int virRegisterStateDriver(virStateDriverPtr);
|
2010-03-09 18:22:22 +00:00
|
|
|
# endif
|
2008-11-21 12:16:08 +00:00
|
|
|
void *virDriverLoadModule(const char *name);
|
2006-03-20 17:49:28 +00:00
|
|
|
|
|
|
|
#endif /* __VIR_DRIVER_H__ */
|