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
|
2013-05-14 23:42:12 +00:00
|
|
|
*
|
|
|
|
* Copyright (C) 2006-2013 Red Hat, Inc.
|
|
|
|
*
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This library is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
|
|
* License along with this library. If not, see
|
|
|
|
* <http://www.gnu.org/licenses/>.
|
2006-03-20 17:49:28 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef __VIR_DRIVER_H__
|
2010-03-09 18:22:22 +00:00
|
|
|
# define __VIR_DRIVER_H__
|
2006-03-20 17:49:28 +00:00
|
|
|
|
2012-01-11 13:48:14 +00:00
|
|
|
# include <unistd.h>
|
2007-11-14 11:40:57 +00:00
|
|
|
|
2010-03-09 18:22:22 +00:00
|
|
|
# include "internal.h"
|
2012-02-24 18:48:55 +00:00
|
|
|
# include "viruri.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,
|
2011-02-10 22:42:34 +00:00
|
|
|
VIR_DRV_VMWARE = 13,
|
|
|
|
VIR_DRV_LIBXL = 14,
|
2011-07-13 14:47:01 +00:00
|
|
|
VIR_DRV_HYPERV = 15,
|
2012-07-31 18:56:05 +00:00
|
|
|
VIR_DRV_PARALLELS = 16,
|
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.
|
|
|
|
*/
|
2013-04-22 17:26:01 +00:00
|
|
|
# define VIR_DRV_SUPPORTS_FEATURE(drv,conn,feature) \
|
|
|
|
((drv)->connectSupportsFeature ? \
|
|
|
|
(drv)->connectSupportsFeature((conn), (feature)) > 0 : 0)
|
2007-08-21 09:03:55 +00:00
|
|
|
|
2007-04-04 14:19:49 +00:00
|
|
|
typedef virDrvOpenStatus
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectOpen)(virConnectPtr conn,
|
|
|
|
virConnectAuthPtr auth,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2006-03-20 17:49:28 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectClose)(virConnectPtr conn);
|
|
|
|
|
2007-08-21 09:03:55 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectSupportsFeature)(virConnectPtr conn,
|
|
|
|
int feature);
|
|
|
|
|
2006-03-20 17:49:28 +00:00
|
|
|
typedef const char *
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectGetType)(virConnectPtr conn);
|
|
|
|
|
2006-03-20 17:49:28 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectGetVersion)(virConnectPtr conn,
|
|
|
|
unsigned long *hvVer);
|
|
|
|
|
2009-11-12 15:53:26 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectGetLibVersion)(virConnectPtr conn,
|
|
|
|
unsigned long *libVer);
|
|
|
|
|
2007-06-26 11:42:46 +00:00
|
|
|
typedef char *
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectGetHostname)(virConnectPtr conn);
|
|
|
|
|
2007-06-26 11:42:46 +00:00
|
|
|
typedef char *
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectGetURI)(virConnectPtr conn);
|
|
|
|
|
2011-02-07 21:14:56 +00:00
|
|
|
typedef char *
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectGetSysinfo)(virConnectPtr conn,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2007-03-08 08:31:07 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectGetMaxVcpus)(virConnectPtr conn,
|
|
|
|
const char *type);
|
|
|
|
|
2006-03-29 12:46:03 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvNodeGetInfo)(virConnectPtr conn,
|
|
|
|
virNodeInfoPtr info);
|
|
|
|
|
2007-03-15 17:24:56 +00:00
|
|
|
typedef char *
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectGetCapabilities)(virConnectPtr conn);
|
|
|
|
|
2006-03-20 17:49:28 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectListDomains)(virConnectPtr conn,
|
|
|
|
int *ids,
|
|
|
|
int maxids);
|
|
|
|
|
2006-03-20 17:49:28 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectNumOfDomains)(virConnectPtr conn);
|
|
|
|
|
2006-03-20 17:49:28 +00:00
|
|
|
typedef virDomainPtr
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainCreateXML)(virConnectPtr conn,
|
|
|
|
const char *xmlDesc,
|
|
|
|
unsigned int flags);
|
Introduce new domain create APIs to pass pre-opened FDs to LXC
With container based virt, it is useful to be able to pass
pre-opened file descriptors to the container init process.
This allows for containers to be auto-activated from incoming
socket connections, passing the active socket into the container.
To do this, introduce a pair of new APIs, virDomainCreateXMLWithFiles
and virDomainCreateWithFiles, which accept an array of file
descriptors. For the LXC driver, UNIX file descriptor passing
will be used to send them to libvirtd, which will them pass
them down to libvirt_lxc, which will then pass them to the container
init process.
This will only be implemented for LXC right now, but the design
is generic enough it could work with other hypervisors, hence
I suggest adding this to libvirt.so, rather than libvirt-lxc.so
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
2013-07-09 16:12:38 +00:00
|
|
|
typedef virDomainPtr
|
|
|
|
(*virDrvDomainCreateXMLWithFiles)(virConnectPtr conn,
|
|
|
|
const char *xmlDesc,
|
|
|
|
unsigned int nfiles,
|
|
|
|
int *files,
|
|
|
|
unsigned int flags);
|
2013-04-23 09:49:27 +00:00
|
|
|
|
2006-03-20 17:49:28 +00:00
|
|
|
typedef virDomainPtr
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainLookupByID)(virConnectPtr conn,
|
|
|
|
int id);
|
|
|
|
|
2006-03-20 17:49:28 +00:00
|
|
|
typedef virDomainPtr
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainLookupByUUID)(virConnectPtr conn,
|
|
|
|
const unsigned char *uuid);
|
|
|
|
|
2006-03-20 17:49:28 +00:00
|
|
|
typedef virDomainPtr
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainLookupByName)(virConnectPtr conn,
|
|
|
|
const char *name);
|
|
|
|
|
2006-03-20 17:49:28 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainSuspend)(virDomainPtr domain);
|
|
|
|
|
2006-03-20 17:49:28 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainResume)(virDomainPtr domain);
|
|
|
|
|
2012-01-26 18:05:46 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainPMSuspendForDuration)(virDomainPtr,
|
|
|
|
unsigned int target,
|
|
|
|
unsigned long long duration,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2012-02-10 11:40:52 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainPMWakeup)(virDomainPtr domain,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2006-03-20 17:49:28 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainShutdown)(virDomainPtr domain);
|
|
|
|
|
2006-04-03 13:46:43 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainReboot)(virDomainPtr domain,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2011-09-29 08:53:29 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainReset)(virDomainPtr domain,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2006-03-20 17:49:28 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainDestroy)(virDomainPtr domain);
|
|
|
|
|
2011-07-20 15:02:48 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainDestroyFlags)(virDomainPtr domain,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2006-03-20 17:49:28 +00:00
|
|
|
typedef char *
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainGetOSType)(virDomainPtr domain);
|
2012-07-10 07:34:23 +00:00
|
|
|
|
|
|
|
typedef char *
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainGetHostname)(virDomainPtr domain,
|
|
|
|
unsigned int flags);
|
2012-07-10 07:34:23 +00:00
|
|
|
|
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
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainGetMaxMemory)(virDomainPtr domain);
|
|
|
|
|
2006-03-20 17:49:28 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainSetMaxMemory)(virDomainPtr domain,
|
|
|
|
unsigned long memory);
|
|
|
|
|
2006-04-13 17:18:49 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainSetMemory)(virDomainPtr domain,
|
|
|
|
unsigned long memory);
|
|
|
|
|
2011-03-02 08:07:48 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainSetMemoryFlags)(virDomainPtr domain,
|
|
|
|
unsigned long memory,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2013-07-08 14:22:38 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvDomainSetMemoryStatsPeriod)(virDomainPtr domain,
|
|
|
|
int period,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2010-10-12 14:03:24 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainSetMemoryParameters)(virDomainPtr domain,
|
|
|
|
virTypedParameterPtr params,
|
|
|
|
int nparams,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2010-10-12 14:03:24 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainGetMemoryParameters)(virDomainPtr domain,
|
|
|
|
virTypedParameterPtr params,
|
|
|
|
int *nparams,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2011-12-20 08:35:00 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainSetNumaParameters)(virDomainPtr domain,
|
|
|
|
virTypedParameterPtr params,
|
|
|
|
int nparams,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2011-12-20 08:35:00 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainGetNumaParameters)(virDomainPtr domain,
|
|
|
|
virTypedParameterPtr params,
|
|
|
|
int *nparams,
|
|
|
|
unsigned int flags);
|
2011-12-20 08:35:00 +00:00
|
|
|
|
2011-02-22 05:31:57 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainSetBlkioParameters)(virDomainPtr domain,
|
|
|
|
virTypedParameterPtr params,
|
|
|
|
int nparams,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2011-02-22 05:31:57 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainGetBlkioParameters)(virDomainPtr domain,
|
|
|
|
virTypedParameterPtr params,
|
|
|
|
int *nparams,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2006-03-20 17:49:28 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainGetInfo)(virDomainPtr domain,
|
|
|
|
virDomainInfoPtr info);
|
|
|
|
|
2011-04-22 11:49:01 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainGetState)(virDomainPtr domain,
|
|
|
|
int *state,
|
|
|
|
int *reason,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2011-05-24 08:28:50 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainGetControlInfo)(virDomainPtr domain,
|
|
|
|
virDomainControlInfoPtr info,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2006-03-20 17:49:28 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainSave)(virDomainPtr domain,
|
|
|
|
const char *to);
|
|
|
|
|
2011-07-06 18:10:11 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainSaveFlags)(virDomainPtr domain,
|
|
|
|
const char *to,
|
|
|
|
const char *dxml,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2006-03-20 17:49:28 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainRestore)(virConnectPtr conn,
|
|
|
|
const char *from);
|
|
|
|
|
2011-07-06 18:10:11 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainRestoreFlags)(virConnectPtr conn,
|
|
|
|
const char *from,
|
|
|
|
const char *dxml,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2011-07-20 04:29:26 +00:00
|
|
|
typedef char *
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainSaveImageGetXMLDesc)(virConnectPtr conn,
|
|
|
|
const char *file,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2011-07-20 04:29:26 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainSaveImageDefineXML)(virConnectPtr conn,
|
|
|
|
const char *file,
|
|
|
|
const char *dxml,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2006-11-22 17:48:29 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainCoreDump)(virDomainPtr domain,
|
|
|
|
const char *to,
|
|
|
|
unsigned int flags);
|
|
|
|
|
screenshot: Defining the internal API
* src/driver.h: Stub code for new API
* src/esx/esx_driver.c, src/libxl/libxl_driver.c,
src/lxc/lxc_driver.c, src/openvz/openvz_driver.c,
src/phyp/phyp_driver.c, src/qemu/qemu_driver.c,
rc/remote/remote_driver.c, rc/test/test_driver.c,
src/uml/uml_driver.c, src/vbox/vbox_tmpl.c,
src/vmware/vmware_driver.c, src/xen/xen_driver.c,
src/xen/xen_driver.h, src/xen/xen_hypervisor.c,
src/xen/xen_inotify.c, src/xen/xend_internal.c,
src/xen/xm_internal.c, src/xen/xs_internal.c,
src/xenapi/xenapi_driver.c: Add dummy entries in driver
table for new APIs
2011-04-04 10:35:45 +00:00
|
|
|
typedef char *
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainScreenshot)(virDomainPtr domain,
|
|
|
|
virStreamPtr stream,
|
|
|
|
unsigned int screen,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2006-08-09 15:21:16 +00:00
|
|
|
typedef char *
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainGetXMLDesc)(virDomainPtr dom,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2009-05-21 13:46:35 +00:00
|
|
|
typedef char *
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectDomainXMLFromNative)(virConnectPtr conn,
|
|
|
|
const char *nativeFormat,
|
|
|
|
const char *nativeConfig,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2009-05-21 13:46:35 +00:00
|
|
|
typedef char *
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectDomainXMLToNative)(virConnectPtr conn,
|
|
|
|
const char *nativeFormat,
|
|
|
|
const char *domainXml,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2006-08-30 14:21:03 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectListDefinedDomains)(virConnectPtr conn,
|
|
|
|
char **const names,
|
|
|
|
int maxnames);
|
|
|
|
|
2012-05-18 15:22:02 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectListAllDomains)(virConnectPtr conn,
|
|
|
|
virDomainPtr **domains,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2006-08-30 14:21:03 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectNumOfDefinedDomains)(virConnectPtr conn);
|
|
|
|
|
2006-08-30 14:21:03 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainCreate)(virDomainPtr dom);
|
|
|
|
|
2010-06-10 13:28:05 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainCreateWithFlags)(virDomainPtr dom,
|
|
|
|
unsigned int flags);
|
Introduce new domain create APIs to pass pre-opened FDs to LXC
With container based virt, it is useful to be able to pass
pre-opened file descriptors to the container init process.
This allows for containers to be auto-activated from incoming
socket connections, passing the active socket into the container.
To do this, introduce a pair of new APIs, virDomainCreateXMLWithFiles
and virDomainCreateWithFiles, which accept an array of file
descriptors. For the LXC driver, UNIX file descriptor passing
will be used to send them to libvirtd, which will them pass
them down to libvirt_lxc, which will then pass them to the container
init process.
This will only be implemented for LXC right now, but the design
is generic enough it could work with other hypervisors, hence
I suggest adding this to libvirt.so, rather than libvirt-lxc.so
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
2013-07-09 16:12:38 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvDomainCreateWithFiles)(virDomainPtr dom,
|
|
|
|
unsigned int nfiles,
|
|
|
|
int *files,
|
|
|
|
unsigned int flags);
|
2013-04-23 09:49:27 +00:00
|
|
|
|
2006-08-30 14:21:03 +00:00
|
|
|
typedef virDomainPtr
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainDefineXML)(virConnectPtr conn,
|
|
|
|
const char *xml);
|
|
|
|
|
2006-08-30 14:21:03 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainUndefine)(virDomainPtr dom);
|
|
|
|
|
2011-07-20 02:59:54 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainUndefineFlags)(virDomainPtr dom,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2006-08-08 22:22:55 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainSetVcpus)(virDomainPtr domain,
|
|
|
|
unsigned int nvcpus);
|
|
|
|
|
2010-09-27 15:18:22 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainSetVcpusFlags)(virDomainPtr domain,
|
|
|
|
unsigned int nvcpus,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2010-09-27 15:18:22 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainGetVcpusFlags)(virDomainPtr domain,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2006-08-08 22:22:55 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainPinVcpu)(virDomainPtr domain,
|
|
|
|
unsigned int vcpu,
|
|
|
|
unsigned char *cpumap,
|
|
|
|
int maplen);
|
|
|
|
|
2011-06-13 15:35:54 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainPinVcpuFlags)(virDomainPtr domain,
|
|
|
|
unsigned int vcpu,
|
|
|
|
unsigned char *cpumap,
|
|
|
|
int maplen,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2011-06-24 08:56:21 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainGetVcpuPinInfo)(virDomainPtr domain,
|
|
|
|
int ncpumaps,
|
|
|
|
unsigned char *cpumaps,
|
|
|
|
int maplen,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2012-08-21 09:18:35 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainPinEmulator)(virDomainPtr domain,
|
|
|
|
unsigned char *cpumap,
|
|
|
|
int maplen,
|
|
|
|
unsigned int flags);
|
2011-06-24 08:56:21 +00:00
|
|
|
|
2006-08-08 22:22:55 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainGetEmulatorPinInfo)(virDomainPtr domain,
|
|
|
|
unsigned char *cpumaps,
|
|
|
|
int maplen,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2007-03-08 08:31:07 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainGetVcpus)(virDomainPtr domain,
|
|
|
|
virVcpuInfoPtr info,
|
|
|
|
int maxinfo,
|
|
|
|
unsigned char *cpumaps,
|
|
|
|
int maplen);
|
2009-03-03 09:14:28 +00:00
|
|
|
|
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainGetMaxVcpus)(virDomainPtr domain);
|
|
|
|
|
|
|
|
typedef int
|
|
|
|
(*virDrvDomainGetSecurityLabel)(virDomainPtr domain,
|
|
|
|
virSecurityLabelPtr seclabel);
|
|
|
|
|
2012-08-15 22:10:39 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainGetSecurityLabelList)(virDomainPtr domain,
|
|
|
|
virSecurityLabelPtr* seclabels);
|
|
|
|
|
2009-03-03 09:14:28 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvNodeGetSecurityModel)(virConnectPtr conn,
|
|
|
|
virSecurityModelPtr secmodel);
|
|
|
|
|
2006-11-16 18:11:28 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainAttachDevice)(virDomainPtr domain,
|
|
|
|
const char *xml);
|
|
|
|
|
2010-01-14 01:31:14 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainAttachDeviceFlags)(virDomainPtr domain,
|
|
|
|
const char *xml,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2006-11-16 18:11:28 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainDetachDevice)(virDomainPtr domain,
|
|
|
|
const char *xml);
|
|
|
|
|
2010-01-14 01:31:14 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*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
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainUpdateDeviceFlags)(virDomainPtr domain,
|
|
|
|
const char *xml,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2007-02-23 08:51:30 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainGetAutostart)(virDomainPtr domain,
|
|
|
|
int *autostart);
|
|
|
|
|
2007-02-23 08:51:30 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +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 *
|
2013-04-23 09:49:27 +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
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainGetSchedulerParameters)(virDomainPtr domain,
|
|
|
|
virTypedParameterPtr params,
|
|
|
|
int *nparams);
|
2007-06-05 12:06:08 +00:00
|
|
|
|
2011-05-17 21:17:14 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainGetSchedulerParametersFlags)(virDomainPtr domain,
|
|
|
|
virTypedParameterPtr params,
|
|
|
|
int *nparams,
|
|
|
|
unsigned int flags);
|
2011-05-17 21:17:14 +00:00
|
|
|
|
2007-06-05 12:06:08 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainSetSchedulerParameters)(virDomainPtr domain,
|
|
|
|
virTypedParameterPtr params,
|
|
|
|
int nparams);
|
2007-06-05 12:06:08 +00:00
|
|
|
|
2011-05-17 06:20:00 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainSetSchedulerParametersFlags)(virDomainPtr domain,
|
|
|
|
virTypedParameterPtr params,
|
|
|
|
int nparams,
|
|
|
|
unsigned int flags);
|
2011-05-17 06:20:00 +00:00
|
|
|
|
2007-08-21 10:08:12 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainBlockStats)(virDomainPtr domain,
|
|
|
|
const char *path,
|
|
|
|
struct _virDomainBlockStats *stats);
|
|
|
|
|
2011-09-05 08:15:14 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainBlockStatsFlags)(virDomainPtr domain,
|
|
|
|
const char *path,
|
|
|
|
virTypedParameterPtr params,
|
|
|
|
int *nparams,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2007-08-21 10:08:12 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainInterfaceStats)(virDomainPtr domain,
|
|
|
|
const char *path,
|
|
|
|
struct _virDomainInterfaceStats *stats);
|
|
|
|
|
2011-12-29 07:33:16 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainSetInterfaceParameters)(virDomainPtr dom,
|
|
|
|
const char *device,
|
|
|
|
virTypedParameterPtr params,
|
|
|
|
int nparams,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2011-12-29 07:33:16 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainGetInterfaceParameters)(virDomainPtr dom,
|
|
|
|
const char *device,
|
|
|
|
virTypedParameterPtr params,
|
|
|
|
int *nparams,
|
|
|
|
unsigned int flags);
|
2007-08-21 10:08:12 +00:00
|
|
|
|
2009-12-20 12:28:42 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainMemoryStats)(virDomainPtr domain,
|
|
|
|
struct _virDomainMemoryStat *stats,
|
|
|
|
unsigned int nr_stats,
|
|
|
|
unsigned int flags);
|
2009-12-20 12:28:42 +00:00
|
|
|
|
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
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainBlockPeek)(virDomainPtr domain,
|
|
|
|
const char *path,
|
|
|
|
unsigned long long offset,
|
|
|
|
size_t size,
|
|
|
|
void *buffer,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2011-11-29 09:59:15 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainBlockResize)(virDomainPtr domain,
|
|
|
|
const char *path,
|
|
|
|
unsigned long long size,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2008-06-10 10:43:28 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*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
|
2013-04-23 09:49:27 +00:00
|
|
|
(*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
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainMigratePrepare)(virConnectPtr dconn,
|
|
|
|
char **cookie,
|
|
|
|
int *cookielen,
|
|
|
|
const char *uri_in,
|
|
|
|
char **uri_out,
|
|
|
|
unsigned long flags,
|
|
|
|
const char *dname,
|
|
|
|
unsigned long resource);
|
2007-08-21 09:31:12 +00:00
|
|
|
|
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainMigratePerform)(virDomainPtr domain,
|
|
|
|
const char *cookie,
|
|
|
|
int cookielen,
|
|
|
|
const char *uri,
|
|
|
|
unsigned long flags,
|
|
|
|
const char *dname,
|
|
|
|
unsigned long resource);
|
2007-08-21 09:31:12 +00:00
|
|
|
|
|
|
|
typedef virDomainPtr
|
2013-04-23 09:49:27 +00:00
|
|
|
(*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
|
|
|
|
2011-06-07 00:59:44 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvNodeGetCPUStats)(virConnectPtr conn,
|
|
|
|
int cpuNum,
|
|
|
|
virNodeCPUStatsPtr params,
|
|
|
|
int *nparams,
|
|
|
|
unsigned int flags);
|
2011-06-07 00:59:44 +00:00
|
|
|
|
2011-06-07 01:04:12 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvNodeGetMemoryStats)(virConnectPtr conn,
|
|
|
|
int cellNum,
|
|
|
|
virNodeMemoryStatsPtr params,
|
|
|
|
int *nparams,
|
|
|
|
unsigned int flags);
|
2011-06-07 01:04:12 +00:00
|
|
|
|
2007-09-28 14:28:12 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvNodeGetCellsFreeMemory)(virConnectPtr conn,
|
|
|
|
unsigned long long *freeMems,
|
|
|
|
int startCell,
|
|
|
|
int maxCells);
|
2007-09-28 14:28:12 +00:00
|
|
|
|
2007-09-30 13:09:07 +00:00
|
|
|
typedef unsigned long long
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvNodeGetFreeMemory)(virConnectPtr conn);
|
2007-09-30 13:09:07 +00:00
|
|
|
|
2008-10-23 13:18:18 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectDomainEventRegister)(virConnectPtr conn,
|
|
|
|
virConnectDomainEventCallback cb,
|
|
|
|
void *opaque,
|
|
|
|
virFreeCallback freecb);
|
2008-10-23 13:18:18 +00:00
|
|
|
|
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectDomainEventDeregister)(virConnectPtr conn,
|
|
|
|
virConnectDomainEventCallback cb);
|
2008-10-23 13:18:18 +00:00
|
|
|
|
2008-11-14 08:42:47 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*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);
|
2008-11-14 08:42:47 +00:00
|
|
|
|
|
|
|
typedef virDomainPtr
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainMigrateFinish2)(virConnectPtr dconn,
|
|
|
|
const char *dname,
|
|
|
|
const char *cookie,
|
|
|
|
int cookielen,
|
|
|
|
const char *uri,
|
|
|
|
unsigned long flags,
|
|
|
|
int retcode);
|
2008-11-14 08:42:47 +00:00
|
|
|
|
2009-03-02 16:25:13 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvNodeDeviceDettach)(virNodeDevicePtr dev);
|
|
|
|
|
2013-04-24 16:56:10 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvNodeDeviceDetachFlags)(virNodeDevicePtr dev,
|
|
|
|
const char *driverName,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2009-03-02 16:25:13 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvNodeDeviceReAttach)(virNodeDevicePtr dev);
|
|
|
|
|
2009-03-02 16:25:13 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvNodeDeviceReset)(virNodeDevicePtr dev);
|
2009-03-02 16:25:13 +00:00
|
|
|
|
2009-09-30 10:51:54 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainMigratePrepareTunnel)(virConnectPtr dconn,
|
|
|
|
virStreamPtr st,
|
|
|
|
unsigned long flags,
|
|
|
|
const char *dname,
|
|
|
|
unsigned long resource,
|
|
|
|
const char *dom_xml);
|
2009-09-30 10:51:54 +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
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectIsEncrypted)(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
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectIsSecure)(virConnectPtr conn);
|
|
|
|
|
2011-09-23 06:47:59 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*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
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainIsActive)(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
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainIsPersistent)(virDomainPtr dom);
|
|
|
|
|
2010-11-15 03:23:33 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*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
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectCompareCPU)(virConnectPtr conn,
|
|
|
|
const char *cpu,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2010-02-02 11:34:01 +00:00
|
|
|
typedef char *
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectBaselineCPU)(virConnectPtr conn,
|
|
|
|
const char **xmlCPUs,
|
|
|
|
unsigned int ncpus,
|
|
|
|
unsigned int flags);
|
2009-12-18 13:59:39 +00:00
|
|
|
|
2013-09-23 09:45:58 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvConnectGetCPUModelNames)(virConnectPtr conn,
|
|
|
|
const char *args,
|
|
|
|
char ***models,
|
|
|
|
unsigned int flags);
|
|
|
|
|
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
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainGetJobInfo)(virDomainPtr domain,
|
|
|
|
virDomainJobInfoPtr info);
|
|
|
|
|
2013-01-25 23:30:49 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainGetJobStats)(virDomainPtr domain,
|
|
|
|
int *type,
|
|
|
|
virTypedParameterPtr *params,
|
|
|
|
int *nparams,
|
|
|
|
unsigned int flags);
|
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
|
|
|
|
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
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainAbortJob)(virDomainPtr domain);
|
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
|
|
|
|
2010-03-12 13:55:08 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainMigrateSetMaxDowntime)(virDomainPtr domain,
|
|
|
|
unsigned long long downtime,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2013-02-18 16:31:08 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainMigrateGetCompressionCache)(virDomainPtr domain,
|
|
|
|
unsigned long long *cacheSize,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2013-02-18 16:31:08 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainMigrateSetCompressionCache)(virDomainPtr domain,
|
|
|
|
unsigned long long cacheSize,
|
|
|
|
unsigned int flags);
|
2013-02-18 16:31:08 +00:00
|
|
|
|
Add public API for setting migration speed on the fly
It is possible to set a migration speed limit when starting
migration. This new API allows the speed limit to be changed
on the fly to adjust to changing conditions
* src/driver.h, src/libvirt.c, src/libvirt_public.syms,
include/libvirt/libvirt.h.in: Add virDomainMigrateSetMaxSpeed
* 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/vmware/vmware_driver.c, src/xen/xen_driver.c,
src/libxl/libxl_driver.c: Stub new API
2011-02-17 13:57:53 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainMigrateSetMaxSpeed)(virDomainPtr domain,
|
|
|
|
unsigned long bandwidth,
|
|
|
|
unsigned int flags);
|
2010-03-12 13:55:08 +00:00
|
|
|
|
2011-08-26 18:10:21 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainMigrateGetMaxSpeed)(virDomainPtr domain,
|
|
|
|
unsigned long *bandwidth,
|
|
|
|
unsigned int flags);
|
2011-08-26 18:10:21 +00:00
|
|
|
|
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
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectDomainEventRegisterAny)(virConnectPtr conn,
|
|
|
|
virDomainPtr dom,
|
|
|
|
int eventID,
|
|
|
|
virConnectDomainEventGenericCallback cb,
|
|
|
|
void *opaque,
|
|
|
|
virFreeCallback freecb);
|
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
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectDomainEventDeregisterAny)(virConnectPtr conn,
|
|
|
|
int callbackID);
|
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
|
|
|
|
2010-04-01 08:46:28 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainManagedSave)(virDomainPtr domain,
|
|
|
|
unsigned int flags);
|
2010-04-01 08:46:28 +00:00
|
|
|
|
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainHasManagedSaveImage)(virDomainPtr domain,
|
|
|
|
unsigned int flags);
|
2010-04-01 08:46:28 +00:00
|
|
|
|
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainManagedSaveRemove)(virDomainPtr domain,
|
|
|
|
unsigned int flags);
|
2010-04-01 08:46:28 +00:00
|
|
|
|
2010-03-31 20:33:13 +00:00
|
|
|
typedef virDomainSnapshotPtr
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainSnapshotCreateXML)(virDomainPtr domain,
|
|
|
|
const char *xmlDesc,
|
|
|
|
unsigned int flags);
|
2010-03-31 20:33:13 +00:00
|
|
|
|
|
|
|
typedef char *
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainSnapshotGetXMLDesc)(virDomainSnapshotPtr snapshot,
|
|
|
|
unsigned int flags);
|
2010-03-31 20:33:13 +00:00
|
|
|
|
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainSnapshotNum)(virDomainPtr domain,
|
|
|
|
unsigned int flags);
|
2010-03-31 20:33:13 +00:00
|
|
|
|
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainSnapshotListNames)(virDomainPtr domain,
|
|
|
|
char **names,
|
|
|
|
int nameslen,
|
|
|
|
unsigned int flags);
|
2010-03-31 20:33:13 +00:00
|
|
|
|
2012-05-23 16:40:50 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainListAllSnapshots)(virDomainPtr domain,
|
|
|
|
virDomainSnapshotPtr **snaps,
|
|
|
|
unsigned int flags);
|
2012-05-23 16:40:50 +00:00
|
|
|
|
2011-09-25 01:56:26 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainSnapshotNumChildren)(virDomainSnapshotPtr snapshot,
|
|
|
|
unsigned int flags);
|
2011-09-25 01:56:26 +00:00
|
|
|
|
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainSnapshotListChildrenNames)(virDomainSnapshotPtr snapshot,
|
|
|
|
char **names,
|
|
|
|
int nameslen,
|
|
|
|
unsigned int flags);
|
2011-09-25 01:56:26 +00:00
|
|
|
|
2012-05-23 16:40:50 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainSnapshotListAllChildren)(virDomainSnapshotPtr snapshot,
|
|
|
|
virDomainSnapshotPtr **snaps,
|
|
|
|
unsigned int flags);
|
2012-05-23 16:40:50 +00:00
|
|
|
|
2010-03-31 20:33:13 +00:00
|
|
|
typedef virDomainSnapshotPtr
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainSnapshotLookupByName)(virDomainPtr domain,
|
|
|
|
const char *name,
|
|
|
|
unsigned int flags);
|
2010-03-31 20:33:13 +00:00
|
|
|
|
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainHasCurrentSnapshot)(virDomainPtr domain,
|
|
|
|
unsigned int flags);
|
2010-03-31 20:33:13 +00:00
|
|
|
|
2011-09-23 18:38:04 +00:00
|
|
|
typedef virDomainSnapshotPtr
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainSnapshotGetParent)(virDomainSnapshotPtr snapshot,
|
|
|
|
unsigned int flags);
|
2011-09-23 18:38:04 +00:00
|
|
|
|
2010-03-31 20:33:13 +00:00
|
|
|
typedef virDomainSnapshotPtr
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainSnapshotCurrent)(virDomainPtr domain,
|
|
|
|
unsigned int flags);
|
2010-03-31 20:33:13 +00:00
|
|
|
|
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
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainSnapshotIsCurrent)(virDomainSnapshotPtr snapshot,
|
|
|
|
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
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainSnapshotHasMetadata)(virDomainSnapshotPtr snapshot,
|
|
|
|
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
|
|
|
|
2010-03-31 20:33:13 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainRevertToSnapshot)(virDomainSnapshotPtr snapshot,
|
|
|
|
unsigned int flags);
|
2010-03-31 20:33:13 +00:00
|
|
|
|
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainSnapshotDelete)(virDomainSnapshotPtr snapshot,
|
|
|
|
unsigned int flags);
|
2010-03-31 20:33:13 +00:00
|
|
|
|
2010-04-13 18:02:46 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainQemuMonitorCommand)(virDomainPtr domain,
|
|
|
|
const char *cmd,
|
|
|
|
char **result,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2012-08-23 03:29:23 +00:00
|
|
|
typedef char *
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainQemuAgentCommand)(virDomainPtr domain,
|
|
|
|
const char *cmd,
|
|
|
|
int timeout,
|
|
|
|
unsigned int flags);
|
2010-04-13 18:02:46 +00:00
|
|
|
|
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. */
|
2011-05-05 14:05:40 +00:00
|
|
|
typedef virDomainPtr
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainQemuAttach)(virConnectPtr conn,
|
|
|
|
unsigned int pid_value,
|
|
|
|
unsigned int flags);
|
2011-05-05 14:05:40 +00:00
|
|
|
|
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
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainOpenConsole)(virDomainPtr dom,
|
|
|
|
const char *dev_name,
|
|
|
|
virStreamPtr st,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2012-12-13 16:24:16 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainOpenChannel)(virDomainPtr dom,
|
|
|
|
const char *name,
|
|
|
|
virStreamPtr st,
|
|
|
|
unsigned int flags);
|
2012-12-13 16:24:16 +00:00
|
|
|
|
2011-10-21 08:00:37 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainOpenGraphics)(virDomainPtr dom,
|
|
|
|
unsigned int idx,
|
|
|
|
int fd,
|
|
|
|
unsigned int flags);
|
2010-04-13 18:02:46 +00:00
|
|
|
|
2011-05-10 08:26:02 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainInjectNMI)(virDomainPtr dom,
|
|
|
|
unsigned int flags);
|
2011-05-10 08:26:02 +00:00
|
|
|
|
2011-06-07 09:11:13 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainSendKey)(virDomainPtr dom,
|
|
|
|
unsigned int codeset,
|
|
|
|
unsigned int holdtime,
|
|
|
|
unsigned int *keycodes,
|
|
|
|
int nkeycodes,
|
|
|
|
unsigned int flags);
|
2011-06-07 09:11:13 +00:00
|
|
|
|
2011-11-15 15:13:05 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainSendProcessSignal)(virDomainPtr dom,
|
|
|
|
long long pid_value,
|
|
|
|
unsigned int signum,
|
|
|
|
unsigned int flags);
|
2011-11-15 15:13:05 +00:00
|
|
|
|
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 *
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainMigrateBegin3)(virDomainPtr domain,
|
|
|
|
const char *xmlin,
|
|
|
|
char **cookieout,
|
|
|
|
int *cookieoutlen,
|
|
|
|
unsigned long flags,
|
|
|
|
const char *dname,
|
|
|
|
unsigned long resource);
|
|
|
|
|
|
|
|
typedef int
|
|
|
|
(*virDrvDomainMigratePrepare3)(virConnectPtr dconn,
|
|
|
|
const char *cookiein,
|
|
|
|
int cookieinlen,
|
|
|
|
char **cookieout,
|
|
|
|
int *cookieoutlen,
|
|
|
|
const char *uri_in,
|
|
|
|
char **uri_out,
|
|
|
|
unsigned long flags,
|
|
|
|
const char *dname,
|
|
|
|
unsigned long resource,
|
|
|
|
const char *dom_xml);
|
|
|
|
|
|
|
|
typedef int
|
|
|
|
(*virDrvDomainMigratePrepareTunnel3)(virConnectPtr dconn,
|
|
|
|
virStreamPtr st,
|
|
|
|
const char *cookiein,
|
|
|
|
int cookieinlen,
|
|
|
|
char **cookieout,
|
|
|
|
int *cookieoutlen,
|
|
|
|
unsigned long flags,
|
|
|
|
const char *dname,
|
|
|
|
unsigned long resource,
|
|
|
|
const char *dom_xml);
|
|
|
|
|
|
|
|
|
|
|
|
typedef int
|
|
|
|
(*virDrvDomainMigratePerform3)(virDomainPtr dom,
|
|
|
|
const char *xmlin,
|
|
|
|
const char *cookiein,
|
|
|
|
int cookieinlen,
|
|
|
|
char **cookieout,
|
|
|
|
int *cookieoutlen,
|
|
|
|
const char *dconnuri,
|
|
|
|
const char *uri,
|
|
|
|
unsigned long flags,
|
|
|
|
const char *dname,
|
|
|
|
unsigned long resource);
|
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
|
|
|
|
Fix the signature of virDomainMigrateFinish3 for error reporting
The current virDomainMigrateFinish3 method signature attempts to
distinguish two types of errors, by allowing return with ret== 0,
but ddomain == NULL, to indicate a failure to start the guest.
This is flawed, because when ret == 0, there is no way for the
virErrorPtr details to be sent back to the client.
Change the signature of virDomainMigrateFinish3 so it simply
returns a virDomainPtr, in the same way as virDomainMigrateFinish2
The disk locking code will protect against the only possible
failure mode this doesn't account for (loosing conenctivity to
libvirtd after Finish3 starts the CPUs, but before the client
sees the reply for Finish3).
* src/driver.h, src/libvirt.c, src/libvirt_internal.h: Change
virDomainMigrateFinish3 to return a virDomainPtr instead of int
* src/remote/remote_driver.c, src/remote/remote_protocol.x,
daemon/remote.c, src/qemu/qemu_driver.c, src/qemu/qemu_migration.c:
Update for API change
2011-05-24 12:05:33 +00:00
|
|
|
typedef virDomainPtr
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainMigrateFinish3)(virConnectPtr dconn,
|
|
|
|
const char *dname,
|
|
|
|
const char *cookiein,
|
|
|
|
int cookieinlen,
|
|
|
|
char **cookieout,
|
|
|
|
int *cookieoutlen,
|
|
|
|
const char *dconnuri,
|
|
|
|
const char *uri,
|
|
|
|
unsigned long flags,
|
|
|
|
int cancelled);
|
|
|
|
|
|
|
|
typedef int
|
|
|
|
(*virDrvDomainMigrateConfirm3)(virDomainPtr domain,
|
|
|
|
const char *cookiein,
|
|
|
|
int cookieinlen,
|
|
|
|
unsigned long flags,
|
|
|
|
int cancelled);
|
|
|
|
|
|
|
|
typedef int
|
|
|
|
(*virDrvNodeSuspendForDuration)(virConnectPtr conn,
|
|
|
|
unsigned int target,
|
|
|
|
unsigned long long duration,
|
|
|
|
unsigned int flags);
|
2011-07-22 05:18:06 +00:00
|
|
|
|
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainBlockJobAbort)(virDomainPtr dom,
|
|
|
|
const char *path,
|
|
|
|
unsigned int flags);
|
2011-07-22 05:18:06 +00:00
|
|
|
|
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainGetBlockJobInfo)(virDomainPtr dom,
|
|
|
|
const char *path,
|
|
|
|
virDomainBlockJobInfoPtr info,
|
|
|
|
unsigned int flags);
|
2011-07-22 05:18:06 +00:00
|
|
|
|
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainBlockJobSetSpeed)(virDomainPtr dom,
|
|
|
|
const char *path,
|
|
|
|
unsigned long bandwidth,
|
|
|
|
unsigned int flags);
|
2011-07-22 05:18:06 +00:00
|
|
|
|
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*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
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainBlockRebase)(virDomainPtr dom,
|
|
|
|
const char *path,
|
|
|
|
const char *base,
|
|
|
|
unsigned long bandwidth,
|
|
|
|
unsigned int flags);
|
|
|
|
|
blockjob: add virDomainBlockCommit
A block commit moves data in the opposite direction of block pull.
Block pull reduces the chain length by dropping backing files after
data has been pulled into the top overlay, and is always safe; block
commit reduces the chain length by dropping overlays after data has
been committed into the backing file, and any files that depended
on base but not on top are invalidated at any point where they have
unallocated data that is now pointing to changed contents in base.
Both directions are useful, however: a qcow2 layer that is more than
50% allocated will typically be faster with a pull operation, while
a qcow2 layer with less than 50% allocation will be faster as a
commit operation. Committing across multiple layers can be more
efficient than repeatedly committing one layer at a time, but
requires extra support from the hypervisor.
This API matches Jeff Cody's proposed qemu command 'block-commit':
https://lists.gnu.org/archive/html/qemu-devel/2012-09/msg02226.html
Jeff's command is still in the works for qemu 1.3, and may gain
further enhancements, such as the ability to control on-error
handling (it will be comparable to the error handling Paolo is
adding to 'drive-mirror', so a similar solution will be needed
when I finally propose virDomainBlockCopy with more functionality
than the basics supported by virDomainBlockRebase). However, even
without qemu support, this API will be useful for _offline_ block
commits, by wrapping qemu-img calls and turning them into a block
job, so this API is worth committing now.
For some examples of how this will be implemented, all starting
with the chain: base <- snap1 <- snap2 <- active
+ These are equivalent:
virDomainBlockCommit(dom, disk, NULL, NULL, 0, 0)
virDomainBlockCommit(dom, disk, NULL, "active", 0, 0)
virDomainBlockCommit(dom, disk, "base", NULL, 0, 0)
virDomainBlockCommit(dom, disk, "base", "active", 0, 0)
but cannot be implemented for online qemu with round 1 of
Jeff's patches; and for offline images, it would require
three back-to-back qemu-img invocations unless qemu-img
is patched to allow more efficient multi-layer commits;
the end result would be 'base' as the active disk with
contents from all three other files, where 'snap1' and
'snap2' are invalid right away, and 'active' is invalid
once any further changes to 'base' are made.
+ These are equivalent:
virDomainBlockCommit(dom, disk, "snap2", NULL, 0, 0)
virDomainBlockCommit(dom, disk, NULL, NULL, 0, _SHALLOW)
they cannot be implemented for online qemu, but for offline,
it is a matter of 'qemu-img commit active', so that 'snap2'
is now the active disk with contents formerly in 'active'.
+ Similarly:
virDomainBlockCommit(dom, disk, "snap2", NULL, 0, _DELETE)
for an offline domain will merge 'active' into 'snap2', then
delete 'active' to avoid leaving a potentially invalid file
around.
+ This version:
virDomainBlockCommit(dom, disk, NULL, "snap2", 0, _SHALLOW)
can be implemented online with 'block-commit' passing a base of
snap1 and a top of snap2; and can be implemented offline by
'qemu-img commit snap2' followed by 'qemu-img rebase -u
-b snap1 active'
* include/libvirt/libvirt.h.in (virDomainBlockCommit): New API.
* src/libvirt.c (virDomainBlockCommit): Implement it.
* src/libvirt_public.syms (LIBVIRT_0.10.2): Export it.
* src/driver.h (virDrvDomainBlockCommit): New driver callback.
* docs/apibuild.py (CParser.parseSignature): Add exception.
2012-09-17 17:56:27 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainBlockCommit)(virDomainPtr dom,
|
|
|
|
const char *disk,
|
|
|
|
const char *base,
|
|
|
|
const char *top,
|
|
|
|
unsigned long bandwidth,
|
|
|
|
unsigned int flags);
|
2011-07-22 05:18:06 +00:00
|
|
|
|
2011-09-22 11:47:07 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectSetKeepAlive)(virConnectPtr conn,
|
|
|
|
int interval,
|
|
|
|
unsigned int count);
|
2011-07-22 05:18:06 +00:00
|
|
|
|
2011-11-15 09:02:43 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainSetBlockIoTune)(virDomainPtr dom,
|
|
|
|
const char *disk,
|
|
|
|
virTypedParameterPtr params,
|
|
|
|
int nparams,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2011-11-15 09:02:43 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainGetBlockIoTune)(virDomainPtr dom,
|
|
|
|
const char *disk,
|
|
|
|
virTypedParameterPtr params,
|
|
|
|
int *nparams,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2011-10-05 17:31:55 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainShutdownFlags)(virDomainPtr domain,
|
|
|
|
unsigned int flags);
|
2011-10-05 17:31:55 +00:00
|
|
|
|
2012-01-28 06:20:28 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainGetCPUStats)(virDomainPtr domain,
|
|
|
|
virTypedParameterPtr params,
|
|
|
|
unsigned int nparams,
|
|
|
|
int start_cpu,
|
|
|
|
unsigned int ncpus,
|
|
|
|
unsigned int flags);
|
2011-11-15 09:02:43 +00:00
|
|
|
|
2012-01-31 06:41:53 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainGetDiskErrors)(virDomainPtr dom,
|
|
|
|
virDomainDiskErrorPtr errors,
|
|
|
|
unsigned int maxerrors,
|
|
|
|
unsigned int flags);
|
2012-01-31 06:41:53 +00:00
|
|
|
|
2012-02-01 13:03:50 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainSetMetadata)(virDomainPtr dom,
|
|
|
|
int type,
|
|
|
|
const char *metadata,
|
|
|
|
const char *key,
|
|
|
|
const char *uri,
|
|
|
|
unsigned int flags);
|
2012-02-01 13:03:50 +00:00
|
|
|
|
|
|
|
typedef char *
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainGetMetadata)(virDomainPtr dom,
|
|
|
|
int type,
|
|
|
|
const char *uri,
|
|
|
|
unsigned int flags);
|
2012-02-01 13:03:50 +00:00
|
|
|
|
2012-09-14 14:42:14 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvNodeGetMemoryParameters)(virConnectPtr conn,
|
|
|
|
virTypedParameterPtr params,
|
|
|
|
int *nparams,
|
|
|
|
unsigned int flags);
|
2012-09-14 14:42:14 +00:00
|
|
|
|
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvNodeSetMemoryParameters)(virConnectPtr conn,
|
|
|
|
virTypedParameterPtr params,
|
|
|
|
int nparams,
|
|
|
|
unsigned int flags);
|
2012-09-14 14:42:14 +00:00
|
|
|
|
2012-10-23 20:34:53 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvNodeGetCPUMap)(virConnectPtr conn,
|
|
|
|
unsigned char **cpumap,
|
|
|
|
unsigned int *online,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2012-11-20 15:43:56 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainFSTrim)(virDomainPtr dom,
|
|
|
|
const char *mountPoint,
|
|
|
|
unsigned long long minimum,
|
|
|
|
unsigned int flags);
|
2012-10-23 20:34:53 +00:00
|
|
|
|
Introduce an LXC specific public API & library
This patch introduces support for LXC specific public APIs. In
common with what was done for QEMU, this creates a libvirt_lxc.so
library and libvirt/libvirt-lxc.h header file.
The actual APIs are
int virDomainLxcOpenNamespace(virDomainPtr domain,
int **fdlist,
unsigned int flags);
int virDomainLxcEnterNamespace(virDomainPtr domain,
unsigned int nfdlist,
int *fdlist,
unsigned int *noldfdlist,
int **oldfdlist,
unsigned int flags);
which provide a way to use the setns() system call to move the
calling process into the container's namespace. It is not
practical to write in a generically applicable manner. The
nearest that we could get to such an API would be an API which
allows to pass a command + argv to be executed inside a
container. Even if we had such a generic API, this LXC specific
API is still useful, because it allows the caller to maintain
the current process context, in particular any I/O streams they
have open.
NB the virDomainLxcEnterNamespace() API is special in that it
runs client side, so does not involve the internal driver API.
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
2012-12-21 13:15:19 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvDomainLxcOpenNamespace)(virDomainPtr dom,
|
|
|
|
int **fdlist,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2013-05-20 14:59:08 +00:00
|
|
|
typedef char *
|
|
|
|
(*virDrvDomainMigrateBegin3Params)(virDomainPtr domain,
|
|
|
|
virTypedParameterPtr params,
|
|
|
|
int nparams,
|
|
|
|
char **cookieout,
|
|
|
|
int *cookieoutlen,
|
|
|
|
unsigned int flags);
|
|
|
|
|
|
|
|
typedef int
|
|
|
|
(*virDrvDomainMigratePrepare3Params)(virConnectPtr dconn,
|
|
|
|
virTypedParameterPtr params,
|
|
|
|
int nparams,
|
|
|
|
const char *cookiein,
|
|
|
|
int cookieinlen,
|
|
|
|
char **cookieout,
|
|
|
|
int *cookieoutlen,
|
|
|
|
char **uri_out,
|
|
|
|
unsigned int flags);
|
|
|
|
|
|
|
|
typedef int
|
|
|
|
(*virDrvDomainMigratePrepareTunnel3Params)(virConnectPtr dconn,
|
|
|
|
virStreamPtr st,
|
|
|
|
virTypedParameterPtr params,
|
|
|
|
int nparams,
|
|
|
|
const char *cookiein,
|
|
|
|
int cookieinlen,
|
|
|
|
char **cookieout,
|
|
|
|
int *cookieoutlen,
|
|
|
|
unsigned int flags);
|
|
|
|
|
|
|
|
typedef int
|
|
|
|
(*virDrvDomainMigratePerform3Params)(virDomainPtr dom,
|
|
|
|
const char *dconnuri,
|
|
|
|
virTypedParameterPtr params,
|
|
|
|
int nparams,
|
|
|
|
const char *cookiein,
|
|
|
|
int cookieinlen,
|
|
|
|
char **cookieout,
|
|
|
|
int *cookieoutlen,
|
|
|
|
unsigned int flags);
|
|
|
|
|
|
|
|
typedef virDomainPtr
|
|
|
|
(*virDrvDomainMigrateFinish3Params)(virConnectPtr dconn,
|
|
|
|
virTypedParameterPtr params,
|
|
|
|
int nparams,
|
|
|
|
const char *cookiein,
|
|
|
|
int cookieinlen,
|
|
|
|
char **cookieout,
|
|
|
|
int *cookieoutlen,
|
|
|
|
unsigned int flags,
|
|
|
|
int cancelled);
|
|
|
|
|
|
|
|
typedef int
|
|
|
|
(*virDrvDomainMigrateConfirm3Params)(virDomainPtr domain,
|
|
|
|
virTypedParameterPtr params,
|
|
|
|
int nparams,
|
|
|
|
const char *cookiein,
|
|
|
|
int cookieinlen,
|
|
|
|
unsigned int flags,
|
|
|
|
int cancelled);
|
|
|
|
|
2013-04-23 09:49:27 +00:00
|
|
|
typedef struct _virDriver virDriver;
|
|
|
|
typedef virDriver *virDriverPtr;
|
Introduce an LXC specific public API & library
This patch introduces support for LXC specific public APIs. In
common with what was done for QEMU, this creates a libvirt_lxc.so
library and libvirt/libvirt-lxc.h header file.
The actual APIs are
int virDomainLxcOpenNamespace(virDomainPtr domain,
int **fdlist,
unsigned int flags);
int virDomainLxcEnterNamespace(virDomainPtr domain,
unsigned int nfdlist,
int *fdlist,
unsigned int *noldfdlist,
int **oldfdlist,
unsigned int flags);
which provide a way to use the setns() system call to move the
calling process into the container's namespace. It is not
practical to write in a generically applicable manner. The
nearest that we could get to such an API would be an API which
allows to pass a command + argv to be executed inside a
container. Even if we had such a generic API, this LXC specific
API is still useful, because it allows the caller to maintain
the current process context, in particular any I/O streams they
have open.
NB the virDomainLxcEnterNamespace() API is special in that it
runs client side, so does not involve the internal driver API.
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
2012-12-21 13:15:19 +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 {
|
2013-04-23 09:49:27 +00:00
|
|
|
int no; /* the number virDrvNo */
|
|
|
|
const char *name; /* the name of the driver */
|
|
|
|
virDrvConnectOpen connectOpen;
|
|
|
|
virDrvConnectClose connectClose;
|
|
|
|
virDrvConnectSupportsFeature connectSupportsFeature;
|
|
|
|
virDrvConnectGetType connectGetType;
|
|
|
|
virDrvConnectGetVersion connectGetVersion;
|
|
|
|
virDrvConnectGetLibVersion connectGetLibVersion;
|
|
|
|
virDrvConnectGetHostname connectGetHostname;
|
|
|
|
virDrvConnectGetSysinfo connectGetSysinfo;
|
|
|
|
virDrvConnectGetMaxVcpus connectGetMaxVcpus;
|
|
|
|
virDrvNodeGetInfo nodeGetInfo;
|
|
|
|
virDrvConnectGetCapabilities connectGetCapabilities;
|
|
|
|
virDrvConnectListDomains connectListDomains;
|
|
|
|
virDrvConnectNumOfDomains connectNumOfDomains;
|
|
|
|
virDrvConnectListAllDomains connectListAllDomains;
|
|
|
|
virDrvDomainCreateXML domainCreateXML;
|
Introduce new domain create APIs to pass pre-opened FDs to LXC
With container based virt, it is useful to be able to pass
pre-opened file descriptors to the container init process.
This allows for containers to be auto-activated from incoming
socket connections, passing the active socket into the container.
To do this, introduce a pair of new APIs, virDomainCreateXMLWithFiles
and virDomainCreateWithFiles, which accept an array of file
descriptors. For the LXC driver, UNIX file descriptor passing
will be used to send them to libvirtd, which will them pass
them down to libvirt_lxc, which will then pass them to the container
init process.
This will only be implemented for LXC right now, but the design
is generic enough it could work with other hypervisors, hence
I suggest adding this to libvirt.so, rather than libvirt-lxc.so
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
2013-07-09 16:12:38 +00:00
|
|
|
virDrvDomainCreateXMLWithFiles domainCreateXMLWithFiles;
|
2013-04-23 09:49:27 +00:00
|
|
|
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;
|
2013-07-08 14:22:38 +00:00
|
|
|
virDrvDomainSetMemoryStatsPeriod domainSetMemoryStatsPeriod;
|
2013-04-23 09:49:27 +00:00
|
|
|
virDrvDomainSetMemoryParameters domainSetMemoryParameters;
|
|
|
|
virDrvDomainGetMemoryParameters domainGetMemoryParameters;
|
|
|
|
virDrvDomainSetNumaParameters domainSetNumaParameters;
|
|
|
|
virDrvDomainGetNumaParameters domainGetNumaParameters;
|
|
|
|
virDrvDomainSetBlkioParameters domainSetBlkioParameters;
|
|
|
|
virDrvDomainGetBlkioParameters domainGetBlkioParameters;
|
|
|
|
virDrvDomainGetInfo domainGetInfo;
|
|
|
|
virDrvDomainGetState domainGetState;
|
|
|
|
virDrvDomainGetControlInfo domainGetControlInfo;
|
|
|
|
virDrvDomainSave domainSave;
|
|
|
|
virDrvDomainSaveFlags domainSaveFlags;
|
|
|
|
virDrvDomainRestore domainRestore;
|
|
|
|
virDrvDomainRestoreFlags domainRestoreFlags;
|
|
|
|
virDrvDomainSaveImageGetXMLDesc domainSaveImageGetXMLDesc;
|
|
|
|
virDrvDomainSaveImageDefineXML domainSaveImageDefineXML;
|
|
|
|
virDrvDomainCoreDump domainCoreDump;
|
|
|
|
virDrvDomainScreenshot domainScreenshot;
|
|
|
|
virDrvDomainSetVcpus domainSetVcpus;
|
|
|
|
virDrvDomainSetVcpusFlags domainSetVcpusFlags;
|
|
|
|
virDrvDomainGetVcpusFlags domainGetVcpusFlags;
|
|
|
|
virDrvDomainPinVcpu domainPinVcpu;
|
|
|
|
virDrvDomainPinVcpuFlags domainPinVcpuFlags;
|
|
|
|
virDrvDomainGetVcpuPinInfo domainGetVcpuPinInfo;
|
|
|
|
virDrvDomainPinEmulator domainPinEmulator;
|
|
|
|
virDrvDomainGetEmulatorPinInfo domainGetEmulatorPinInfo;
|
|
|
|
virDrvDomainGetVcpus domainGetVcpus;
|
|
|
|
virDrvDomainGetMaxVcpus domainGetMaxVcpus;
|
|
|
|
virDrvDomainGetSecurityLabel domainGetSecurityLabel;
|
|
|
|
virDrvDomainGetSecurityLabelList domainGetSecurityLabelList;
|
|
|
|
virDrvNodeGetSecurityModel nodeGetSecurityModel;
|
|
|
|
virDrvDomainGetXMLDesc domainGetXMLDesc;
|
|
|
|
virDrvConnectDomainXMLFromNative connectDomainXMLFromNative;
|
|
|
|
virDrvConnectDomainXMLToNative connectDomainXMLToNative;
|
|
|
|
virDrvConnectListDefinedDomains connectListDefinedDomains;
|
|
|
|
virDrvConnectNumOfDefinedDomains connectNumOfDefinedDomains;
|
|
|
|
virDrvDomainCreate domainCreate;
|
|
|
|
virDrvDomainCreateWithFlags domainCreateWithFlags;
|
Introduce new domain create APIs to pass pre-opened FDs to LXC
With container based virt, it is useful to be able to pass
pre-opened file descriptors to the container init process.
This allows for containers to be auto-activated from incoming
socket connections, passing the active socket into the container.
To do this, introduce a pair of new APIs, virDomainCreateXMLWithFiles
and virDomainCreateWithFiles, which accept an array of file
descriptors. For the LXC driver, UNIX file descriptor passing
will be used to send them to libvirtd, which will them pass
them down to libvirt_lxc, which will then pass them to the container
init process.
This will only be implemented for LXC right now, but the design
is generic enough it could work with other hypervisors, hence
I suggest adding this to libvirt.so, rather than libvirt-lxc.so
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
2013-07-09 16:12:38 +00:00
|
|
|
virDrvDomainCreateWithFiles domainCreateWithFiles;
|
2013-04-23 09:49:27 +00:00
|
|
|
virDrvDomainDefineXML domainDefineXML;
|
|
|
|
virDrvDomainUndefine domainUndefine;
|
|
|
|
virDrvDomainUndefineFlags domainUndefineFlags;
|
|
|
|
virDrvDomainAttachDevice domainAttachDevice;
|
|
|
|
virDrvDomainAttachDeviceFlags domainAttachDeviceFlags;
|
|
|
|
virDrvDomainDetachDevice domainDetachDevice;
|
|
|
|
virDrvDomainDetachDeviceFlags domainDetachDeviceFlags;
|
|
|
|
virDrvDomainUpdateDeviceFlags domainUpdateDeviceFlags;
|
|
|
|
virDrvDomainGetAutostart domainGetAutostart;
|
|
|
|
virDrvDomainSetAutostart domainSetAutostart;
|
|
|
|
virDrvDomainGetSchedulerType domainGetSchedulerType;
|
|
|
|
virDrvDomainGetSchedulerParameters domainGetSchedulerParameters;
|
2011-05-17 21:17:14 +00:00
|
|
|
virDrvDomainGetSchedulerParametersFlags domainGetSchedulerParametersFlags;
|
2013-04-23 09:49:27 +00:00
|
|
|
virDrvDomainSetSchedulerParameters domainSetSchedulerParameters;
|
2011-05-17 06:20:00 +00:00
|
|
|
virDrvDomainSetSchedulerParametersFlags domainSetSchedulerParametersFlags;
|
2013-04-23 09:49:27 +00:00
|
|
|
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;
|
|
|
|
virDrvConnectDomainEventRegister connectDomainEventRegister;
|
|
|
|
virDrvConnectDomainEventDeregister connectDomainEventDeregister;
|
|
|
|
virDrvDomainMigratePrepare2 domainMigratePrepare2;
|
|
|
|
virDrvDomainMigrateFinish2 domainMigrateFinish2;
|
|
|
|
virDrvNodeDeviceDettach nodeDeviceDettach;
|
2013-04-24 16:56:10 +00:00
|
|
|
virDrvNodeDeviceDetachFlags nodeDeviceDetachFlags;
|
2013-04-23 09:49:27 +00:00
|
|
|
virDrvNodeDeviceReAttach nodeDeviceReAttach;
|
|
|
|
virDrvNodeDeviceReset nodeDeviceReset;
|
|
|
|
virDrvDomainMigratePrepareTunnel domainMigratePrepareTunnel;
|
|
|
|
virDrvConnectIsEncrypted connectIsEncrypted;
|
|
|
|
virDrvConnectIsSecure connectIsSecure;
|
|
|
|
virDrvDomainIsActive domainIsActive;
|
|
|
|
virDrvDomainIsPersistent domainIsPersistent;
|
|
|
|
virDrvDomainIsUpdated domainIsUpdated;
|
|
|
|
virDrvConnectCompareCPU connectCompareCPU;
|
|
|
|
virDrvConnectBaselineCPU connectBaselineCPU;
|
|
|
|
virDrvDomainGetJobInfo domainGetJobInfo;
|
|
|
|
virDrvDomainGetJobStats domainGetJobStats;
|
|
|
|
virDrvDomainAbortJob domainAbortJob;
|
|
|
|
virDrvDomainMigrateSetMaxDowntime domainMigrateSetMaxDowntime;
|
2013-02-18 16:31:08 +00:00
|
|
|
virDrvDomainMigrateGetCompressionCache domainMigrateGetCompressionCache;
|
|
|
|
virDrvDomainMigrateSetCompressionCache domainMigrateSetCompressionCache;
|
2013-04-23 09:49:27 +00:00
|
|
|
virDrvDomainMigrateGetMaxSpeed domainMigrateGetMaxSpeed;
|
|
|
|
virDrvDomainMigrateSetMaxSpeed domainMigrateSetMaxSpeed;
|
|
|
|
virDrvConnectDomainEventRegisterAny connectDomainEventRegisterAny;
|
|
|
|
virDrvConnectDomainEventDeregisterAny connectDomainEventDeregisterAny;
|
|
|
|
virDrvDomainManagedSave domainManagedSave;
|
|
|
|
virDrvDomainHasManagedSaveImage domainHasManagedSaveImage;
|
|
|
|
virDrvDomainManagedSaveRemove domainManagedSaveRemove;
|
|
|
|
virDrvDomainSnapshotCreateXML domainSnapshotCreateXML;
|
|
|
|
virDrvDomainSnapshotGetXMLDesc domainSnapshotGetXMLDesc;
|
|
|
|
virDrvDomainSnapshotNum domainSnapshotNum;
|
|
|
|
virDrvDomainSnapshotListNames domainSnapshotListNames;
|
|
|
|
virDrvDomainListAllSnapshots domainListAllSnapshots;
|
|
|
|
virDrvDomainSnapshotNumChildren domainSnapshotNumChildren;
|
2011-09-25 01:56:26 +00:00
|
|
|
virDrvDomainSnapshotListChildrenNames domainSnapshotListChildrenNames;
|
2012-05-23 16:40:50 +00:00
|
|
|
virDrvDomainSnapshotListAllChildren domainSnapshotListAllChildren;
|
2013-04-23 09:49:27 +00:00
|
|
|
virDrvDomainSnapshotLookupByName domainSnapshotLookupByName;
|
|
|
|
virDrvDomainHasCurrentSnapshot domainHasCurrentSnapshot;
|
|
|
|
virDrvDomainSnapshotGetParent domainSnapshotGetParent;
|
|
|
|
virDrvDomainSnapshotCurrent domainSnapshotCurrent;
|
|
|
|
virDrvDomainSnapshotIsCurrent domainSnapshotIsCurrent;
|
|
|
|
virDrvDomainSnapshotHasMetadata domainSnapshotHasMetadata;
|
|
|
|
virDrvDomainRevertToSnapshot domainRevertToSnapshot;
|
|
|
|
virDrvDomainSnapshotDelete domainSnapshotDelete;
|
|
|
|
virDrvDomainQemuMonitorCommand domainQemuMonitorCommand;
|
|
|
|
virDrvDomainQemuAttach domainQemuAttach;
|
|
|
|
virDrvDomainQemuAgentCommand domainQemuAgentCommand;
|
|
|
|
virDrvDomainOpenConsole domainOpenConsole;
|
|
|
|
virDrvDomainOpenChannel domainOpenChannel;
|
|
|
|
virDrvDomainOpenGraphics domainOpenGraphics;
|
|
|
|
virDrvDomainInjectNMI domainInjectNMI;
|
|
|
|
virDrvDomainMigrateBegin3 domainMigrateBegin3;
|
|
|
|
virDrvDomainMigratePrepare3 domainMigratePrepare3;
|
|
|
|
virDrvDomainMigratePrepareTunnel3 domainMigratePrepareTunnel3;
|
|
|
|
virDrvDomainMigratePerform3 domainMigratePerform3;
|
|
|
|
virDrvDomainMigrateFinish3 domainMigrateFinish3;
|
|
|
|
virDrvDomainMigrateConfirm3 domainMigrateConfirm3;
|
|
|
|
virDrvDomainSendKey domainSendKey;
|
|
|
|
virDrvDomainBlockJobAbort domainBlockJobAbort;
|
|
|
|
virDrvDomainGetBlockJobInfo domainGetBlockJobInfo;
|
|
|
|
virDrvDomainBlockJobSetSpeed domainBlockJobSetSpeed;
|
|
|
|
virDrvDomainBlockPull domainBlockPull;
|
|
|
|
virDrvDomainBlockRebase domainBlockRebase;
|
|
|
|
virDrvDomainBlockCommit domainBlockCommit;
|
|
|
|
virDrvConnectSetKeepAlive connectSetKeepAlive;
|
|
|
|
virDrvConnectIsAlive connectIsAlive;
|
|
|
|
virDrvNodeSuspendForDuration nodeSuspendForDuration;
|
|
|
|
virDrvDomainSetBlockIoTune domainSetBlockIoTune;
|
|
|
|
virDrvDomainGetBlockIoTune domainGetBlockIoTune;
|
|
|
|
virDrvDomainGetCPUStats domainGetCPUStats;
|
|
|
|
virDrvDomainGetDiskErrors domainGetDiskErrors;
|
|
|
|
virDrvDomainSetMetadata domainSetMetadata;
|
|
|
|
virDrvDomainGetMetadata domainGetMetadata;
|
|
|
|
virDrvNodeGetMemoryParameters nodeGetMemoryParameters;
|
|
|
|
virDrvNodeSetMemoryParameters nodeSetMemoryParameters;
|
|
|
|
virDrvNodeGetCPUMap nodeGetCPUMap;
|
|
|
|
virDrvDomainFSTrim domainFSTrim;
|
|
|
|
virDrvDomainSendProcessSignal domainSendProcessSignal;
|
|
|
|
virDrvDomainLxcOpenNamespace domainLxcOpenNamespace;
|
2013-05-20 14:59:08 +00:00
|
|
|
virDrvDomainMigrateBegin3Params domainMigrateBegin3Params;
|
|
|
|
virDrvDomainMigratePrepare3Params domainMigratePrepare3Params;
|
|
|
|
virDrvDomainMigratePrepareTunnel3Params domainMigratePrepareTunnel3Params;
|
|
|
|
virDrvDomainMigratePerform3Params domainMigratePerform3Params;
|
|
|
|
virDrvDomainMigrateFinish3Params domainMigrateFinish3Params;
|
|
|
|
virDrvDomainMigrateConfirm3Params domainMigrateConfirm3Params;
|
2013-09-23 09:45:58 +00:00
|
|
|
virDrvConnectGetCPUModelNames connectGetCPUModelNames;
|
2006-03-20 17:49:28 +00:00
|
|
|
};
|
|
|
|
|
2013-04-23 12:49:21 +00:00
|
|
|
|
|
|
|
typedef virDrvConnectOpen virDrvNetworkOpen;
|
|
|
|
typedef virDrvConnectClose virDrvNetworkClose;
|
|
|
|
|
2007-02-14 15:37:18 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectNumOfNetworks)(virConnectPtr conn);
|
|
|
|
|
2007-02-14 15:37:18 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectListNetworks)(virConnectPtr conn,
|
|
|
|
char **const names,
|
|
|
|
int maxnames);
|
|
|
|
|
2007-02-14 15:37:18 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectNumOfDefinedNetworks)(virConnectPtr conn);
|
|
|
|
|
2007-02-14 15:37:18 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectListDefinedNetworks)(virConnectPtr conn,
|
|
|
|
char **const names,
|
|
|
|
int maxnames);
|
|
|
|
|
2012-09-04 15:55:15 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectListAllNetworks)(virConnectPtr conn,
|
|
|
|
virNetworkPtr **nets,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2013-12-11 10:37:58 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvConnectNetworkEventRegisterAny)(virConnectPtr conn,
|
|
|
|
virNetworkPtr dom,
|
|
|
|
int eventID,
|
|
|
|
virConnectNetworkEventGenericCallback cb,
|
|
|
|
void *opaque,
|
|
|
|
virFreeCallback freecb);
|
|
|
|
|
|
|
|
typedef int
|
|
|
|
(*virDrvConnectNetworkEventDeregisterAny)(virConnectPtr conn,
|
|
|
|
int callbackID);
|
|
|
|
|
2007-02-14 15:37:18 +00:00
|
|
|
typedef virNetworkPtr
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvNetworkLookupByUUID)(virConnectPtr conn,
|
|
|
|
const unsigned char *uuid);
|
|
|
|
|
2007-02-14 15:37:18 +00:00
|
|
|
typedef virNetworkPtr
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvNetworkLookupByName)(virConnectPtr conn,
|
|
|
|
const char *name);
|
|
|
|
|
2007-02-14 15:37:18 +00:00
|
|
|
typedef virNetworkPtr
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvNetworkCreateXML)(virConnectPtr conn,
|
|
|
|
const char *xmlDesc);
|
|
|
|
|
2007-02-14 15:37:18 +00:00
|
|
|
typedef virNetworkPtr
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvNetworkDefineXML)(virConnectPtr conn,
|
|
|
|
const char *xml);
|
|
|
|
|
2007-02-14 15:37:18 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvNetworkUndefine)(virNetworkPtr network);
|
|
|
|
|
2012-08-20 03:35:47 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvNetworkUpdate)(virNetworkPtr network,
|
|
|
|
unsigned int command, /* virNetworkUpdateCommand */
|
|
|
|
unsigned int section, /* virNetworkUpdateSection */
|
|
|
|
int parentIndex,
|
|
|
|
const char *xml,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2007-02-14 15:37:18 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvNetworkCreate)(virNetworkPtr network);
|
|
|
|
|
2007-02-14 15:37:18 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvNetworkDestroy)(virNetworkPtr network);
|
|
|
|
|
2007-02-14 15:37:18 +00:00
|
|
|
typedef char *
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvNetworkGetXMLDesc)(virNetworkPtr network,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2007-02-14 16:20:38 +00:00
|
|
|
typedef char *
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvNetworkGetBridgeName)(virNetworkPtr network);
|
|
|
|
|
2007-02-23 08:51:30 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvNetworkGetAutostart)(virNetworkPtr network,
|
|
|
|
int *autostart);
|
|
|
|
|
2007-02-23 08:51:30 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +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
|
2013-04-23 09:49:27 +00:00
|
|
|
(*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
|
2013-04-23 09:49:27 +00:00
|
|
|
(*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
|
|
|
|
|
|
|
|
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 {
|
2013-04-23 09:49:27 +00:00
|
|
|
const char * name; /* the name of the driver */
|
2013-04-23 12:49:21 +00:00
|
|
|
virDrvNetworkOpen networkOpen;
|
|
|
|
virDrvNetworkClose networkClose;
|
2013-04-23 09:49:27 +00:00
|
|
|
virDrvConnectNumOfNetworks connectNumOfNetworks;
|
|
|
|
virDrvConnectListNetworks connectListNetworks;
|
|
|
|
virDrvConnectNumOfDefinedNetworks connectNumOfDefinedNetworks;
|
|
|
|
virDrvConnectListDefinedNetworks connectListDefinedNetworks;
|
|
|
|
virDrvConnectListAllNetworks connectListAllNetworks;
|
2013-12-11 10:37:58 +00:00
|
|
|
virDrvConnectNetworkEventRegisterAny connectNetworkEventRegisterAny;
|
|
|
|
virDrvConnectNetworkEventDeregisterAny connectNetworkEventDeregisterAny;
|
2013-04-23 09:49:27 +00:00
|
|
|
virDrvNetworkLookupByUUID networkLookupByUUID;
|
|
|
|
virDrvNetworkLookupByName networkLookupByName;
|
|
|
|
virDrvNetworkCreateXML networkCreateXML;
|
|
|
|
virDrvNetworkDefineXML networkDefineXML;
|
|
|
|
virDrvNetworkUndefine networkUndefine;
|
|
|
|
virDrvNetworkUpdate networkUpdate;
|
|
|
|
virDrvNetworkCreate networkCreate;
|
|
|
|
virDrvNetworkDestroy networkDestroy;
|
|
|
|
virDrvNetworkGetXMLDesc networkGetXMLDesc;
|
|
|
|
virDrvNetworkGetBridgeName networkGetBridgeName;
|
|
|
|
virDrvNetworkGetAutostart networkGetAutostart;
|
|
|
|
virDrvNetworkSetAutostart networkSetAutostart;
|
|
|
|
virDrvNetworkIsActive networkIsActive;
|
|
|
|
virDrvNetworkIsPersistent networkIsPersistent;
|
2007-02-14 15:37:18 +00:00
|
|
|
};
|
|
|
|
|
2013-04-23 09:49:27 +00:00
|
|
|
|
2013-04-23 12:49:21 +00:00
|
|
|
typedef virDrvConnectOpen virDrvInterfaceOpen;
|
|
|
|
typedef virDrvConnectClose virDrvInterfaceClose;
|
|
|
|
|
2009-05-20 14:26:49 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectNumOfInterfaces)(virConnectPtr conn);
|
|
|
|
|
2009-05-20 14:26:49 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectListInterfaces)(virConnectPtr conn,
|
|
|
|
char **const names,
|
|
|
|
int maxnames);
|
|
|
|
|
2009-07-16 15:58:15 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectNumOfDefinedInterfaces)(virConnectPtr conn);
|
|
|
|
|
2009-07-16 15:58:15 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectListDefinedInterfaces)(virConnectPtr conn,
|
|
|
|
char **const names,
|
|
|
|
int maxnames);
|
|
|
|
|
2012-09-04 16:10:15 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectListAllInterfaces)(virConnectPtr conn,
|
|
|
|
virInterfacePtr **ifaces,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2009-05-20 14:26:49 +00:00
|
|
|
typedef virInterfacePtr
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvInterfaceLookupByName)(virConnectPtr conn,
|
|
|
|
const char *name);
|
|
|
|
|
2009-05-20 14:26:49 +00:00
|
|
|
typedef virInterfacePtr
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvInterfaceLookupByMACString)(virConnectPtr conn,
|
|
|
|
const char *mac);
|
2009-05-20 14:26:49 +00:00
|
|
|
|
|
|
|
typedef char *
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvInterfaceGetXMLDesc)(virInterfacePtr iface,
|
|
|
|
unsigned int flags);
|
2009-05-20 14:26:49 +00:00
|
|
|
|
|
|
|
typedef virInterfacePtr
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvInterfaceDefineXML)(virConnectPtr conn,
|
|
|
|
const char *xmlDesc,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2009-05-20 14:26:49 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvInterfaceUndefine)(virInterfacePtr iface);
|
|
|
|
|
2009-05-20 14:26:49 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvInterfaceCreate)(virInterfacePtr iface,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2009-05-20 14:26:49 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvInterfaceDestroy)(virInterfacePtr iface,
|
|
|
|
unsigned int flags);
|
2009-05-20 14:26:49 +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
|
2013-04-23 09:49:27 +00:00
|
|
|
(*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
|
|
|
|
2011-05-05 10:06:53 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvInterfaceChangeBegin)(virConnectPtr conn,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2011-05-05 10:06:53 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvInterfaceChangeCommit)(virConnectPtr conn,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2011-05-05 10:06:53 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*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
|
|
|
|
2009-05-20 14:26:49 +00:00
|
|
|
typedef struct _virInterfaceDriver virInterfaceDriver;
|
|
|
|
typedef virInterfaceDriver *virInterfaceDriverPtr;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* _virInterfaceDriver:
|
|
|
|
*
|
2011-07-22 15:53:16 +00:00
|
|
|
* Structure associated to a network interface driver, defining the various
|
2009-05-20 14:26:49 +00:00
|
|
|
* entry points for it.
|
|
|
|
*
|
|
|
|
* All drivers must support the following fields/methods:
|
|
|
|
* - open
|
|
|
|
* - close
|
|
|
|
*/
|
|
|
|
struct _virInterfaceDriver {
|
2013-04-23 09:49:27 +00:00
|
|
|
const char *name; /* the name of the driver */
|
2013-04-23 12:49:21 +00:00
|
|
|
virDrvInterfaceOpen interfaceOpen;
|
|
|
|
virDrvInterfaceClose interfaceClose;
|
2013-04-23 09:49:27 +00:00
|
|
|
virDrvConnectNumOfInterfaces connectNumOfInterfaces;
|
|
|
|
virDrvConnectListInterfaces connectListInterfaces;
|
|
|
|
virDrvConnectNumOfDefinedInterfaces connectNumOfDefinedInterfaces;
|
|
|
|
virDrvConnectListDefinedInterfaces connectListDefinedInterfaces;
|
|
|
|
virDrvConnectListAllInterfaces connectListAllInterfaces;
|
|
|
|
virDrvInterfaceLookupByName interfaceLookupByName;
|
2009-05-20 14:26:49 +00:00
|
|
|
virDrvInterfaceLookupByMACString interfaceLookupByMACString;
|
2013-04-23 09:49:27 +00:00
|
|
|
virDrvInterfaceGetXMLDesc interfaceGetXMLDesc;
|
|
|
|
virDrvInterfaceDefineXML interfaceDefineXML;
|
|
|
|
virDrvInterfaceUndefine interfaceUndefine;
|
|
|
|
virDrvInterfaceCreate interfaceCreate;
|
|
|
|
virDrvInterfaceDestroy interfaceDestroy;
|
|
|
|
virDrvInterfaceIsActive interfaceIsActive;
|
|
|
|
virDrvInterfaceChangeBegin interfaceChangeBegin;
|
|
|
|
virDrvInterfaceChangeCommit interfaceChangeCommit;
|
|
|
|
virDrvInterfaceChangeRollback interfaceChangeRollback;
|
2009-05-20 14:26:49 +00:00
|
|
|
};
|
|
|
|
|
2008-02-20 15:06:53 +00:00
|
|
|
|
2013-04-23 12:49:21 +00:00
|
|
|
typedef virDrvConnectOpen virDrvStorageOpen;
|
|
|
|
typedef virDrvConnectClose virDrvStorageClose;
|
|
|
|
|
|
|
|
|
2008-02-20 15:06:53 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectNumOfStoragePools)(virConnectPtr conn);
|
|
|
|
|
2008-02-20 15:06:53 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectListStoragePools)(virConnectPtr conn,
|
|
|
|
char **const names,
|
|
|
|
int maxnames);
|
|
|
|
|
2008-02-20 15:06:53 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectNumOfDefinedStoragePools)(virConnectPtr conn);
|
|
|
|
|
2008-02-20 15:06:53 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectListDefinedStoragePools)(virConnectPtr conn,
|
|
|
|
char **const names,
|
|
|
|
int maxnames);
|
|
|
|
|
2012-09-04 15:16:24 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectListAllStoragePools)(virConnectPtr conn,
|
|
|
|
virStoragePoolPtr **pools,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2008-08-27 20:05:58 +00:00
|
|
|
typedef char *
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectFindStoragePoolSources)(virConnectPtr conn,
|
|
|
|
const char *type,
|
|
|
|
const char *srcSpec,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2008-02-20 15:06:53 +00:00
|
|
|
typedef virStoragePoolPtr
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvStoragePoolLookupByName)(virConnectPtr conn,
|
|
|
|
const char *name);
|
|
|
|
|
2008-02-20 15:06:53 +00:00
|
|
|
typedef virStoragePoolPtr
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvStoragePoolLookupByUUID)(virConnectPtr conn,
|
|
|
|
const unsigned char *uuid);
|
|
|
|
|
2008-02-20 15:06:53 +00:00
|
|
|
typedef virStoragePoolPtr
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvStoragePoolLookupByVolume)(virStorageVolPtr vol);
|
|
|
|
|
2008-02-20 15:06:53 +00:00
|
|
|
typedef virStoragePoolPtr
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvStoragePoolCreateXML)(virConnectPtr conn,
|
|
|
|
const char *xmlDesc,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2008-02-20 15:06:53 +00:00
|
|
|
typedef virStoragePoolPtr
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvStoragePoolDefineXML)(virConnectPtr conn,
|
|
|
|
const char *xmlDesc,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2008-02-20 15:06:53 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvStoragePoolUndefine)(virStoragePoolPtr pool);
|
|
|
|
|
2008-02-20 15:06:53 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvStoragePoolBuild)(virStoragePoolPtr pool,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2008-02-20 15:06:53 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvStoragePoolCreate)(virStoragePoolPtr pool,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2008-02-20 15:06:53 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvStoragePoolDestroy)(virStoragePoolPtr pool);
|
|
|
|
|
2008-02-20 15:06:53 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvStoragePoolDelete)(virStoragePoolPtr pool,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2008-02-20 15:06:53 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvStoragePoolRefresh)(virStoragePoolPtr pool,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2008-02-20 15:06:53 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvStoragePoolGetInfo)(virStoragePoolPtr vol,
|
|
|
|
virStoragePoolInfoPtr info);
|
|
|
|
|
2008-02-20 15:06:53 +00:00
|
|
|
typedef char *
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvStoragePoolGetXMLDesc)(virStoragePoolPtr pool,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2008-02-20 15:06:53 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvStoragePoolGetAutostart)(virStoragePoolPtr pool,
|
|
|
|
int *autostart);
|
|
|
|
|
2008-02-20 15:06:53 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvStoragePoolSetAutostart)(virStoragePoolPtr pool,
|
|
|
|
int autostart);
|
|
|
|
|
2008-02-20 15:06:53 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvStoragePoolNumOfVolumes)(virStoragePoolPtr pool);
|
|
|
|
|
2008-02-20 15:06:53 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvStoragePoolListVolumes)(virStoragePoolPtr pool,
|
|
|
|
char **const names,
|
|
|
|
int maxnames);
|
|
|
|
|
2012-09-04 15:32:53 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvStoragePoolListAllVolumes)(virStoragePoolPtr pool,
|
|
|
|
virStorageVolPtr **vols,
|
|
|
|
unsigned int flags);
|
2008-02-20 15:06:53 +00:00
|
|
|
|
|
|
|
typedef virStorageVolPtr
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvStorageVolLookupByName)(virStoragePoolPtr pool,
|
|
|
|
const char *name);
|
|
|
|
|
2008-02-20 15:06:53 +00:00
|
|
|
typedef virStorageVolPtr
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvStorageVolLookupByKey)(virConnectPtr pool,
|
|
|
|
const char *key);
|
2008-02-20 15:06:53 +00:00
|
|
|
|
2013-04-23 09:49:27 +00:00
|
|
|
typedef virStorageVolPtr
|
|
|
|
(*virDrvStorageVolLookupByPath)(virConnectPtr pool,
|
|
|
|
const char *path);
|
2008-02-20 15:06:53 +00:00
|
|
|
|
|
|
|
typedef virStorageVolPtr
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvStorageVolCreateXML)(virStoragePoolPtr pool,
|
|
|
|
const char *xmldesc,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2008-02-20 15:06:53 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvStorageVolDelete)(virStorageVolPtr vol,
|
|
|
|
unsigned int flags);
|
2008-02-20 15:06:53 +00:00
|
|
|
|
2010-03-01 20:15:16 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvStorageVolWipe)(virStorageVolPtr vol,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2012-01-09 16:05:03 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvStorageVolWipePattern)(virStorageVolPtr vol,
|
|
|
|
unsigned int algorithm,
|
|
|
|
unsigned int flags);
|
2010-03-01 20:15:16 +00:00
|
|
|
|
2008-02-20 15:06:53 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvStorageVolGetInfo)(virStorageVolPtr vol,
|
|
|
|
virStorageVolInfoPtr info);
|
|
|
|
|
2008-02-20 15:06:53 +00:00
|
|
|
typedef char *
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvStorageVolGetXMLDesc)(virStorageVolPtr pool,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2008-02-20 15:06:53 +00:00
|
|
|
typedef char *
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvStorageVolGetPath)(virStorageVolPtr vol);
|
2008-02-20 15:06:53 +00:00
|
|
|
|
2009-05-12 20:10:50 +00:00
|
|
|
typedef virStorageVolPtr
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvStorageVolCreateXMLFrom)(virStoragePoolPtr pool,
|
|
|
|
const char *xmldesc,
|
|
|
|
virStorageVolPtr clonevol,
|
2009-07-14 13:24:27 +00:00
|
|
|
unsigned int flags);
|
2013-04-23 09:49:27 +00:00
|
|
|
|
2009-07-14 13:24:27 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvStorageVolDownload)(virStorageVolPtr vol,
|
|
|
|
virStreamPtr stream,
|
|
|
|
unsigned long long offset,
|
|
|
|
unsigned long long length,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2012-01-27 05:29:56 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvStorageVolUpload)(virStorageVolPtr vol,
|
|
|
|
virStreamPtr stream,
|
|
|
|
unsigned long long offset,
|
|
|
|
unsigned long long length,
|
|
|
|
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
|
2013-04-23 09:49:27 +00:00
|
|
|
(*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
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvStoragePoolIsActive)(virStoragePoolPtr pool);
|
|
|
|
|
|
|
|
typedef int
|
|
|
|
(*virDrvStoragePoolIsPersistent)(virStoragePoolPtr pool);
|
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
|
|
|
|
|
|
|
|
2008-02-20 15:06:53 +00:00
|
|
|
|
|
|
|
typedef struct _virStorageDriver virStorageDriver;
|
|
|
|
typedef virStorageDriver *virStorageDriverPtr;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* _virStorageDriver:
|
|
|
|
*
|
2011-07-22 15:53:16 +00:00
|
|
|
* Structure associated to a storage driver, defining the various
|
2008-02-20 15:06:53 +00:00
|
|
|
* entry points for it.
|
|
|
|
*
|
|
|
|
* All drivers must support the following fields/methods:
|
|
|
|
* - open
|
|
|
|
* - close
|
|
|
|
*/
|
|
|
|
struct _virStorageDriver {
|
2013-04-23 09:49:27 +00:00
|
|
|
const char * name; /* the name of the driver */
|
2013-04-23 12:49:21 +00:00
|
|
|
virDrvStorageOpen storageOpen;
|
|
|
|
virDrvStorageClose storageClose;
|
2013-04-23 09:49:27 +00:00
|
|
|
virDrvConnectNumOfStoragePools connectNumOfStoragePools;
|
|
|
|
virDrvConnectListStoragePools connectListStoragePools;
|
|
|
|
virDrvConnectNumOfDefinedStoragePools connectNumOfDefinedStoragePools;
|
|
|
|
virDrvConnectListDefinedStoragePools connectListDefinedStoragePools;
|
|
|
|
virDrvConnectListAllStoragePools connectListAllStoragePools;
|
|
|
|
virDrvConnectFindStoragePoolSources connectFindStoragePoolSources;
|
|
|
|
virDrvStoragePoolLookupByName storagePoolLookupByName;
|
|
|
|
virDrvStoragePoolLookupByUUID storagePoolLookupByUUID;
|
|
|
|
virDrvStoragePoolLookupByVolume storagePoolLookupByVolume;
|
|
|
|
virDrvStoragePoolCreateXML storagePoolCreateXML;
|
|
|
|
virDrvStoragePoolDefineXML storagePoolDefineXML;
|
|
|
|
virDrvStoragePoolBuild storagePoolBuild;
|
|
|
|
virDrvStoragePoolUndefine storagePoolUndefine;
|
|
|
|
virDrvStoragePoolCreate storagePoolCreate;
|
|
|
|
virDrvStoragePoolDestroy storagePoolDestroy;
|
|
|
|
virDrvStoragePoolDelete storagePoolDelete;
|
|
|
|
virDrvStoragePoolRefresh storagePoolRefresh;
|
|
|
|
virDrvStoragePoolGetInfo storagePoolGetInfo;
|
|
|
|
virDrvStoragePoolGetXMLDesc storagePoolGetXMLDesc;
|
|
|
|
virDrvStoragePoolGetAutostart storagePoolGetAutostart;
|
|
|
|
virDrvStoragePoolSetAutostart storagePoolSetAutostart;
|
|
|
|
virDrvStoragePoolNumOfVolumes storagePoolNumOfVolumes;
|
|
|
|
virDrvStoragePoolListVolumes storagePoolListVolumes;
|
|
|
|
virDrvStoragePoolListAllVolumes storagePoolListAllVolumes;
|
|
|
|
virDrvStorageVolLookupByName storageVolLookupByName;
|
|
|
|
virDrvStorageVolLookupByKey storageVolLookupByKey;
|
|
|
|
virDrvStorageVolLookupByPath storageVolLookupByPath;
|
|
|
|
virDrvStorageVolCreateXML storageVolCreateXML;
|
|
|
|
virDrvStorageVolCreateXMLFrom storageVolCreateXMLFrom;
|
|
|
|
virDrvStorageVolDownload storageVolDownload;
|
|
|
|
virDrvStorageVolUpload storageVolUpload;
|
|
|
|
virDrvStorageVolDelete storageVolDelete;
|
|
|
|
virDrvStorageVolWipe storageVolWipe;
|
|
|
|
virDrvStorageVolWipePattern storageVolWipePattern;
|
|
|
|
virDrvStorageVolGetInfo storageVolGetInfo;
|
|
|
|
virDrvStorageVolGetXMLDesc storageVolGetXMLDesc;
|
|
|
|
virDrvStorageVolGetPath storageVolGetPath;
|
|
|
|
virDrvStorageVolResize storageVolResize;
|
|
|
|
virDrvStoragePoolIsActive storagePoolIsActive;
|
|
|
|
virDrvStoragePoolIsPersistent storagePoolIsPersistent;
|
2008-02-20 15:06:53 +00:00
|
|
|
};
|
|
|
|
|
2010-03-09 18:22:22 +00:00
|
|
|
# ifdef WITH_LIBVIRTD
|
2012-10-31 19:03:55 +00:00
|
|
|
|
2013-04-23 09:49:27 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvStateInitialize)(bool privileged,
|
|
|
|
virStateInhibitCallback callback,
|
|
|
|
void *opaque);
|
|
|
|
|
2013-07-25 12:01:02 +00:00
|
|
|
typedef void
|
|
|
|
(*virDrvStateAutoStart)(void);
|
|
|
|
|
2013-04-23 09:49:27 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvStateCleanup)(void);
|
|
|
|
|
|
|
|
typedef int
|
|
|
|
(*virDrvStateReload)(void);
|
|
|
|
|
|
|
|
typedef int
|
|
|
|
(*virDrvStateStop)(void);
|
2007-06-26 22:56:14 +00:00
|
|
|
|
|
|
|
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;
|
2013-04-23 09:49:27 +00:00
|
|
|
virDrvStateInitialize stateInitialize;
|
2013-07-25 12:01:02 +00:00
|
|
|
virDrvStateAutoStart stateAutoStart;
|
2013-04-23 09:49:27 +00:00
|
|
|
virDrvStateCleanup stateCleanup;
|
|
|
|
virDrvStateReload stateReload;
|
|
|
|
virDrvStateStop stateStop;
|
2007-06-26 22:56:14 +00:00
|
|
|
};
|
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
|
|
|
|
2013-04-23 12:49:21 +00:00
|
|
|
typedef virDrvConnectOpen virDrvNodeDeviceOpen;
|
|
|
|
typedef virDrvConnectClose virDrvNodeDeviceClose;
|
|
|
|
|
|
|
|
|
2013-04-23 09:49:27 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvNodeNumOfDevices)(virConnectPtr conn,
|
|
|
|
const char *cap,
|
|
|
|
unsigned int flags);
|
2008-11-21 12:19:22 +00:00
|
|
|
|
2013-04-23 09:49:27 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvNodeListDevices)(virConnectPtr conn,
|
|
|
|
const char *cap,
|
|
|
|
char **const names,
|
|
|
|
int maxnames,
|
|
|
|
unsigned int flags);
|
2013-04-22 17:25:01 +00:00
|
|
|
|
2013-04-23 09:49:27 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvConnectListAllNodeDevices)(virConnectPtr conn,
|
|
|
|
virNodeDevicePtr **devices,
|
|
|
|
unsigned int flags);
|
|
|
|
|
|
|
|
typedef virNodeDevicePtr
|
|
|
|
(*virDrvNodeDeviceLookupByName)(virConnectPtr conn,
|
|
|
|
const char *name);
|
|
|
|
|
|
|
|
typedef virNodeDevicePtr
|
|
|
|
(*virDrvNodeDeviceLookupSCSIHostByWWN)(virConnectPtr conn,
|
|
|
|
const char *wwnn,
|
|
|
|
const char *wwpn,
|
|
|
|
unsigned int flags);
|
|
|
|
|
|
|
|
typedef char *
|
|
|
|
(*virDrvNodeDeviceGetXMLDesc)(virNodeDevicePtr dev,
|
|
|
|
unsigned int flags);
|
2008-11-21 12:19:22 +00:00
|
|
|
|
2013-04-23 09:49:27 +00:00
|
|
|
typedef char *
|
|
|
|
(*virDrvNodeDeviceGetParent)(virNodeDevicePtr dev);
|
2008-11-21 12:19:22 +00:00
|
|
|
|
2013-04-23 09:49:27 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvNodeDeviceNumOfCaps)(virNodeDevicePtr dev);
|
2013-02-04 13:03:09 +00:00
|
|
|
|
2013-04-23 09:49:27 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvNodeDeviceListCaps)(virNodeDevicePtr dev,
|
|
|
|
char **const names,
|
|
|
|
int maxnames);
|
2008-11-21 12:19:22 +00:00
|
|
|
|
2013-04-23 09:49:27 +00:00
|
|
|
typedef virNodeDevicePtr
|
|
|
|
(*virDrvNodeDeviceCreateXML)(virConnectPtr conn,
|
|
|
|
const char *xmlDesc,
|
|
|
|
unsigned int flags);
|
2008-11-21 12:19:22 +00:00
|
|
|
|
2013-04-23 09:49:27 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvNodeDeviceDestroy)(virNodeDevicePtr dev);
|
2008-11-21 12:19:22 +00:00
|
|
|
|
|
|
|
|
2013-04-23 09:49:27 +00:00
|
|
|
|
2013-04-23 10:15:48 +00:00
|
|
|
typedef struct _virNodeDeviceDriver virNodeDeviceDriver;
|
|
|
|
typedef virNodeDeviceDriver *virNodeDeviceDriverPtr;
|
2009-04-24 13:11:23 +00:00
|
|
|
|
2008-11-21 12:19:22 +00:00
|
|
|
/**
|
2013-04-23 10:15:48 +00:00
|
|
|
* _virNodeDeviceDriver:
|
2008-11-21 12:19:22 +00:00
|
|
|
*
|
|
|
|
* Structure associated with monitoring the devices
|
|
|
|
* on a virtualized node.
|
|
|
|
*
|
|
|
|
*/
|
2013-04-23 10:15:48 +00:00
|
|
|
struct _virNodeDeviceDriver {
|
2013-04-23 09:49:27 +00:00
|
|
|
const char * name; /* the name of the driver */
|
2013-04-23 12:49:21 +00:00
|
|
|
virDrvNodeDeviceOpen nodeDeviceOpen;
|
|
|
|
virDrvNodeDeviceClose nodeDeviceClose;
|
2013-04-23 09:49:27 +00:00
|
|
|
virDrvNodeNumOfDevices nodeNumOfDevices;
|
|
|
|
virDrvNodeListDevices nodeListDevices;
|
2013-04-22 17:26:01 +00:00
|
|
|
virDrvConnectListAllNodeDevices connectListAllNodeDevices;
|
|
|
|
virDrvNodeDeviceLookupByName nodeDeviceLookupByName;
|
2013-04-23 09:49:27 +00:00
|
|
|
virDrvNodeDeviceLookupSCSIHostByWWN nodeDeviceLookupSCSIHostByWWN;
|
|
|
|
virDrvNodeDeviceGetXMLDesc nodeDeviceGetXMLDesc;
|
|
|
|
virDrvNodeDeviceGetParent nodeDeviceGetParent;
|
|
|
|
virDrvNodeDeviceNumOfCaps nodeDeviceNumOfCaps;
|
|
|
|
virDrvNodeDeviceListCaps nodeDeviceListCaps;
|
|
|
|
virDrvNodeDeviceCreateXML nodeDeviceCreateXML;
|
|
|
|
virDrvNodeDeviceDestroy nodeDeviceDestroy;
|
2008-11-21 12:19:22 +00:00
|
|
|
};
|
|
|
|
|
2009-08-14 19:42:19 +00:00
|
|
|
enum {
|
|
|
|
/* This getValue call is inside libvirt, override the "private" flag.
|
2011-04-11 22:25:25 +00:00
|
|
|
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,
|
2009-08-14 19:42:19 +00:00
|
|
|
};
|
|
|
|
|
2013-04-23 12:49:21 +00:00
|
|
|
typedef virDrvConnectOpen virDrvSecretOpen;
|
|
|
|
typedef virDrvConnectClose virDrvSecretClose;
|
|
|
|
|
|
|
|
|
2009-08-14 19:42:19 +00:00
|
|
|
typedef virSecretPtr
|
2013-04-23 09:49:27 +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
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvSecretLookupByUsage)(virConnectPtr conn,
|
|
|
|
int usageType,
|
|
|
|
const char *usageID);
|
|
|
|
|
2009-08-14 19:42:19 +00:00
|
|
|
typedef virSecretPtr
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvSecretDefineXML)(virConnectPtr conn,
|
|
|
|
const char *xml,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2009-08-14 19:42:19 +00:00
|
|
|
typedef char *
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvSecretGetXMLDesc)(virSecretPtr secret,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2009-08-14 19:42:19 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvSecretSetValue)(virSecretPtr secret,
|
|
|
|
const unsigned char *value,
|
|
|
|
size_t value_size,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2009-08-14 19:42:19 +00:00
|
|
|
typedef unsigned char *
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvSecretGetValue)(virSecretPtr secret,
|
|
|
|
size_t *value_size,
|
|
|
|
unsigned int flags,
|
|
|
|
unsigned int internalFlags);
|
|
|
|
|
2009-08-14 19:42:19 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvSecretUndefine)(virSecretPtr secret);
|
|
|
|
|
2009-08-14 19:42:19 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectNumOfSecrets)(virConnectPtr conn);
|
|
|
|
|
2009-08-14 19:42:19 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectListSecrets)(virConnectPtr conn,
|
|
|
|
char **uuids,
|
|
|
|
int maxuuids);
|
|
|
|
|
2012-09-14 08:38:48 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectListAllSecrets)(virConnectPtr conn,
|
|
|
|
virSecretPtr **secrets,
|
|
|
|
unsigned int flags);
|
2009-08-14 19:42:19 +00:00
|
|
|
|
|
|
|
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;
|
2013-04-23 12:49:21 +00:00
|
|
|
virDrvSecretOpen secretOpen;
|
|
|
|
virDrvSecretClose secretClose;
|
2013-04-23 09:49:27 +00:00
|
|
|
virDrvConnectNumOfSecrets connectNumOfSecrets;
|
|
|
|
virDrvConnectListSecrets connectListSecrets;
|
|
|
|
virDrvConnectListAllSecrets connectListAllSecrets;
|
|
|
|
virDrvSecretLookupByUUID secretLookupByUUID;
|
|
|
|
virDrvSecretLookupByUsage secretLookupByUsage;
|
|
|
|
virDrvSecretDefineXML secretDefineXML;
|
|
|
|
virDrvSecretGetXMLDesc secretGetXMLDesc;
|
|
|
|
virDrvSecretSetValue secretSetValue;
|
|
|
|
virDrvSecretGetValue secretGetValue;
|
|
|
|
virDrvSecretUndefine secretUndefine;
|
2009-08-14 19:42:19 +00:00
|
|
|
};
|
|
|
|
|
2009-07-10 11:18:12 +00:00
|
|
|
|
2013-04-23 09:49:27 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvStreamSend)(virStreamPtr st,
|
|
|
|
const char *data,
|
|
|
|
size_t nbytes);
|
2009-07-10 11:18:12 +00:00
|
|
|
|
2013-04-23 09:49:27 +00:00
|
|
|
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);
|
2009-07-10 11:18:12 +00:00
|
|
|
|
2013-04-23 09:49:27 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvStreamFinish)(virStreamPtr st);
|
2009-07-10 11:18:12 +00:00
|
|
|
|
2013-04-23 09:49:27 +00:00
|
|
|
typedef int
|
|
|
|
(*virDrvStreamAbort)(virStreamPtr st);
|
2009-07-10 11:18:12 +00:00
|
|
|
|
2013-04-23 09:49:27 +00:00
|
|
|
typedef struct _virStreamDriver virStreamDriver;
|
|
|
|
typedef virStreamDriver *virStreamDriverPtr;
|
2009-07-10 11:18:12 +00:00
|
|
|
|
|
|
|
struct _virStreamDriver {
|
2013-04-23 09:49:27 +00:00
|
|
|
virDrvStreamSend streamSend;
|
|
|
|
virDrvStreamRecv streamRecv;
|
|
|
|
virDrvStreamEventAddCallback streamEventAddCallback;
|
2013-04-22 17:26:01 +00:00
|
|
|
virDrvStreamEventUpdateCallback streamEventUpdateCallback;
|
|
|
|
virDrvStreamEventRemoveCallback streamEventRemoveCallback;
|
2013-04-23 09:49:27 +00:00
|
|
|
virDrvStreamFinish streamFinish;
|
|
|
|
virDrvStreamAbort streamAbort;
|
2009-07-10 11:18:12 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2013-04-23 12:49:21 +00:00
|
|
|
typedef virDrvConnectOpen virDrvNWFilterOpen;
|
|
|
|
typedef virDrvConnectClose virDrvNWFilterClose;
|
|
|
|
|
|
|
|
|
2010-03-25 17:46:01 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectNumOfNWFilters)(virConnectPtr conn);
|
|
|
|
|
2010-03-25 17:46:01 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectListNWFilters)(virConnectPtr conn,
|
|
|
|
char **const names,
|
|
|
|
int maxnames);
|
|
|
|
|
2012-09-05 06:02:03 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvConnectListAllNWFilters)(virConnectPtr conn,
|
|
|
|
virNWFilterPtr **filters,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2010-03-25 17:46:01 +00:00
|
|
|
typedef virNWFilterPtr
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvNWFilterLookupByName)(virConnectPtr conn,
|
|
|
|
const char *name);
|
|
|
|
|
2010-03-25 17:46:01 +00:00
|
|
|
typedef virNWFilterPtr
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvNWFilterLookupByUUID)(virConnectPtr conn,
|
|
|
|
const unsigned char *uuid);
|
|
|
|
|
2010-03-25 17:46:01 +00:00
|
|
|
typedef virNWFilterPtr
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvNWFilterDefineXML)(virConnectPtr conn,
|
|
|
|
const char *xmlDesc);
|
|
|
|
|
2010-03-25 17:46:01 +00:00
|
|
|
typedef int
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvNWFilterUndefine)(virNWFilterPtr nwfilter);
|
2010-03-25 17:46:01 +00:00
|
|
|
|
|
|
|
typedef char *
|
2013-04-23 09:49:27 +00:00
|
|
|
(*virDrvNWFilterGetXMLDesc)(virNWFilterPtr nwfilter,
|
|
|
|
unsigned int flags);
|
2010-03-25 17:46:01 +00:00
|
|
|
|
|
|
|
|
|
|
|
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 {
|
2013-04-23 09:49:27 +00:00
|
|
|
const char * name; /* the name of the driver */
|
2013-04-23 12:49:21 +00:00
|
|
|
virDrvNWFilterOpen nwfilterOpen;
|
|
|
|
virDrvNWFilterClose nwfilterClose;
|
2013-04-22 17:26:01 +00:00
|
|
|
virDrvConnectNumOfNWFilters connectNumOfNWFilters;
|
2013-04-23 09:49:27 +00:00
|
|
|
virDrvConnectListNWFilters connectListNWFilters;
|
|
|
|
virDrvConnectListAllNWFilters connectListAllNWFilters;
|
|
|
|
virDrvNWFilterLookupByName nwfilterLookupByName;
|
|
|
|
virDrvNWFilterLookupByUUID nwfilterLookupByUUID;
|
|
|
|
virDrvNWFilterDefineXML nwfilterDefineXML;
|
|
|
|
virDrvNWFilterUndefine nwfilterUndefine;
|
|
|
|
virDrvNWFilterGetXMLDesc nwfilterGetXMLDesc;
|
2010-03-25 17:46:01 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
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);
|
2013-04-23 10:15:48 +00:00
|
|
|
int virRegisterNodeDeviceDriver(virNodeDeviceDriverPtr);
|
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
|
2012-04-02 17:51:11 +00:00
|
|
|
void virDriverModuleInitialize(const char *defmoddir);
|
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__ */
|