External/libvirt
1
0
Fork 0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2024-07-17 07:07:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rename 'DeviceMonitor' to 'NodeDeviceDriver'

Browse Source 
The driver.h struct for node devices used an inconsistent
naming scheme 'DeviceMonitor' instead of the more usual
'NodeDeviceDriver'. Fix this everywhere it has leaked
out to.

Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
This commit is contained in:
Daniel P. Berrange 2013-04-23 11:15:48 +01:00
parent 161c823b2a
commit 07a6b9aac4
17 changed files with 133 additions and 133 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
docs/hvsupport.pl
View File

@ -18,7 +18,7 @@ my %groupheaders = (
"virDriver" => "Hypervisor APIs", "virDriver" => "Hypervisor APIs",
"virNetworkDriver" => "Virtual Network APIs", "virNetworkDriver" => "Virtual Network APIs",
"virInterfaceDriver" => "Host Interface APIs", "virInterfaceDriver" => "Host Interface APIs",
"virDeviceMonitor" => "Host Device APIs", "virNodeDeviceDriver" => "Host Device APIs",
"virStorageDriver" => "Storage Pool APIs", "virStorageDriver" => "Storage Pool APIs",
"virSecretDriver" => "Secret APIs", "virSecretDriver" => "Secret APIs",
"virNWFilterDriver" => "Network Filter APIs", "virNWFilterDriver" => "Network Filter APIs",
@ -182,7 +182,7 @@ open FILE, "<$drivertable"
my %groups; my %groups;
my $ingrp; my $ingrp;
while (defined($line = <FILE>)) { while (defined($line = <FILE>)) {
if ($line =~ /struct _(vir\w*(?:Driver|Monitor))/) { if ($line =~ /struct _(vir\w*Driver)/) {
my $grp = $1; my $grp = $1;
if ($grp ne "virStateDriver" && if ($grp ne "virStateDriver" &&
$grp ne "virStreamDriver") { $grp ne "virStreamDriver") {

6
src/conf/node_device_conf.h
View File

@ -200,9 +200,9 @@ struct _virNodeDeviceObjList {
virNodeDeviceObjPtr *objs; virNodeDeviceObjPtr *objs;
}; };
typedef struct _virDeviceMonitorState virDeviceMonitorState; typedef struct _virNodeDeviceDriverState virNodeDeviceDriverState;
typedef virDeviceMonitorState *virDeviceMonitorStatePtr; typedef virNodeDeviceDriverState *virNodeDeviceDriverStatePtr;
struct _virDeviceMonitorState { struct _virNodeDeviceDriverState {
virMutex lock; virMutex lock;
virNodeDeviceObjList devs; /* currently-known devices */ virNodeDeviceObjList devs; /* currently-known devices */

4
src/datatypes.c
View File

@ -149,8 +149,8 @@ virConnectDispose(void *obj)
conn->interfaceDriver->connectClose(conn); conn->interfaceDriver->connectClose(conn);
if (conn->storageDriver) if (conn->storageDriver)
conn->storageDriver->connectClose(conn); conn->storageDriver->connectClose(conn);
if (conn->deviceMonitor) if (conn->nodeDeviceDriver)
conn->deviceMonitor->connectClose(conn); conn->nodeDeviceDriver->connectClose(conn);
if (conn->secretDriver) if (conn->secretDriver)
conn->secretDriver->connectClose(conn); conn->secretDriver->connectClose(conn);
if (conn->nwfilterDriver) if (conn->nwfilterDriver)

4
src/datatypes.h
View File

@ -128,7 +128,7 @@ struct _virConnect {
virNetworkDriverPtr networkDriver; virNetworkDriverPtr networkDriver;
virInterfaceDriverPtr interfaceDriver; virInterfaceDriverPtr interfaceDriver;
virStorageDriverPtr storageDriver; virStorageDriverPtr storageDriver;
virDeviceMonitorPtr deviceMonitor; virNodeDeviceDriverPtr nodeDeviceDriver;
virSecretDriverPtr secretDriver; virSecretDriverPtr secretDriver;
virNWFilterDriverPtr nwfilterDriver; virNWFilterDriverPtr nwfilterDriver;
@ -140,7 +140,7 @@ struct _virConnect {
void * networkPrivateData; void * networkPrivateData;
void * interfacePrivateData; void * interfacePrivateData;
void * storagePrivateData; void * storagePrivateData;
void * devMonPrivateData; void * nodeDevicePrivateData;
void * secretPrivateData; void * secretPrivateData;
void * nwfilterPrivateData; void * nwfilterPrivateData;

10
src/driver.h
View File

@ -1757,17 +1757,17 @@ typedef int
typedef struct _virDeviceMonitor virDeviceMonitor; typedef struct _virNodeDeviceDriver virNodeDeviceDriver;
typedef virDeviceMonitor *virDeviceMonitorPtr; typedef virNodeDeviceDriver *virNodeDeviceDriverPtr;
/** /**
* _virDeviceMonitor: * _virNodeDeviceDriver:
* *
* Structure associated with monitoring the devices * Structure associated with monitoring the devices
* on a virtualized node. * on a virtualized node.
* *
*/ */
struct _virDeviceMonitor { struct _virNodeDeviceDriver {
const char * name; /* the name of the driver */ const char * name; /* the name of the driver */
virDrvConnectOpen connectOpen; virDrvConnectOpen connectOpen;
virDrvConnectClose connectClose; virDrvConnectClose connectClose;
@ -1980,7 +1980,7 @@ int virRegisterDriver(virDriverPtr);
int virRegisterNetworkDriver(virNetworkDriverPtr); int virRegisterNetworkDriver(virNetworkDriverPtr);
int virRegisterInterfaceDriver(virInterfaceDriverPtr); int virRegisterInterfaceDriver(virInterfaceDriverPtr);
int virRegisterStorageDriver(virStorageDriverPtr); int virRegisterStorageDriver(virStorageDriverPtr);
int virRegisterDeviceMonitor(virDeviceMonitorPtr); int virRegisterNodeDeviceDriver(virNodeDeviceDriverPtr);
int virRegisterSecretDriver(virSecretDriverPtr); int virRegisterSecretDriver(virSecretDriverPtr);
int virRegisterNWFilterDriver(virNWFilterDriverPtr); int virRegisterNWFilterDriver(virNWFilterDriverPtr);
# ifdef WITH_LIBVIRTD # ifdef WITH_LIBVIRTD

8
src/esx/esx_device_monitor.c
View File

@ -50,7 +50,7 @@ esxDeviceOpen(virConnectPtr conn,
return VIR_DRV_OPEN_DECLINED; return VIR_DRV_OPEN_DECLINED;
} }
conn->devMonPrivateData = conn->privateData; conn->nodeDevicePrivateData = conn->privateData;
return VIR_DRV_OPEN_SUCCESS; return VIR_DRV_OPEN_SUCCESS;
} }
@ -60,14 +60,14 @@ esxDeviceOpen(virConnectPtr conn,
static int static int
esxDeviceClose(virConnectPtr conn) esxDeviceClose(virConnectPtr conn)
{ {
conn->devMonPrivateData = NULL; conn->nodeDevicePrivateData = NULL;
return 0; return 0;
} }
static virDeviceMonitor esxDeviceMonitor = { static virNodeDeviceDriver esxNodeDeviceDriver = {
.name = "ESX", .name = "ESX",
.connectOpen = esxDeviceOpen, /* 0.7.6 */ .connectOpen = esxDeviceOpen, /* 0.7.6 */
.connectClose = esxDeviceClose, /* 0.7.6 */ .connectClose = esxDeviceClose, /* 0.7.6 */
@ -78,5 +78,5 @@ static virDeviceMonitor esxDeviceMonitor = {
int int
esxDeviceRegister(void) esxDeviceRegister(void)
{ {
return virRegisterDeviceMonitor(&esxDeviceMonitor); return virRegisterNodeDeviceDriver(&esxNodeDeviceDriver);
} }

8
src/hyperv/hyperv_device_monitor.c
View File

@ -47,7 +47,7 @@ hypervDeviceOpen(virConnectPtr conn,
return VIR_DRV_OPEN_DECLINED; return VIR_DRV_OPEN_DECLINED;
} }
conn->devMonPrivateData = conn->privateData; conn->nodeDevicePrivateData = conn->privateData;
return VIR_DRV_OPEN_SUCCESS; return VIR_DRV_OPEN_SUCCESS;
} }
@ -57,14 +57,14 @@ hypervDeviceOpen(virConnectPtr conn,
static int static int
hypervDeviceClose(virConnectPtr conn) hypervDeviceClose(virConnectPtr conn)
{ {
conn->devMonPrivateData = NULL; conn->nodeDevicePrivateData = NULL;
return 0; return 0;
} }
static virDeviceMonitor hypervDeviceMonitor = { static virNodeDeviceDriver hypervNodeDeviceDriver = {
"Hyper-V", "Hyper-V",
.connectOpen = hypervDeviceOpen, /* 0.9.5 */ .connectOpen = hypervDeviceOpen, /* 0.9.5 */
.connectClose = hypervDeviceClose, /* 0.9.5 */ .connectClose = hypervDeviceClose, /* 0.9.5 */
@ -75,5 +75,5 @@ static virDeviceMonitor hypervDeviceMonitor = {
int int
hypervDeviceRegister(void) hypervDeviceRegister(void)
{ {
return virRegisterDeviceMonitor(&hypervDeviceMonitor); return virRegisterNodeDeviceDriver(&hypervNodeDeviceDriver);
} }

76
src/libvirt.c
View File

@ -112,8 +112,8 @@ static virInterfaceDriverPtr virInterfaceDriverTab[MAX_DRIVERS];
static int virInterfaceDriverTabCount = 0; static int virInterfaceDriverTabCount = 0;
static virStorageDriverPtr virStorageDriverTab[MAX_DRIVERS]; static virStorageDriverPtr virStorageDriverTab[MAX_DRIVERS];
static int virStorageDriverTabCount = 0; static int virStorageDriverTabCount = 0;
static virDeviceMonitorPtr virDeviceMonitorTab[MAX_DRIVERS]; static virNodeDeviceDriverPtr virNodeDeviceDriverTab[MAX_DRIVERS];
static int virDeviceMonitorTabCount = 0; static int virNodeDeviceDriverTabCount = 0;
static virSecretDriverPtr virSecretDriverTab[MAX_DRIVERS]; static virSecretDriverPtr virSecretDriverTab[MAX_DRIVERS];
static int virSecretDriverTabCount = 0; static int virSecretDriverTabCount = 0;
static virNWFilterDriverPtr virNWFilterDriverTab[MAX_DRIVERS]; static virNWFilterDriverPtr virNWFilterDriverTab[MAX_DRIVERS];
@ -672,7 +672,7 @@ virRegisterStorageDriver(virStorageDriverPtr driver)
} }
/** /**
* virRegisterDeviceMonitor: * virRegisterNodeDeviceDriver:
* @driver: pointer to a device monitor block * @driver: pointer to a device monitor block
* *
* Register a device monitor * Register a device monitor
@ -680,11 +680,11 @@ virRegisterStorageDriver(virStorageDriverPtr driver)
* Returns the driver priority or -1 in case of error. * Returns the driver priority or -1 in case of error.
*/ */
int int
virRegisterDeviceMonitor(virDeviceMonitorPtr driver) virRegisterNodeDeviceDriver(virNodeDeviceDriverPtr driver)
{ {
virCheckNonNullArgReturn(driver, -1); virCheckNonNullArgReturn(driver, -1);
if (virDeviceMonitorTabCount >= MAX_DRIVERS) { if (virNodeDeviceDriverTabCount >= MAX_DRIVERS) {
virLibConnError(VIR_ERR_INTERNAL_ERROR, virLibConnError(VIR_ERR_INTERNAL_ERROR,
_("Too many drivers, cannot register %s"), _("Too many drivers, cannot register %s"),
driver->name); driver->name);
@ -692,10 +692,10 @@ virRegisterDeviceMonitor(virDeviceMonitorPtr driver)
} }
VIR_DEBUG("registering %s as device driver %d", VIR_DEBUG("registering %s as device driver %d",
driver->name, virDeviceMonitorTabCount); driver->name, virNodeDeviceDriverTabCount);
virDeviceMonitorTab[virDeviceMonitorTabCount] = driver; virNodeDeviceDriverTab[virNodeDeviceDriverTabCount] = driver;
return virDeviceMonitorTabCount++; return virNodeDeviceDriverTabCount++;
} }
/** /**
@ -1282,16 +1282,16 @@ do_open(const char *name,
} }
/* Node driver (optional) */ /* Node driver (optional) */
for (i = 0; i < virDeviceMonitorTabCount; i++) { for (i = 0; i < virNodeDeviceDriverTabCount; i++) {
res = virDeviceMonitorTab[i]->connectOpen(ret, auth, flags); res = virNodeDeviceDriverTab[i]->connectOpen(ret, auth, flags);
VIR_DEBUG("node driver %d %s returned %s", VIR_DEBUG("node driver %d %s returned %s",
i, virDeviceMonitorTab[i]->name, i, virNodeDeviceDriverTab[i]->name,
res == VIR_DRV_OPEN_SUCCESS ? "SUCCESS" : res == VIR_DRV_OPEN_SUCCESS ? "SUCCESS" :
(res == VIR_DRV_OPEN_DECLINED ? "DECLINED" : (res == VIR_DRV_OPEN_DECLINED ? "DECLINED" :
(res == VIR_DRV_OPEN_ERROR ? "ERROR" : "unknown status"))); (res == VIR_DRV_OPEN_ERROR ? "ERROR" : "unknown status")));
if (res == VIR_DRV_OPEN_SUCCESS) { if (res == VIR_DRV_OPEN_SUCCESS) {
ret->deviceMonitor = virDeviceMonitorTab[i]; ret->nodeDeviceDriver = virNodeDeviceDriverTab[i];
break; break;
} else if (res == VIR_DRV_OPEN_ERROR) { } else if (res == VIR_DRV_OPEN_ERROR) {
break; break;
@ -14220,9 +14220,9 @@ virNodeNumOfDevices(virConnectPtr conn, const char *cap, unsigned int flags)
return -1; return -1;
} }
if (conn->deviceMonitor && conn->deviceMonitor->nodeNumOfDevices) { if (conn->nodeDeviceDriver && conn->nodeDeviceDriver->nodeNumOfDevices) {
int ret; int ret;
ret = conn->deviceMonitor->nodeNumOfDevices(conn, cap, flags); ret = conn->nodeDeviceDriver->nodeNumOfDevices(conn, cap, flags);
if (ret < 0) if (ret < 0)
goto error; goto error;
return ret; return ret;
@ -14291,10 +14291,10 @@ virConnectListAllNodeDevices(virConnectPtr conn,
return -1; return -1;
} }
if (conn->deviceMonitor && if (conn->nodeDeviceDriver &&
conn->deviceMonitor->connectListAllNodeDevices) { conn->nodeDeviceDriver->connectListAllNodeDevices) {
int ret; int ret;
ret = conn->deviceMonitor->connectListAllNodeDevices(conn, devices, flags); ret = conn->nodeDeviceDriver->connectListAllNodeDevices(conn, devices, flags);
if (ret < 0) if (ret < 0)
goto error; goto error;
return ret; return ret;
@ -14343,9 +14343,9 @@ virNodeListDevices(virConnectPtr conn,
virCheckNonNullArgGoto(names, error); virCheckNonNullArgGoto(names, error);
virCheckNonNegativeArgGoto(maxnames, error); virCheckNonNegativeArgGoto(maxnames, error);
if (conn->deviceMonitor && conn->deviceMonitor->nodeListDevices) { if (conn->nodeDeviceDriver && conn->nodeDeviceDriver->nodeListDevices) {
int ret; int ret;
ret = conn->deviceMonitor->nodeListDevices(conn, cap, names, maxnames, flags); ret = conn->nodeDeviceDriver->nodeListDevices(conn, cap, names, maxnames, flags);
if (ret < 0) if (ret < 0)
goto error; goto error;
return ret; return ret;
@ -14382,9 +14382,9 @@ virNodeDevicePtr virNodeDeviceLookupByName(virConnectPtr conn, const char *name)
virCheckNonNullArgGoto(name, error); virCheckNonNullArgGoto(name, error);
if (conn->deviceMonitor && conn->deviceMonitor->nodeDeviceLookupByName) { if (conn->nodeDeviceDriver && conn->nodeDeviceDriver->nodeDeviceLookupByName) {
virNodeDevicePtr ret; virNodeDevicePtr ret;
ret = conn->deviceMonitor->nodeDeviceLookupByName(conn, name); ret = conn->nodeDeviceDriver->nodeDeviceLookupByName(conn, name);
if (!ret) if (!ret)
goto error; goto error;
return ret; return ret;
@ -14427,10 +14427,10 @@ virNodeDeviceLookupSCSIHostByWWN(virConnectPtr conn,
virCheckNonNullArgGoto(wwnn, error); virCheckNonNullArgGoto(wwnn, error);
virCheckNonNullArgGoto(wwpn, error); virCheckNonNullArgGoto(wwpn, error);
if (conn->deviceMonitor && if (conn->nodeDeviceDriver &&
conn->deviceMonitor->nodeDeviceLookupSCSIHostByWWN) { conn->nodeDeviceDriver->nodeDeviceLookupSCSIHostByWWN) {
virNodeDevicePtr ret; virNodeDevicePtr ret;
ret = conn->deviceMonitor->nodeDeviceLookupSCSIHostByWWN(conn, wwnn, ret = conn->nodeDeviceDriver->nodeDeviceLookupSCSIHostByWWN(conn, wwnn,
wwpn, flags); wwpn, flags);
if (!ret) if (!ret)
goto error; goto error;
@ -14466,9 +14466,9 @@ char *virNodeDeviceGetXMLDesc(virNodeDevicePtr dev, unsigned int flags)
return NULL; return NULL;
} }
if (dev->conn->deviceMonitor && dev->conn->deviceMonitor->nodeDeviceGetXMLDesc) { if (dev->conn->nodeDeviceDriver && dev->conn->nodeDeviceDriver->nodeDeviceGetXMLDesc) {
char *ret; char *ret;
ret = dev->conn->deviceMonitor->nodeDeviceGetXMLDesc(dev, flags); ret = dev->conn->nodeDeviceDriver->nodeDeviceGetXMLDesc(dev, flags);
if (!ret) if (!ret)
goto error; goto error;
return ret; return ret;
@ -14525,8 +14525,8 @@ const char *virNodeDeviceGetParent(virNodeDevicePtr dev)
} }
if (!dev->parent) { if (!dev->parent) {
if (dev->conn->deviceMonitor && dev->conn->deviceMonitor->nodeDeviceGetParent) { if (dev->conn->nodeDeviceDriver && dev->conn->nodeDeviceDriver->nodeDeviceGetParent) {
dev->parent = dev->conn->deviceMonitor->nodeDeviceGetParent(dev); dev->parent = dev->conn->nodeDeviceDriver->nodeDeviceGetParent(dev);
} else { } else {
virLibConnError(VIR_ERR_NO_SUPPORT, __FUNCTION__); virLibConnError(VIR_ERR_NO_SUPPORT, __FUNCTION__);
virDispatchError(dev->conn); virDispatchError(dev->conn);
@ -14556,9 +14556,9 @@ int virNodeDeviceNumOfCaps(virNodeDevicePtr dev)
return -1; return -1;
} }
if (dev->conn->deviceMonitor && dev->conn->deviceMonitor->nodeDeviceNumOfCaps) { if (dev->conn->nodeDeviceDriver && dev->conn->nodeDeviceDriver->nodeDeviceNumOfCaps) {
int ret; int ret;
ret = dev->conn->deviceMonitor->nodeDeviceNumOfCaps(dev); ret = dev->conn->nodeDeviceDriver->nodeDeviceNumOfCaps(dev);
if (ret < 0) if (ret < 0)
goto error; goto error;
return ret; return ret;
@ -14599,9 +14599,9 @@ int virNodeDeviceListCaps(virNodeDevicePtr dev,
virCheckNonNullArgGoto(names, error); virCheckNonNullArgGoto(names, error);
virCheckNonNegativeArgGoto(maxnames, error); virCheckNonNegativeArgGoto(maxnames, error);
if (dev->conn->deviceMonitor && dev->conn->deviceMonitor->nodeDeviceListCaps) { if (dev->conn->nodeDeviceDriver && dev->conn->nodeDeviceDriver->nodeDeviceListCaps) {
int ret; int ret;
ret = dev->conn->deviceMonitor->nodeDeviceListCaps(dev, names, maxnames); ret = dev->conn->nodeDeviceDriver->nodeDeviceListCaps(dev, names, maxnames);
if (ret < 0) if (ret < 0)
goto error; goto error;
return ret; return ret;
@ -14854,9 +14854,9 @@ virNodeDeviceCreateXML(virConnectPtr conn,
virCheckNonNullArgGoto(xmlDesc, error); virCheckNonNullArgGoto(xmlDesc, error);
if (conn->deviceMonitor && if (conn->nodeDeviceDriver &&
conn->deviceMonitor->nodeDeviceCreateXML) { conn->nodeDeviceDriver->nodeDeviceCreateXML) {
virNodeDevicePtr dev = conn->deviceMonitor->nodeDeviceCreateXML(conn, xmlDesc, flags); virNodeDevicePtr dev = conn->nodeDeviceDriver->nodeDeviceCreateXML(conn, xmlDesc, flags);
if (dev == NULL) if (dev == NULL)
goto error; goto error;
return dev; return dev;
@ -14897,9 +14897,9 @@ virNodeDeviceDestroy(virNodeDevicePtr dev)
goto error; goto error;
} }
if (dev->conn->deviceMonitor && if (dev->conn->nodeDeviceDriver &&
dev->conn->deviceMonitor->nodeDeviceDestroy) { dev->conn->nodeDeviceDriver->nodeDeviceDestroy) {
int retval = dev->conn->deviceMonitor->nodeDeviceDestroy(dev); int retval = dev->conn->nodeDeviceDriver->nodeDeviceDestroy(dev);
if (retval < 0) { if (retval < 0) {
goto error; goto error;
} }

2
src/libvirt_private.syms
View File

@ -713,10 +713,10 @@ virDomainMigratePrepare2;
virDomainMigratePrepare3; virDomainMigratePrepare3;
virDomainMigratePrepareTunnel; virDomainMigratePrepareTunnel;
virDomainMigratePrepareTunnel3; virDomainMigratePrepareTunnel3;
virRegisterDeviceMonitor;
virRegisterDriver; virRegisterDriver;
virRegisterInterfaceDriver; virRegisterInterfaceDriver;
virRegisterNetworkDriver; virRegisterNetworkDriver;
virRegisterNodeDeviceDriver;
virRegisterNWFilterDriver; virRegisterNWFilterDriver;
virRegisterSecretDriver; virRegisterSecretDriver;
virRegisterStorageDriver; virRegisterStorageDriver;

28
src/node_device/node_device_driver.c
View File

@ -112,11 +112,11 @@ static int update_driver_name(virNodeDeviceObjPtr dev ATTRIBUTE_UNUSED)
#endif #endif
void nodeDeviceLock(virDeviceMonitorStatePtr driver) void nodeDeviceLock(virNodeDeviceDriverStatePtr driver)
{ {
virMutexLock(&driver->lock); virMutexLock(&driver->lock);
} }
void nodeDeviceUnlock(virDeviceMonitorStatePtr driver) void nodeDeviceUnlock(virNodeDeviceDriverStatePtr driver)
{ {
virMutexUnlock(&driver->lock); virMutexUnlock(&driver->lock);
} }
@ -126,7 +126,7 @@ nodeNumOfDevices(virConnectPtr conn,
const char *cap, const char *cap,
unsigned int flags) unsigned int flags)
{ {
virDeviceMonitorStatePtr driver = conn->devMonPrivateData; virNodeDeviceDriverStatePtr driver = conn->nodeDevicePrivateData;
int ndevs = 0; int ndevs = 0;
unsigned int i; unsigned int i;
@ -151,7 +151,7 @@ nodeListDevices(virConnectPtr conn,
char **const names, int maxnames, char **const names, int maxnames,
unsigned int flags) unsigned int flags)
{ {
virDeviceMonitorStatePtr driver = conn->devMonPrivateData; virNodeDeviceDriverStatePtr driver = conn->nodeDevicePrivateData;
int ndevs = 0; int ndevs = 0;
unsigned int i; unsigned int i;
@ -187,7 +187,7 @@ nodeListAllNodeDevices(virConnectPtr conn,
virNodeDevicePtr **devices, virNodeDevicePtr **devices,
unsigned int flags) unsigned int flags)
{ {
virDeviceMonitorStatePtr driver = conn->devMonPrivateData; virNodeDeviceDriverStatePtr driver = conn->nodeDevicePrivateData;
int ret = -1; int ret = -1;
virCheckFlags(VIR_CONNECT_LIST_NODE_DEVICES_FILTERS_CAP, -1); virCheckFlags(VIR_CONNECT_LIST_NODE_DEVICES_FILTERS_CAP, -1);
@ -201,7 +201,7 @@ nodeListAllNodeDevices(virConnectPtr conn,
virNodeDevicePtr virNodeDevicePtr
nodeDeviceLookupByName(virConnectPtr conn, const char *name) nodeDeviceLookupByName(virConnectPtr conn, const char *name)
{ {
virDeviceMonitorStatePtr driver = conn->devMonPrivateData; virNodeDeviceDriverStatePtr driver = conn->nodeDevicePrivateData;
virNodeDeviceObjPtr obj; virNodeDeviceObjPtr obj;
virNodeDevicePtr ret = NULL; virNodeDevicePtr ret = NULL;
@ -230,7 +230,7 @@ nodeDeviceLookupSCSIHostByWWN(virConnectPtr conn,
unsigned int flags) unsigned int flags)
{ {
unsigned int i; unsigned int i;
virDeviceMonitorStatePtr driver = conn->devMonPrivateData; virNodeDeviceDriverStatePtr driver = conn->nodeDevicePrivateData;
virNodeDeviceObjListPtr devs = &driver->devs; virNodeDeviceObjListPtr devs = &driver->devs;
virNodeDevCapsDefPtr cap = NULL; virNodeDevCapsDefPtr cap = NULL;
virNodeDeviceObjPtr obj = NULL; virNodeDeviceObjPtr obj = NULL;
@ -274,7 +274,7 @@ char *
nodeDeviceGetXMLDesc(virNodeDevicePtr dev, nodeDeviceGetXMLDesc(virNodeDevicePtr dev,
unsigned int flags) unsigned int flags)
{ {
virDeviceMonitorStatePtr driver = dev->conn->devMonPrivateData; virNodeDeviceDriverStatePtr driver = dev->conn->nodeDevicePrivateData;
virNodeDeviceObjPtr obj; virNodeDeviceObjPtr obj;
char *ret = NULL; char *ret = NULL;
@ -306,7 +306,7 @@ cleanup:
char * char *
nodeDeviceGetParent(virNodeDevicePtr dev) nodeDeviceGetParent(virNodeDevicePtr dev)
{ {
virDeviceMonitorStatePtr driver = dev->conn->devMonPrivateData; virNodeDeviceDriverStatePtr driver = dev->conn->nodeDevicePrivateData;
virNodeDeviceObjPtr obj; virNodeDeviceObjPtr obj;
char *ret = NULL; char *ret = NULL;
@ -340,7 +340,7 @@ cleanup:
int int
nodeDeviceNumOfCaps(virNodeDevicePtr dev) nodeDeviceNumOfCaps(virNodeDevicePtr dev)
{ {
virDeviceMonitorStatePtr driver = dev->conn->devMonPrivateData; virNodeDeviceDriverStatePtr driver = dev->conn->nodeDevicePrivateData;
virNodeDeviceObjPtr obj; virNodeDeviceObjPtr obj;
virNodeDevCapsDefPtr caps; virNodeDevCapsDefPtr caps;
int ncaps = 0; int ncaps = 0;
@ -371,7 +371,7 @@ cleanup:
int int
nodeDeviceListCaps(virNodeDevicePtr dev, char **const names, int maxnames) nodeDeviceListCaps(virNodeDevicePtr dev, char **const names, int maxnames)
{ {
virDeviceMonitorStatePtr driver = dev->conn->devMonPrivateData; virNodeDeviceDriverStatePtr driver = dev->conn->nodeDevicePrivateData;
virNodeDeviceObjPtr obj; virNodeDeviceObjPtr obj;
virNodeDevCapsDefPtr caps; virNodeDevCapsDefPtr caps;
int ncaps = 0; int ncaps = 0;
@ -442,7 +442,7 @@ get_time(time_t *t)
static virNodeDevicePtr static virNodeDevicePtr
find_new_device(virConnectPtr conn, const char *wwnn, const char *wwpn) find_new_device(virConnectPtr conn, const char *wwnn, const char *wwpn)
{ {
virDeviceMonitorStatePtr driver = conn->devMonPrivateData; virNodeDeviceDriverStatePtr driver = conn->nodeDevicePrivateData;
virNodeDevicePtr dev = NULL; virNodeDevicePtr dev = NULL;
time_t start = 0, now = 0; time_t start = 0, now = 0;
@ -481,7 +481,7 @@ nodeDeviceCreateXML(virConnectPtr conn,
const char *xmlDesc, const char *xmlDesc,
unsigned int flags) unsigned int flags)
{ {
virDeviceMonitorStatePtr driver = conn->devMonPrivateData; virNodeDeviceDriverStatePtr driver = conn->nodeDevicePrivateData;
virNodeDeviceDefPtr def = NULL; virNodeDeviceDefPtr def = NULL;
char *wwnn = NULL, *wwpn = NULL; char *wwnn = NULL, *wwpn = NULL;
int parent_host = -1; int parent_host = -1;
@ -537,7 +537,7 @@ int
nodeDeviceDestroy(virNodeDevicePtr dev) nodeDeviceDestroy(virNodeDevicePtr dev)
{ {
int ret = -1; int ret = -1;
virDeviceMonitorStatePtr driver = dev->conn->devMonPrivateData; virNodeDeviceDriverStatePtr driver = dev->conn->nodeDevicePrivateData;
virNodeDeviceObjPtr obj = NULL; virNodeDeviceObjPtr obj = NULL;
char *parent_name = NULL, *wwnn = NULL, *wwpn = NULL; char *parent_name = NULL, *wwnn = NULL, *wwpn = NULL;
int parent_host = -1; int parent_host = -1;

4
src/node_device/node_device_driver.h
View File

@ -46,8 +46,8 @@ int halNodeRegister(void);
int udevNodeRegister(void); int udevNodeRegister(void);
# endif # endif
void nodeDeviceLock(virDeviceMonitorStatePtr driver); void nodeDeviceLock(virNodeDeviceDriverStatePtr driver);
void nodeDeviceUnlock(virDeviceMonitorStatePtr driver); void nodeDeviceUnlock(virNodeDeviceDriverStatePtr driver);
int nodedevRegister(void); int nodedevRegister(void);

30
src/node_device/node_device_hal.c
View File

@ -46,10 +46,10 @@
* Host device enumeration (HAL implementation) * Host device enumeration (HAL implementation)
*/ */
static virDeviceMonitorStatePtr driverState; static virNodeDeviceDriverStatePtr driverState;
#define CONN_DRV_STATE(conn) \ #define CONN_DRV_STATE(conn) \
((virDeviceMonitorStatePtr)((conn)->devMonPrivateData)) ((virNodeDeviceDriverStatePtr)((conn)->nodeDevicePrivateData))
#define DRV_STATE_HAL_CTX(ds) ((LibHalContext *)((ds)->privateData)) #define DRV_STATE_HAL_CTX(ds) ((LibHalContext *)((ds)->privateData))
#define CONN_HAL_CTX(conn) DRV_STATE_HAL_CTX(CONN_DRV_STATE(conn)) #define CONN_HAL_CTX(conn) DRV_STATE_HAL_CTX(CONN_DRV_STATE(conn))
@ -590,9 +590,9 @@ static void device_prop_modified(LibHalContext *ctx ATTRIBUTE_UNUSED,
} }
static int halDeviceMonitorStartup(bool privileged ATTRIBUTE_UNUSED, static int halNodeDeviceDriverStartup(bool privileged ATTRIBUTE_UNUSED,
virStateInhibitCallback callback ATTRIBUTE_UNUSED, virStateInhibitCallback callback ATTRIBUTE_UNUSED,
void *opaque ATTRIBUTE_UNUSED) void *opaque ATTRIBUTE_UNUSED)
{ {
LibHalContext *hal_ctx = NULL; LibHalContext *hal_ctx = NULL;
char **udi = NULL; char **udi = NULL;
@ -691,7 +691,7 @@ static int halDeviceMonitorStartup(bool privileged ATTRIBUTE_UNUSED,
} }
static int halDeviceMonitorShutdown(void) static int halNodeDeviceDriverShutdown(void)
{ {
if (driverState) { if (driverState) {
nodeDeviceLock(driverState); nodeDeviceLock(driverState);
@ -708,7 +708,7 @@ static int halDeviceMonitorShutdown(void)
} }
static int halDeviceMonitorReload(void) static int halNodeDeviceDriverReload(void)
{ {
DBusError err; DBusError err;
char **udi = NULL; char **udi = NULL;
@ -749,20 +749,20 @@ static virDrvOpenStatus halNodeDrvOpen(virConnectPtr conn,
if (driverState == NULL) if (driverState == NULL)
return VIR_DRV_OPEN_DECLINED; return VIR_DRV_OPEN_DECLINED;
conn->devMonPrivateData = driverState; conn->nodeDevicePrivateData = driverState;
return VIR_DRV_OPEN_SUCCESS; return VIR_DRV_OPEN_SUCCESS;
} }
static int halNodeDrvClose(virConnectPtr conn ATTRIBUTE_UNUSED) static int halNodeDrvClose(virConnectPtr conn ATTRIBUTE_UNUSED)
{ {
conn->devMonPrivateData = NULL; conn->nodeDevicePrivateData = NULL;
return 0; return 0;
} }
static virDeviceMonitor halDeviceMonitor = { static virNodeDeviceDriver halNodeDeviceDriver = {
.name = "halDeviceMonitor", .name = "halNodeDeviceDriver",
.connectOpen = halNodeDrvOpen, /* 0.5.0 */ .connectOpen = halNodeDrvOpen, /* 0.5.0 */
.connectClose = halNodeDrvClose, /* 0.5.0 */ .connectClose = halNodeDrvClose, /* 0.5.0 */
.nodeNumOfDevices = nodeNumOfDevices, /* 0.5.0 */ .nodeNumOfDevices = nodeNumOfDevices, /* 0.5.0 */
@ -781,14 +781,14 @@ static virDeviceMonitor halDeviceMonitor = {
static virStateDriver halStateDriver = { static virStateDriver halStateDriver = {
.name = "HAL", .name = "HAL",
.stateInitialize = halDeviceMonitorStartup, /* 0.5.0 */ .stateInitialize = halNodeDeviceDriverStartup, /* 0.5.0 */
.stateCleanup = halDeviceMonitorShutdown, /* 0.5.0 */ .stateCleanup = halNodeDeviceDriverShutdown, /* 0.5.0 */
.stateReload = halDeviceMonitorReload, /* 0.5.0 */ .stateReload = halNodeDeviceDriverReload, /* 0.5.0 */
}; };
int halNodeRegister(void) int halNodeRegister(void)
{ {
if (virRegisterDeviceMonitor(&halDeviceMonitor) < 0) if (virRegisterNodeDeviceDriver(&halNodeDeviceDriver) < 0)
return -1; return -1;
return virRegisterStateDriver(&halStateDriver); return virRegisterStateDriver(&halStateDriver);
} }

30
src/node_device/node_device_udev.c
View File

@ -50,7 +50,7 @@ struct _udevPrivate {
int watch; int watch;
}; };
static virDeviceMonitorStatePtr driverState = NULL; static virNodeDeviceDriverStatePtr driverState = NULL;
static int udevStrToLong_ull(char const *s, static int udevStrToLong_ull(char const *s,
char **end_ptr, char **end_ptr,
@ -1437,7 +1437,7 @@ out:
} }
static int udevDeviceMonitorShutdown(void) static int udevNodeDeviceDriverShutdown(void)
{ {
int ret = 0; int ret = 0;
@ -1649,9 +1649,9 @@ out:
return ret; return ret;
} }
static int udevDeviceMonitorStartup(bool privileged ATTRIBUTE_UNUSED, static int udevNodeDeviceDriverStartup(bool privileged ATTRIBUTE_UNUSED,
virStateInhibitCallback callback ATTRIBUTE_UNUSED, virStateInhibitCallback callback ATTRIBUTE_UNUSED,
void *opaque ATTRIBUTE_UNUSED) void *opaque ATTRIBUTE_UNUSED)
{ {
udevPrivate *priv = NULL; udevPrivate *priv = NULL;
struct udev *udev = NULL; struct udev *udev = NULL;
@ -1758,13 +1758,13 @@ out_unlock:
out: out:
if (ret == -1) { if (ret == -1) {
udevDeviceMonitorShutdown(); udevNodeDeviceDriverShutdown();
} }
return ret; return ret;
} }
static int udevDeviceMonitorReload(void) static int udevNodeDeviceDriverReload(void)
{ {
return 0; return 0;
} }
@ -1780,19 +1780,19 @@ static virDrvOpenStatus udevNodeDrvOpen(virConnectPtr conn,
return VIR_DRV_OPEN_DECLINED; return VIR_DRV_OPEN_DECLINED;
} }
conn->devMonPrivateData = driverState; conn->nodeDevicePrivateData = driverState;
return VIR_DRV_OPEN_SUCCESS; return VIR_DRV_OPEN_SUCCESS;
} }
static int udevNodeDrvClose(virConnectPtr conn) static int udevNodeDrvClose(virConnectPtr conn)
{ {
conn->devMonPrivateData = NULL; conn->nodeDevicePrivateData = NULL;
return 0; return 0;
} }
static virDeviceMonitor udevDeviceMonitor = { static virNodeDeviceDriver udevNodeDeviceDriver = {
.name = "udevDeviceMonitor", .name = "udevNodeDeviceDriver",
.connectOpen = udevNodeDrvOpen, /* 0.7.3 */ .connectOpen = udevNodeDrvOpen, /* 0.7.3 */
.connectClose = udevNodeDrvClose, /* 0.7.3 */ .connectClose = udevNodeDrvClose, /* 0.7.3 */
.nodeNumOfDevices = nodeNumOfDevices, /* 0.7.3 */ .nodeNumOfDevices = nodeNumOfDevices, /* 0.7.3 */
@ -1810,16 +1810,16 @@ static virDeviceMonitor udevDeviceMonitor = {
static virStateDriver udevStateDriver = { static virStateDriver udevStateDriver = {
.name = "udev", .name = "udev",
.stateInitialize = udevDeviceMonitorStartup, /* 0.7.3 */ .stateInitialize = udevNodeDeviceDriverStartup, /* 0.7.3 */
.stateCleanup = udevDeviceMonitorShutdown, /* 0.7.3 */ .stateCleanup = udevNodeDeviceDriverShutdown, /* 0.7.3 */
.stateReload = udevDeviceMonitorReload, /* 0.7.3 */ .stateReload = udevNodeDeviceDriverReload, /* 0.7.3 */
}; };
int udevNodeRegister(void) int udevNodeRegister(void)
{ {
VIR_DEBUG("Registering udev node device backend"); VIR_DEBUG("Registering udev node device backend");
if (virRegisterDeviceMonitor(&udevDeviceMonitor) < 0) { if (virRegisterNodeDeviceDriver(&udevNodeDeviceDriver) < 0) {
return -1; return -1;
} }

24
src/remote/remote_driver.c
View File

@ -3367,16 +3367,16 @@ done:
/*----------------------------------------------------------------------*/ /*----------------------------------------------------------------------*/
static virDrvOpenStatus ATTRIBUTE_NONNULL(1) static virDrvOpenStatus ATTRIBUTE_NONNULL(1)
remoteDevMonOpen(virConnectPtr conn, virConnectAuthPtr auth, remoteNodeDeviceOpen(virConnectPtr conn, virConnectAuthPtr auth,
unsigned int flags) unsigned int flags)
{ {
return remoteGenericOpen(conn, auth, flags, &conn->devMonPrivateData); return remoteGenericOpen(conn, auth, flags, &conn->nodeDevicePrivateData);
} }
static int static int
remoteDevMonClose(virConnectPtr conn) remoteNodeDeviceClose(virConnectPtr conn)
{ {
return remoteGenericClose(conn, &conn->devMonPrivateData); return remoteGenericClose(conn, &conn->nodeDevicePrivateData);
} }
static int static int
@ -3385,7 +3385,7 @@ remoteNodeDeviceDettach(virNodeDevicePtr dev)
int rv = -1; int rv = -1;
remote_node_device_dettach_args args; remote_node_device_dettach_args args;
/* This method is unusual in that it uses the HV driver, not the devMon driver /* This method is unusual in that it uses the HV driver, not the devMon driver
* hence its use of privateData, instead of devMonPrivateData */ * hence its use of privateData, instead of nodeDevicePrivateData */
struct private_data *priv = dev->conn->privateData; struct private_data *priv = dev->conn->privateData;
remoteDriverLock(priv); remoteDriverLock(priv);
@ -3410,7 +3410,7 @@ remoteNodeDeviceReAttach(virNodeDevicePtr dev)
int rv = -1; int rv = -1;
remote_node_device_re_attach_args args; remote_node_device_re_attach_args args;
/* This method is unusual in that it uses the HV driver, not the devMon driver /* This method is unusual in that it uses the HV driver, not the devMon driver
* hence its use of privateData, instead of devMonPrivateData */ * hence its use of privateData, instead of nodeDevicePrivateData */
struct private_data *priv = dev->conn->privateData; struct private_data *priv = dev->conn->privateData;
remoteDriverLock(priv); remoteDriverLock(priv);
@ -3435,7 +3435,7 @@ remoteNodeDeviceReset(virNodeDevicePtr dev)
int rv = -1; int rv = -1;
remote_node_device_reset_args args; remote_node_device_reset_args args;
/* This method is unusual in that it uses the HV driver, not the devMon driver /* This method is unusual in that it uses the HV driver, not the devMon driver
* hence its use of privateData, instead of devMonPrivateData */ * hence its use of privateData, instead of nodeDevicePrivateData */
struct private_data *priv = dev->conn->privateData; struct private_data *priv = dev->conn->privateData;
remoteDriverLock(priv); remoteDriverLock(priv);
@ -6414,10 +6414,10 @@ static virSecretDriver secret_driver = {
.secretUndefine = remoteSecretUndefine /* 0.7.1 */ .secretUndefine = remoteSecretUndefine /* 0.7.1 */
}; };
static virDeviceMonitor dev_monitor = { static virNodeDeviceDriver node_device_driver = {
.name = "remote", .name = "remote",
.connectOpen = remoteDevMonOpen, /* 0.5.0 */ .connectOpen = remoteNodeDeviceOpen, /* 0.5.0 */
.connectClose = remoteDevMonClose, /* 0.5.0 */ .connectClose = remoteNodeDeviceClose, /* 0.5.0 */
.nodeNumOfDevices = remoteNodeNumOfDevices, /* 0.5.0 */ .nodeNumOfDevices = remoteNodeNumOfDevices, /* 0.5.0 */
.nodeListDevices = remoteNodeListDevices, /* 0.5.0 */ .nodeListDevices = remoteNodeListDevices, /* 0.5.0 */
.connectListAllNodeDevices = remoteConnectListAllNodeDevices, /* 0.10.2 */ .connectListAllNodeDevices = remoteConnectListAllNodeDevices, /* 0.10.2 */
@ -6469,7 +6469,7 @@ remoteRegister(void)
if (virRegisterNetworkDriver(&network_driver) == -1) return -1; if (virRegisterNetworkDriver(&network_driver) == -1) return -1;
if (virRegisterInterfaceDriver(&interface_driver) == -1) return -1; if (virRegisterInterfaceDriver(&interface_driver) == -1) return -1;
if (virRegisterStorageDriver(&storage_driver) == -1) return -1; if (virRegisterStorageDriver(&storage_driver) == -1) return -1;
if (virRegisterDeviceMonitor(&dev_monitor) == -1) return -1; if (virRegisterNodeDeviceDriver(&node_device_driver) == -1) return -1;
if (virRegisterSecretDriver(&secret_driver) == -1) return -1; if (virRegisterSecretDriver(&secret_driver) == -1) return -1;
if (virRegisterNWFilterDriver(&nwfilter_driver) == -1) return -1; if (virRegisterNWFilterDriver(&nwfilter_driver) == -1) return -1;
#ifdef WITH_LIBVIRTD #ifdef WITH_LIBVIRTD

4
src/rpc/gendispatch.pl
View File

@ -1072,7 +1072,7 @@ elsif ($mode eq "client") {
!($argtype =~ m/^remote_node_device_lookup_by_name_/) and !($argtype =~ m/^remote_node_device_lookup_by_name_/) and
!($argtype =~ m/^remote_node_device_create_xml_/)) { !($argtype =~ m/^remote_node_device_create_xml_/)) {
$has_node_device = 1; $has_node_device = 1;
$priv_name = "devMonPrivateData"; $priv_name = "nodeDevicePrivateData";
} }
foreach my $args_member (@{$call->{args_members}}) { foreach my $args_member (@{$call->{args_members}}) {
@ -1309,7 +1309,7 @@ elsif ($mode eq "client") {
my $type_name = name_to_TypeName($name); my $type_name = name_to_TypeName($name);
if ($name eq "node_device") { if ($name eq "node_device") {
$priv_name = "devMonPrivateData"; $priv_name = "nodeDevicePrivateData";
} elsif ($name =~ m/^storage_/) { } elsif ($name =~ m/^storage_/) {
$priv_name = "storagePrivateData"; $priv_name = "storagePrivateData";
} elsif (!($name =~ m/^domain/)) { } elsif (!($name =~ m/^domain/)) {

20
src/test/test_driver.c
View File

@ -5245,21 +5245,21 @@ cleanup:
/* Node device implementations */ /* Node device implementations */
static virDrvOpenStatus testDevMonOpen(virConnectPtr conn, static virDrvOpenStatus testNodeDeviceOpen(virConnectPtr conn,
virConnectAuthPtr auth ATTRIBUTE_UNUSED, virConnectAuthPtr auth ATTRIBUTE_UNUSED,
unsigned int flags) unsigned int flags)
{ {
virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR); virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR);
if (STRNEQ(conn->driver->name, "Test")) if (STRNEQ(conn->driver->name, "Test"))
return VIR_DRV_OPEN_DECLINED; return VIR_DRV_OPEN_DECLINED;
conn->devMonPrivateData = conn->privateData; conn->nodeDevicePrivateData = conn->privateData;
return VIR_DRV_OPEN_SUCCESS; return VIR_DRV_OPEN_SUCCESS;
} }
static int testDevMonClose(virConnectPtr conn) { static int testNodeDeviceClose(virConnectPtr conn) {
conn->devMonPrivateData = NULL; conn->nodeDevicePrivateData = NULL;
return 0; return 0;
} }
@ -5952,10 +5952,10 @@ static virStorageDriver testStorageDriver = {
.storagePoolIsPersistent = testStoragePoolIsPersistent, /* 0.7.3 */ .storagePoolIsPersistent = testStoragePoolIsPersistent, /* 0.7.3 */
}; };
static virDeviceMonitor testDevMonitor = { static virNodeDeviceDriver testNodeDeviceDriver = {
.name = "Test", .name = "Test",
.connectOpen = testDevMonOpen, /* 0.6.0 */ .connectOpen = testNodeDeviceOpen, /* 0.6.0 */
.connectClose = testDevMonClose, /* 0.6.0 */ .connectClose = testNodeDeviceClose, /* 0.6.0 */
.nodeNumOfDevices = testNodeNumOfDevices, /* 0.7.2 */ .nodeNumOfDevices = testNodeNumOfDevices, /* 0.7.2 */
.nodeListDevices = testNodeListDevices, /* 0.7.2 */ .nodeListDevices = testNodeListDevices, /* 0.7.2 */
@ -5997,7 +5997,7 @@ testRegister(void)
return -1; return -1;
if (virRegisterStorageDriver(&testStorageDriver) < 0) if (virRegisterStorageDriver(&testStorageDriver) < 0)
return -1; return -1;
if (virRegisterDeviceMonitor(&testDevMonitor) < 0) if (virRegisterNodeDeviceDriver(&testNodeDeviceDriver) < 0)
return -1; return -1;
if (virRegisterSecretDriver(&testSecretDriver) < 0) if (virRegisterSecretDriver(&testSecretDriver) < 0)
return -1; return -1;

4
tests/object-locking.ml
View File

@ -47,7 +47,7 @@ let driverTables = [
"virDriver"; "virDriver";
"virNetworkDriver"; "virNetworkDriver";
"virStorageDriver"; "virStorageDriver";
"virDeviceMonitor"; "virNodeDeviceDriver";
(* "virStateDriver"; Disable for now, since shutdown/startup have weird locking rules *) (* "virStateDriver"; Disable for now, since shutdown/startup have weird locking rules *)
] ]
@ -160,7 +160,7 @@ let lockableDrivers = [
"uml_driver"; "uml_driver";
"virStorageDriverStatePtr"; "virStorageDriverStatePtr";
"network_driver"; "network_driver";
"virDeviceMonitorState"; "virNodeDeviceState";
"one_driver_t"; "one_driver_t";
] ]