my $drivertable = "$srcdir/driver.h";
my %groupheaders = (
- "virDriver" => "Hypervisor APIs",
+ "virHypervisorDriver" => "Hypervisor APIs",
"virNetworkDriver" => "Virtual Network APIs",
"virInterfaceDriver" => "Host Interface APIs",
"virNodeDeviceDriver" => "Host Device APIs",
return 0;
}
-static virDriver bhyveDriver = {
+static virHypervisorDriver bhyveDriver = {
.no = VIR_DRV_BHYVE,
.name = "bhyve",
.connectOpen = bhyveConnectOpen, /* 1.2.2 */
int
bhyveRegister(void)
{
- if (virRegisterDriver(&bhyveDriver) < 0)
+ if (virRegisterHypervisorDriver(&bhyveDriver) < 0)
return -1;
if (virRegisterStateDriver(&bhyveStateDriver) < 0)
return -1;
virURIPtr uri; /* connection URI */
/* The underlying hypervisor driver and network driver. */
- virDriverPtr driver;
+ virHypervisorDriverPtr driver;
virNetworkDriverPtr networkDriver;
virInterfaceDriverPtr interfaceDriver;
virStorageDriverPtr storageDriver;
- virNodeDeviceDriverPtr nodeDeviceDriver;
+ virNodeDeviceDriverPtr nodeDeviceDriver;
virSecretDriverPtr secretDriver;
virNWFilterDriverPtr nwfilterDriver;
unsigned int cellCount,
unsigned int flags);
-typedef struct _virDriver virDriver;
-typedef virDriver *virDriverPtr;
+typedef struct _virHypervisorDriver virHypervisorDriver;
+typedef virHypervisorDriver *virHypervisorDriverPtr;
/**
- * _virDriver:
+ * _virHypervisorDriver:
*
* Structure associated to a virtualization driver, defining the various
* entry points for it.
* - open
* - close
*/
-struct _virDriver {
+struct _virHypervisorDriver {
int no; /* the number virDrvNo */
const char *name; /* the name of the driver */
virDrvConnectOpen connectOpen;
* TODO: also need ways to (des)activate a given driver
* lookup based on the URI given in a virConnectOpen(ReadOnly)
*/
-int virRegisterDriver(virDriverPtr) ATTRIBUTE_RETURN_CHECK;
+int virRegisterHypervisorDriver(virHypervisorDriverPtr) ATTRIBUTE_RETURN_CHECK;
int virRegisterNetworkDriver(virNetworkDriverPtr) ATTRIBUTE_RETURN_CHECK;
int virRegisterInterfaceDriver(virInterfaceDriverPtr) ATTRIBUTE_RETURN_CHECK;
int virRegisterStorageDriver(virStorageDriverPtr) ATTRIBUTE_RETURN_CHECK;
#undef MATCH
-static virDriver esxDriver = {
+static virHypervisorDriver esxDriver = {
.no = VIR_DRV_ESX,
.name = "ESX",
.connectOpen = esxConnectOpen, /* 0.7.0 */
int
esxRegister(void)
{
- if (virRegisterDriver(&esxDriver) < 0 ||
+ if (virRegisterHypervisorDriver(&esxDriver) < 0 ||
esxInterfaceRegister() < 0 ||
esxNetworkRegister() < 0 ||
esxStorageRegister() < 0 ||
-static virDriver hypervDriver = {
+static virHypervisorDriver hypervDriver = {
.no = VIR_DRV_HYPERV,
.name = "Hyper-V",
.connectOpen = hypervConnectOpen, /* 0.9.5 */
int
hypervRegister(void)
{
- if (virRegisterDriver(&hypervDriver) < 0 ||
+ if (virRegisterHypervisorDriver(&hypervDriver) < 0 ||
hypervInterfaceRegister() < 0 ||
hypervNetworkRegister() < 0 ||
hypervStorageRegister() < 0 ||
} \
} while (0)
-static virDriverPtr virDriverTab[MAX_DRIVERS];
-static int virDriverTabCount = 0;
+static virHypervisorDriverPtr virHypervisorDriverTab[MAX_DRIVERS];
+static int virHypervisorDriverTabCount = 0;
static virNetworkDriverPtr virNetworkDriverTab[MAX_DRIVERS];
static int virNetworkDriverTabCount = 0;
static virInterfaceDriverPtr virInterfaceDriverTab[MAX_DRIVERS];
/**
- * virRegisterDriver:
+ * virRegisterHypervisorDriver:
* @driver: pointer to a driver block
*
* Register a virtualization driver
* Returns the driver priority or -1 in case of error.
*/
int
-virRegisterDriver(virDriverPtr driver)
+virRegisterHypervisorDriver(virHypervisorDriverPtr driver)
{
VIR_DEBUG("driver=%p name=%s", driver,
driver ? NULLSTR(driver->name) : "(null)");
virCheckNonNullArgReturn(driver, -1);
- virDriverCheckTabMaxReturn(virDriverTabCount, -1);
+ virDriverCheckTabMaxReturn(virHypervisorDriverTabCount, -1);
VIR_DEBUG("registering %s as driver %d",
- driver->name, virDriverTabCount);
+ driver->name, virHypervisorDriverTabCount);
- virDriverTab[virDriverTabCount] = driver;
- return virDriverTabCount++;
+ virHypervisorDriverTab[virHypervisorDriverTabCount] = driver;
+ return virHypervisorDriverTabCount++;
}
/* Cleansing flags */
ret->flags = flags & VIR_CONNECT_RO;
- for (i = 0; i < virDriverTabCount; i++) {
+ for (i = 0; i < virHypervisorDriverTabCount; i++) {
/* We're going to probe the remote driver next. So we have already
* probed all other client-side-only driver before, but none of them
* accepted the URI.
* driver then report a useful error, instead of a cryptic one about
* not being able to connect to libvirtd or not being able to find
* certificates. */
- if (virDriverTab[i]->no == VIR_DRV_REMOTE &&
+ if (virHypervisorDriverTab[i]->no == VIR_DRV_REMOTE &&
ret->uri != NULL && ret->uri->scheme != NULL &&
(
#ifndef WITH_PHYP
goto failed;
}
- VIR_DEBUG("trying driver %zu (%s) ...", i, virDriverTab[i]->name);
- ret->driver = virDriverTab[i];
- res = virDriverTab[i]->connectOpen(ret, auth, flags);
+ VIR_DEBUG("trying driver %zu (%s) ...", i, virHypervisorDriverTab[i]->name);
+ ret->driver = virHypervisorDriverTab[i];
+ res = virHypervisorDriverTab[i]->connectOpen(ret, auth, flags);
VIR_DEBUG("driver %zu %s returned %s",
- i, virDriverTab[i]->name,
+ i, virHypervisorDriverTab[i]->name,
res == VIR_DRV_OPEN_SUCCESS ? "SUCCESS" :
(res == VIR_DRV_OPEN_DECLINED ? "DECLINED" :
(res == VIR_DRV_OPEN_ERROR ? "ERROR" : "unknown status")));
virDomainMigratePrepareTunnel;
virDomainMigratePrepareTunnel3;
virDomainMigratePrepareTunnel3Params;
-virRegisterDriver;
+virRegisterHypervisorDriver;
virRegisterInterfaceDriver;
virRegisterNetworkDriver;
virRegisterNodeDeviceDriver;
}
-static virDriver libxlDriver = {
+static virHypervisorDriver libxlDriver = {
.no = VIR_DRV_LIBXL,
.name = LIBXL_DRIVER_NAME,
.connectOpen = libxlConnectOpen, /* 0.9.0 */
int
libxlRegister(void)
{
- if (virRegisterDriver(&libxlDriver) < 0)
+ if (virRegisterHypervisorDriver(&libxlDriver) < 0)
return -1;
if (virRegisterStateDriver(&libxlStateDriver) < 0)
return -1;
/* Function Tables */
-static virDriver lxcDriver = {
+static virHypervisorDriver lxcDriver = {
.no = VIR_DRV_LXC,
.name = LXC_DRIVER_NAME,
.connectOpen = lxcConnectOpen, /* 0.4.2 */
int lxcRegister(void)
{
- if (virRegisterDriver(&lxcDriver) < 0)
+ if (virRegisterHypervisorDriver(&lxcDriver) < 0)
return -1;
if (virRegisterStateDriver(&lxcStateDriver) < 0)
return -1;
}
-static virDriver openvzDriver = {
+static virHypervisorDriver openvzDriver = {
.no = VIR_DRV_OPENVZ,
.name = "OPENVZ",
.connectOpen = openvzConnectOpen, /* 0.3.1 */
int openvzRegister(void)
{
- if (virRegisterDriver(&openvzDriver) < 0)
+ if (virRegisterHypervisorDriver(&openvzDriver) < 0)
return -1;
return 0;
}
}
-static virDriver parallelsDriver = {
+static virHypervisorDriver parallelsDriver = {
.no = VIR_DRV_PARALLELS,
.name = "Parallels",
.connectOpen = parallelsConnectOpen, /* 0.10.0 */
VIR_FREE(prlctl_path);
- if (virRegisterDriver(¶llelsDriver) < 0)
+ if (virRegisterHypervisorDriver(¶llelsDriver) < 0)
return -1;
if (parallelsStorageRegister())
return -1;
return 0;
}
-static virDriver phypDriver = {
+static virHypervisorDriver phypDriver = {
.no = VIR_DRV_PHYP,
.name = "PHYP",
.connectOpen = phypConnectOpen, /* 0.7.0 */
int
phypRegister(void)
{
- if (virRegisterDriver(&phypDriver) < 0)
+ if (virRegisterHypervisorDriver(&phypDriver) < 0)
return -1;
if (virRegisterStorageDriver(&phypStorageDriver) < 0)
return -1;
}
-static virDriver qemuDriver = {
+static virHypervisorDriver qemuDriver = {
.no = VIR_DRV_QEMU,
.name = QEMU_DRIVER_NAME,
.connectOpen = qemuConnectOpen, /* 0.2.0 */
int qemuRegister(void)
{
- if (virRegisterDriver(&qemuDriver) < 0)
+ if (virRegisterHypervisorDriver(&qemuDriver) < 0)
return -1;
if (virRegisterStateDriver(&qemuStateDriver) < 0)
return -1;
limit, params, nparams)
static bool inside_daemon = false;
-static virDriverPtr remoteDriver = NULL;
struct private_data {
virMutex lock;
return REMOTE_PROTOCOL_VERSION;
}
-static virDriver remote_driver = {
+static virHypervisorDriver hypervisor_driver = {
.no = VIR_DRV_REMOTE,
.name = "remote",
.connectOpen = remoteConnectOpen, /* 0.3.0 */
int
remoteRegister(void)
{
- remoteDriver = &remote_driver;
-
- if (virRegisterDriver(&remote_driver) < 0)
+ if (virRegisterHypervisorDriver(&hypervisor_driver) < 0)
return -1;
if (virRegisterNetworkDriver(&network_driver) < 0)
return -1;
-static virDriver testDriver = {
+static virHypervisorDriver testDriver = {
.no = VIR_DRV_TEST,
.name = "Test",
.connectOpen = testConnectOpen, /* 0.1.1 */
int
testRegister(void)
{
- if (virRegisterDriver(&testDriver) < 0)
+ if (virRegisterHypervisorDriver(&testDriver) < 0)
return -1;
if (virRegisterNetworkDriver(&testNetworkDriver) < 0)
return -1;
}
-static virDriver umlDriver = {
+static virHypervisorDriver umlDriver = {
.no = VIR_DRV_UML,
.name = "UML",
.connectOpen = umlConnectOpen, /* 0.5.0 */
int umlRegister(void)
{
- if (virRegisterDriver(¨Driver) < 0)
+ if (virRegisterHypervisorDriver(¨Driver) < 0)
return -1;
if (virRegisterStateDriver(¨StateDriver) < 0)
return -1;
* Function Tables
*/
-virDriver vboxCommonDriver = {
+virHypervisorDriver vboxCommonDriver = {
.no = VIR_DRV_VBOX,
.name = "VBOX",
.connectOpen = vboxConnectOpen, /* 0.6.3 */
vboxCommonDriver.domainScreenshot = NULL;
}
-virDriverPtr vboxGetDriver(uint32_t uVersion)
+virHypervisorDriverPtr vboxGetHypervisorDriver(uint32_t uVersion)
{
/* Install gVBoxAPI according to the vbox API version.
* Return -1 for unsupported version.
#if !defined(WITH_DRIVER_MODULES) || defined(VBOX_STORAGE_DRIVER)
static void
-vboxGetDrivers(virDriverPtr *driver_ret,
+vboxGetDrivers(virHypervisorDriverPtr *hypervisorDriver_ret,
virStorageDriverPtr *storageDriver_ret)
{
virStorageDriverPtr storageDriver;
VIR_DEBUG("VBoxCGlueInit failed, using dummy driver");
}
- if (driver_ret)
- *driver_ret = NULL;
+ if (hypervisorDriver_ret)
+ *hypervisorDriver_ret = NULL;
if (storageDriver_ret)
*storageDriver_ret = storageDriver;
}
return VIR_DRV_OPEN_ERROR;
}
-static virDriver vboxDriverDummy = {
+static virHypervisorDriver vboxDriverDummy = {
VIR_DRV_VBOX,
"VBOX",
.connectOpen = dummyConnectOpen, /* 0.6.3 */
int vboxRegister(void)
{
- virDriverPtr driver = NULL;
+ virHypervisorDriverPtr driver = NULL;
uint32_t uVersion;
if (VBoxCGlueInit(&uVersion) == 0)
- driver = vboxGetDriver(uVersion);
+ driver = vboxGetHypervisorDriver(uVersion);
if (!driver)
driver = &vboxDriverDummy;
- if (virRegisterDriver(driver) < 0)
+ if (virRegisterHypervisorDriver(driver) < 0)
return -1;
return 0;
}
# include "internal.h"
-virDriverPtr vboxGetDriver(uint32_t uVersion);
+virHypervisorDriverPtr vboxGetHypervisorDriver(uint32_t uVersion);
virNetworkDriverPtr vboxGetNetworkDriver(uint32_t uVersion);
#endif /* VBOX_GET_DRIVER_H */
/* No Callback support for VirtualBox 4.* series */
static void
-_registerDomainEvent(virDriverPtr driver)
+_registerDomainEvent(virHypervisorDriverPtr driver)
{
driver->connectDomainEventRegister = NULL;
driver->connectDomainEventDeregister = NULL;
}
static void
-_registerDomainEvent(virDriverPtr driver)
+_registerDomainEvent(virHypervisorDriverPtr driver)
{
driver->connectDomainEventRegister = vboxConnectDomainEventRegister; /* 0.7.0 */
driver->connectDomainEventDeregister = vboxConnectDomainEventDeregister; /* 0.7.0 */
int (*attachFloppy)(vboxGlobalData *data, IMachine *machine, const char *src);
int (*detachFloppy)(IMachine *machine);
int (*snapshotRestore)(virDomainPtr dom, IMachine *machine, ISnapshot *snapshot);
- void (*registerDomainEvent)(virDriverPtr driver);
+ void (*registerDomainEvent)(virHypervisorDriverPtr driver);
vboxUniformedPFN UPFN;
vboxUniformedIID UIID;
vboxUniformedArray UArray;
-static virDriver vmwareDriver = {
+static virHypervisorDriver vmwareDriver = {
.no = VIR_DRV_VMWARE,
.name = "VMWARE",
.connectOpen = vmwareConnectOpen, /* 0.8.7 */
int
vmwareRegister(void)
{
- if (virRegisterDriver(&vmwareDriver) < 0)
+ if (virRegisterHypervisorDriver(&vmwareDriver) < 0)
return -1;
return 0;
}
/*----- Register with libvirt.c, and initialize Xen drivers. -----*/
/* The interface which we export upwards to libvirt.c. */
-static virDriver xenUnifiedDriver = {
+static virHypervisorDriver xenUnifiedDriver = {
.no = VIR_DRV_XEN_UNIFIED,
.name = "Xen",
.connectOpen = xenUnifiedConnectOpen, /* 0.0.3 */
{
if (virRegisterStateDriver(&state_driver) == -1) return -1;
- return virRegisterDriver(&xenUnifiedDriver);
+ return virRegisterHypervisorDriver(&xenUnifiedDriver);
}
/**
}
/* The interface which we export upwards to libvirt.c. */
-static virDriver xenapiDriver = {
+static virHypervisorDriver xenapiDriver = {
.no = VIR_DRV_XENAPI,
.name = "XenAPI",
.connectOpen = xenapiConnectOpen, /* 0.8.0 */
int
xenapiRegister(void)
{
- return virRegisterDriver(&xenapiDriver);
+ return virRegisterHypervisorDriver(&xenapiDriver);
}
/*