External/libvirt
1
0
Fork 0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2025-03-07 17:28:15 +00:00
Code

Remove use of nodeDevicePrivateData from nodeDev driver

Browse Source 
The node device driver can rely on its global state instead
of the connect private data.
This commit is contained in:
Daniel P. Berrange 2014-11-17 16:30:27 +00:00
parent 47b7f661a4
commit 60b966b378
4 changed files with 99 additions and 120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
src/node_device/node_device_driver.c
View File

@ -43,6 +43,8 @@
#define VIR_FROM_THIS VIR_FROM_NODEDEV #define VIR_FROM_THIS VIR_FROM_NODEDEV
virNodeDeviceDriverStatePtr driver;
static int update_caps(virNodeDeviceObjPtr dev) static int update_caps(virNodeDeviceObjPtr dev)
{ {
virNodeDevCapsDefPtr cap = dev->def->caps; virNodeDevCapsDefPtr cap = dev->def->caps;
@ -114,11 +116,11 @@ static int update_driver_name(virNodeDeviceObjPtr dev ATTRIBUTE_UNUSED)
#endif #endif
void nodeDeviceLock(virNodeDeviceDriverStatePtr driver) void nodeDeviceLock(void)
{ {
virMutexLock(&driver->lock); virMutexLock(&driver->lock);
} }
void nodeDeviceUnlock(virNodeDeviceDriverStatePtr driver) void nodeDeviceUnlock(void)
{ {
virMutexUnlock(&driver->lock); virMutexUnlock(&driver->lock);
} }
@ -128,7 +130,6 @@ nodeNumOfDevices(virConnectPtr conn,
const char *cap, const char *cap,
unsigned int flags) unsigned int flags)
{ {
virNodeDeviceDriverStatePtr driver = conn->nodeDevicePrivateData;
int ndevs = 0; int ndevs = 0;
size_t i; size_t i;
@ -137,7 +138,7 @@ nodeNumOfDevices(virConnectPtr conn,
virCheckFlags(0, -1); virCheckFlags(0, -1);
nodeDeviceLock(driver); nodeDeviceLock();
for (i = 0; i < driver->devs.count; i++) { for (i = 0; i < driver->devs.count; i++) {
virNodeDeviceObjPtr obj = driver->devs.objs[i]; virNodeDeviceObjPtr obj = driver->devs.objs[i];
virNodeDeviceObjLock(obj); virNodeDeviceObjLock(obj);
@ -147,7 +148,7 @@ nodeNumOfDevices(virConnectPtr conn,
++ndevs; ++ndevs;
virNodeDeviceObjUnlock(obj); virNodeDeviceObjUnlock(obj);
} }
nodeDeviceUnlock(driver); nodeDeviceUnlock();
return ndevs; return ndevs;
} }
@ -158,7 +159,6 @@ nodeListDevices(virConnectPtr conn,
char **const names, int maxnames, char **const names, int maxnames,
unsigned int flags) unsigned int flags)
{ {
virNodeDeviceDriverStatePtr driver = conn->nodeDevicePrivateData;
int ndevs = 0; int ndevs = 0;
size_t i; size_t i;
@ -167,7 +167,7 @@ nodeListDevices(virConnectPtr conn,
virCheckFlags(0, -1); virCheckFlags(0, -1);
nodeDeviceLock(driver); nodeDeviceLock();
for (i = 0; i < driver->devs.count && ndevs < maxnames; i++) { for (i = 0; i < driver->devs.count && ndevs < maxnames; i++) {
virNodeDeviceObjPtr obj = driver->devs.objs[i]; virNodeDeviceObjPtr obj = driver->devs.objs[i];
virNodeDeviceObjLock(obj); virNodeDeviceObjLock(obj);
@ -181,12 +181,12 @@ nodeListDevices(virConnectPtr conn,
} }
virNodeDeviceObjUnlock(obj); virNodeDeviceObjUnlock(obj);
} }
nodeDeviceUnlock(driver); nodeDeviceUnlock();
return ndevs; return ndevs;
failure: failure:
nodeDeviceUnlock(driver); nodeDeviceUnlock();
--ndevs; --ndevs;
while (--ndevs >= 0) while (--ndevs >= 0)
VIR_FREE(names[ndevs]); VIR_FREE(names[ndevs]);
@ -198,7 +198,6 @@ nodeConnectListAllNodeDevices(virConnectPtr conn,
virNodeDevicePtr **devices, virNodeDevicePtr **devices,
unsigned int flags) unsigned int flags)
{ {
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);
@ -206,24 +205,23 @@ nodeConnectListAllNodeDevices(virConnectPtr conn,
if (virConnectListAllNodeDevicesEnsureACL(conn) < 0) if (virConnectListAllNodeDevicesEnsureACL(conn) < 0)
return -1; return -1;
nodeDeviceLock(driver); nodeDeviceLock();
ret = virNodeDeviceObjListExport(conn, driver->devs, devices, ret = virNodeDeviceObjListExport(conn, driver->devs, devices,
virConnectListAllNodeDevicesCheckACL, virConnectListAllNodeDevicesCheckACL,
flags); flags);
nodeDeviceUnlock(driver); nodeDeviceUnlock();
return ret; return ret;
} }
virNodeDevicePtr virNodeDevicePtr
nodeDeviceLookupByName(virConnectPtr conn, const char *name) nodeDeviceLookupByName(virConnectPtr conn, const char *name)
{ {
virNodeDeviceDriverStatePtr driver = conn->nodeDevicePrivateData;
virNodeDeviceObjPtr obj; virNodeDeviceObjPtr obj;
virNodeDevicePtr ret = NULL; virNodeDevicePtr ret = NULL;
nodeDeviceLock(driver); nodeDeviceLock();
obj = virNodeDeviceFindByName(&driver->devs, name); obj = virNodeDeviceFindByName(&driver->devs, name);
nodeDeviceUnlock(driver); nodeDeviceUnlock();
if (!obj) { if (!obj) {
virReportError(VIR_ERR_NO_NODE_DEVICE, NULL); virReportError(VIR_ERR_NO_NODE_DEVICE, NULL);
@ -249,7 +247,6 @@ nodeDeviceLookupSCSIHostByWWN(virConnectPtr conn,
unsigned int flags) unsigned int flags)
{ {
size_t i; size_t i;
virNodeDeviceDriverStatePtr driver = conn->nodeDevicePrivateData;
virNodeDeviceObjListPtr devs = &driver->devs; virNodeDeviceObjListPtr devs = &driver->devs;
virNodeDevCapsDefPtr cap = NULL; virNodeDevCapsDefPtr cap = NULL;
virNodeDeviceObjPtr obj = NULL; virNodeDeviceObjPtr obj = NULL;
@ -257,7 +254,7 @@ nodeDeviceLookupSCSIHostByWWN(virConnectPtr conn,
virCheckFlags(0, NULL); virCheckFlags(0, NULL);
nodeDeviceLock(driver); nodeDeviceLock();
for (i = 0; i < devs->count; i++) { for (i = 0; i < devs->count; i++) {
obj = devs->objs[i]; obj = devs->objs[i];
@ -288,7 +285,7 @@ nodeDeviceLookupSCSIHostByWWN(virConnectPtr conn,
} }
out: out:
nodeDeviceUnlock(driver); nodeDeviceUnlock();
return dev; return dev;
} }
@ -297,15 +294,14 @@ char *
nodeDeviceGetXMLDesc(virNodeDevicePtr dev, nodeDeviceGetXMLDesc(virNodeDevicePtr dev,
unsigned int flags) unsigned int flags)
{ {
virNodeDeviceDriverStatePtr driver = dev->conn->nodeDevicePrivateData;
virNodeDeviceObjPtr obj; virNodeDeviceObjPtr obj;
char *ret = NULL; char *ret = NULL;
virCheckFlags(0, NULL); virCheckFlags(0, NULL);
nodeDeviceLock(driver); nodeDeviceLock();
obj = virNodeDeviceFindByName(&driver->devs, dev->name); obj = virNodeDeviceFindByName(&driver->devs, dev->name);
nodeDeviceUnlock(driver); nodeDeviceUnlock();
if (!obj) { if (!obj) {
virReportError(VIR_ERR_NO_NODE_DEVICE, virReportError(VIR_ERR_NO_NODE_DEVICE,
@ -333,13 +329,12 @@ nodeDeviceGetXMLDesc(virNodeDevicePtr dev,
char * char *
nodeDeviceGetParent(virNodeDevicePtr dev) nodeDeviceGetParent(virNodeDevicePtr dev)
{ {
virNodeDeviceDriverStatePtr driver = dev->conn->nodeDevicePrivateData;
virNodeDeviceObjPtr obj; virNodeDeviceObjPtr obj;
char *ret = NULL; char *ret = NULL;
nodeDeviceLock(driver); nodeDeviceLock();
obj = virNodeDeviceFindByName(&driver->devs, dev->name); obj = virNodeDeviceFindByName(&driver->devs, dev->name);
nodeDeviceUnlock(driver); nodeDeviceUnlock();
if (!obj) { if (!obj) {
virReportError(VIR_ERR_NO_NODE_DEVICE, virReportError(VIR_ERR_NO_NODE_DEVICE,
@ -369,15 +364,14 @@ nodeDeviceGetParent(virNodeDevicePtr dev)
int int
nodeDeviceNumOfCaps(virNodeDevicePtr dev) nodeDeviceNumOfCaps(virNodeDevicePtr dev)
{ {
virNodeDeviceDriverStatePtr driver = dev->conn->nodeDevicePrivateData;
virNodeDeviceObjPtr obj; virNodeDeviceObjPtr obj;
virNodeDevCapsDefPtr caps; virNodeDevCapsDefPtr caps;
int ncaps = 0; int ncaps = 0;
int ret = -1; int ret = -1;
nodeDeviceLock(driver); nodeDeviceLock();
obj = virNodeDeviceFindByName(&driver->devs, dev->name); obj = virNodeDeviceFindByName(&driver->devs, dev->name);
nodeDeviceUnlock(driver); nodeDeviceUnlock();
if (!obj) { if (!obj) {
virReportError(VIR_ERR_NO_NODE_DEVICE, virReportError(VIR_ERR_NO_NODE_DEVICE,
@ -403,15 +397,14 @@ nodeDeviceNumOfCaps(virNodeDevicePtr dev)
int int
nodeDeviceListCaps(virNodeDevicePtr dev, char **const names, int maxnames) nodeDeviceListCaps(virNodeDevicePtr dev, char **const names, int maxnames)
{ {
virNodeDeviceDriverStatePtr driver = dev->conn->nodeDevicePrivateData;
virNodeDeviceObjPtr obj; virNodeDeviceObjPtr obj;
virNodeDevCapsDefPtr caps; virNodeDevCapsDefPtr caps;
int ncaps = 0; int ncaps = 0;
int ret = -1; int ret = -1;
nodeDeviceLock(driver); nodeDeviceLock();
obj = virNodeDeviceFindByName(&driver->devs, dev->name); obj = virNodeDeviceFindByName(&driver->devs, dev->name);
nodeDeviceUnlock(driver); nodeDeviceUnlock();
if (!obj) { if (!obj) {
virReportError(VIR_ERR_NO_NODE_DEVICE, virReportError(VIR_ERR_NO_NODE_DEVICE,
@ -474,7 +467,6 @@ 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)
{ {
virNodeDeviceDriverStatePtr driver = conn->nodeDevicePrivateData;
virNodeDevicePtr dev = NULL; virNodeDevicePtr dev = NULL;
time_t start = 0, now = 0; time_t start = 0, now = 0;
@ -483,7 +475,7 @@ find_new_device(virConnectPtr conn, const char *wwnn, const char *wwpn)
* We're not doing anything with the driver pointer at this point, * We're not doing anything with the driver pointer at this point,
* so it's safe to release it, assuming that the pointer itself * so it's safe to release it, assuming that the pointer itself
* doesn't become invalid. */ * doesn't become invalid. */
nodeDeviceUnlock(driver); nodeDeviceUnlock();
get_time(&start); get_time(&start);
@ -501,7 +493,7 @@ find_new_device(virConnectPtr conn, const char *wwnn, const char *wwpn)
break; break;
} }
nodeDeviceLock(driver); nodeDeviceLock();
return dev; return dev;
} }
@ -511,7 +503,6 @@ nodeDeviceCreateXML(virConnectPtr conn,
const char *xmlDesc, const char *xmlDesc,
unsigned int flags) unsigned int flags)
{ {
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;
@ -521,7 +512,7 @@ nodeDeviceCreateXML(virConnectPtr conn,
virCheckFlags(0, NULL); virCheckFlags(0, NULL);
virt_type = virConnectGetType(conn); virt_type = virConnectGetType(conn);
nodeDeviceLock(driver); nodeDeviceLock();
def = virNodeDeviceDefParseString(xmlDesc, CREATE_DEVICE, virt_type); def = virNodeDeviceDefParseString(xmlDesc, CREATE_DEVICE, virt_type);
if (def == NULL) if (def == NULL)
@ -555,7 +546,7 @@ nodeDeviceCreateXML(virConnectPtr conn,
virReportError(VIR_ERR_NO_NODE_DEVICE, NULL); virReportError(VIR_ERR_NO_NODE_DEVICE, NULL);
cleanup: cleanup:
nodeDeviceUnlock(driver); nodeDeviceUnlock();
virNodeDeviceDefFree(def); virNodeDeviceDefFree(def);
VIR_FREE(wwnn); VIR_FREE(wwnn);
VIR_FREE(wwpn); VIR_FREE(wwpn);
@ -567,14 +558,13 @@ int
nodeDeviceDestroy(virNodeDevicePtr dev) nodeDeviceDestroy(virNodeDevicePtr dev)
{ {
int ret = -1; int ret = -1;
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;
nodeDeviceLock(driver); nodeDeviceLock();
obj = virNodeDeviceFindByName(&driver->devs, dev->name); obj = virNodeDeviceFindByName(&driver->devs, dev->name);
nodeDeviceUnlock(driver); nodeDeviceUnlock();
if (!obj) { if (!obj) {
virReportError(VIR_ERR_NO_NODE_DEVICE, NULL); virReportError(VIR_ERR_NO_NODE_DEVICE, NULL);

6
src/node_device/node_device_driver.h
View File

@ -37,8 +37,10 @@ int halNodeRegister(void);
int udevNodeRegister(void); int udevNodeRegister(void);
# endif # endif
void nodeDeviceLock(virNodeDeviceDriverStatePtr driver); void nodeDeviceLock(void);
void nodeDeviceUnlock(virNodeDeviceDriverStatePtr driver); void nodeDeviceUnlock(void);
extern virNodeDeviceDriverStatePtr driver;
int nodedevRegister(void); int nodedevRegister(void);

84
src/node_device/node_device_hal.c
View File

@ -49,12 +49,7 @@ VIR_LOG_INIT("node_device.node_device_hal");
* Host device enumeration (HAL implementation) * Host device enumeration (HAL implementation)
*/ */
static virNodeDeviceDriverStatePtr driverState;
#define CONN_DRV_STATE(conn) \
((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 NODE_DEV_UDI(obj) ((const char *)((obj)->privateData) #define NODE_DEV_UDI(obj) ((const char *)((obj)->privateData)
@ -481,8 +476,8 @@ dev_create(const char *udi)
if (VIR_STRDUP(privData, udi) < 0) if (VIR_STRDUP(privData, udi) < 0)
return; return;
nodeDeviceLock(driverState); nodeDeviceLock();
ctx = DRV_STATE_HAL_CTX(driverState); ctx = DRV_STATE_HAL_CTX(driver);
if (VIR_ALLOC(def) < 0) if (VIR_ALLOC(def) < 0)
goto failure; goto failure;
@ -507,7 +502,7 @@ dev_create(const char *udi)
/* Some devices don't have a path in sysfs, so ignore failure */ /* Some devices don't have a path in sysfs, so ignore failure */
(void)get_str_prop(ctx, udi, "linux.sysfs_path", &devicePath); (void)get_str_prop(ctx, udi, "linux.sysfs_path", &devicePath);
dev = virNodeDeviceAssignDef(&driverState->devs, dev = virNodeDeviceAssignDef(&driver->devs,
def); def);
if (!dev) { if (!dev) {
@ -521,7 +516,7 @@ dev_create(const char *udi)
virNodeDeviceObjUnlock(dev); virNodeDeviceObjUnlock(dev);
nodeDeviceUnlock(driverState); nodeDeviceUnlock();
return; return;
failure: failure:
@ -529,7 +524,7 @@ dev_create(const char *udi)
cleanup: cleanup:
VIR_FREE(privData); VIR_FREE(privData);
virNodeDeviceDefFree(def); virNodeDeviceDefFree(def);
nodeDeviceUnlock(driverState); nodeDeviceUnlock();
} }
static void static void
@ -538,17 +533,17 @@ dev_refresh(const char *udi)
const char *name = hal_name(udi); const char *name = hal_name(udi);
virNodeDeviceObjPtr dev; virNodeDeviceObjPtr dev;
nodeDeviceLock(driverState); nodeDeviceLock();
dev = virNodeDeviceFindByName(&driverState->devs, name); dev = virNodeDeviceFindByName(&driver->devs, name);
if (dev) { if (dev) {
/* Simply "rediscover" device -- incrementally handling changes /* Simply "rediscover" device -- incrementally handling changes
* to sub-capabilities (like net.80203) is nasty ... so avoid it. * to sub-capabilities (like net.80203) is nasty ... so avoid it.
*/ */
virNodeDeviceObjRemove(&driverState->devs, dev); virNodeDeviceObjRemove(&driver->devs, dev);
} else { } else {
VIR_DEBUG("no device named %s", name); VIR_DEBUG("no device named %s", name);
} }
nodeDeviceUnlock(driverState); nodeDeviceUnlock();
if (dev) if (dev)
dev_create(udi); dev_create(udi);
@ -570,14 +565,14 @@ device_removed(LibHalContext *ctx ATTRIBUTE_UNUSED,
const char *name = hal_name(udi); const char *name = hal_name(udi);
virNodeDeviceObjPtr dev; virNodeDeviceObjPtr dev;
nodeDeviceLock(driverState); nodeDeviceLock();
dev = virNodeDeviceFindByName(&driverState->devs, name); dev = virNodeDeviceFindByName(&driver->devs, name);
VIR_DEBUG("%s", name); VIR_DEBUG("%s", name);
if (dev) if (dev)
virNodeDeviceObjRemove(&driverState->devs, dev); virNodeDeviceObjRemove(&driver->devs, dev);
else else
VIR_DEBUG("no device named %s", name); VIR_DEBUG("no device named %s", name);
nodeDeviceUnlock(driverState); nodeDeviceUnlock();
} }
@ -588,9 +583,9 @@ device_cap_added(LibHalContext *ctx,
const char *name = hal_name(udi); const char *name = hal_name(udi);
virNodeDeviceObjPtr dev; virNodeDeviceObjPtr dev;
nodeDeviceLock(driverState); nodeDeviceLock();
dev = virNodeDeviceFindByName(&driverState->devs, name); dev = virNodeDeviceFindByName(&driver->devs, name);
nodeDeviceUnlock(driverState); nodeDeviceUnlock();
VIR_DEBUG("%s %s", cap, name); VIR_DEBUG("%s %s", cap, name);
if (dev) { if (dev) {
(void)gather_capability(ctx, udi, cap, &dev->def->caps); (void)gather_capability(ctx, udi, cap, &dev->def->caps);
@ -644,14 +639,14 @@ nodeStateInitialize(bool privileged ATTRIBUTE_UNUSED,
qsort(caps_tbl, ARRAY_CARDINALITY(caps_tbl), sizeof(caps_tbl[0]), qsort(caps_tbl, ARRAY_CARDINALITY(caps_tbl), sizeof(caps_tbl[0]),
cmpstringp); cmpstringp);
if (VIR_ALLOC(driverState) < 0) if (VIR_ALLOC(driver) < 0)
return -1; return -1;
if (virMutexInit(&driverState->lock) < 0) { if (virMutexInit(&driver->lock) < 0) {
VIR_FREE(driverState); VIR_FREE(driver);
return -1; return -1;
} }
nodeDeviceLock(driverState); nodeDeviceLock();
dbus_error_init(&err); dbus_error_init(&err);
if (!(sysbus = virDBusGetSystemBus())) { if (!(sysbus = virDBusGetSystemBus())) {
@ -682,14 +677,14 @@ nodeStateInitialize(bool privileged ATTRIBUTE_UNUSED,
} }
/* Populate with known devices */ /* Populate with known devices */
driverState->privateData = hal_ctx; driver->privateData = hal_ctx;
/* We need to unlock state now, since setting these callbacks cause /* We need to unlock state now, since setting these callbacks cause
* a dbus RPC call, and while this call is waiting for the reply, * a dbus RPC call, and while this call is waiting for the reply,
* a signal may already arrive, triggering the callback and thus * a signal may already arrive, triggering the callback and thus
* requiring the lock ! * requiring the lock !
*/ */
nodeDeviceUnlock(driverState); nodeDeviceUnlock();
/* Register HAL event callbacks */ /* Register HAL event callbacks */
if (!libhal_ctx_set_device_added(hal_ctx, device_added) || if (!libhal_ctx_set_device_added(hal_ctx, device_added) ||
@ -720,11 +715,11 @@ nodeStateInitialize(bool privileged ATTRIBUTE_UNUSED,
VIR_ERROR(_("%s: %s"), err.name, err.message); VIR_ERROR(_("%s: %s"), err.name, err.message);
dbus_error_free(&err); dbus_error_free(&err);
} }
virNodeDeviceObjListFree(&driverState->devs); virNodeDeviceObjListFree(&driver->devs);
if (hal_ctx) if (hal_ctx)
(void)libhal_ctx_free(hal_ctx); (void)libhal_ctx_free(hal_ctx);
nodeDeviceUnlock(driverState); nodeDeviceUnlock();
VIR_FREE(driverState); VIR_FREE(driver);
return ret; return ret;
} }
@ -733,15 +728,15 @@ nodeStateInitialize(bool privileged ATTRIBUTE_UNUSED,
static int static int
nodeStateCleanup(void) nodeStateCleanup(void)
{ {
if (driverState) { if (driver) {
nodeDeviceLock(driverState); nodeDeviceLock();
LibHalContext *hal_ctx = DRV_STATE_HAL_CTX(driverState); LibHalContext *hal_ctx = DRV_STATE_HAL_CTX(driver);
virNodeDeviceObjListFree(&driverState->devs); virNodeDeviceObjListFree(&driver->devs);
(void)libhal_ctx_shutdown(hal_ctx, NULL); (void)libhal_ctx_shutdown(hal_ctx, NULL);
(void)libhal_ctx_free(hal_ctx); (void)libhal_ctx_free(hal_ctx);
nodeDeviceUnlock(driverState); nodeDeviceUnlock();
virMutexDestroy(&driverState->lock); virMutexDestroy(&driver->lock);
VIR_FREE(driverState); VIR_FREE(driver);
return 0; return 0;
} }
return -1; return -1;
@ -758,12 +753,12 @@ nodeStateReload(void)
LibHalContext *hal_ctx; LibHalContext *hal_ctx;
VIR_INFO("Reloading HAL device state"); VIR_INFO("Reloading HAL device state");
nodeDeviceLock(driverState); nodeDeviceLock();
VIR_INFO("Removing existing objects"); VIR_INFO("Removing existing objects");
virNodeDeviceObjListFree(&driverState->devs); virNodeDeviceObjListFree(&driver->devs);
nodeDeviceUnlock(driverState); nodeDeviceUnlock();
hal_ctx = DRV_STATE_HAL_CTX(driverState); hal_ctx = DRV_STATE_HAL_CTX(driver);
VIR_INFO("Creating new objects"); VIR_INFO("Creating new objects");
dbus_error_init(&err); dbus_error_init(&err);
udi = libhal_get_all_devices(hal_ctx, &num_devs, &err); udi = libhal_get_all_devices(hal_ctx, &num_devs, &err);
@ -783,24 +778,21 @@ nodeStateReload(void)
static virDrvOpenStatus static virDrvOpenStatus
nodeDeviceOpen(virConnectPtr conn, nodeDeviceOpen(virConnectPtr conn ATTRIBUTE_UNUSED,
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 (driverState == NULL) if (driver == NULL)
return VIR_DRV_OPEN_DECLINED; return VIR_DRV_OPEN_DECLINED;
conn->nodeDevicePrivateData = driverState;
return VIR_DRV_OPEN_SUCCESS; return VIR_DRV_OPEN_SUCCESS;
} }
static int static int
nodeDeviceClose(virConnectPtr conn ATTRIBUTE_UNUSED) nodeDeviceClose(virConnectPtr conn ATTRIBUTE_UNUSED)
{ {
conn->nodeDevicePrivateData = NULL;
return 0; return 0;
} }

61
src/node_device/node_device_udev.c
View File

@ -56,8 +56,6 @@ struct _udevPrivate {
bool privileged; bool privileged;
}; };
static virNodeDeviceDriverStatePtr driverState;
static int udevStrToLong_ull(char const *s, static int udevStrToLong_ull(char const *s,
char **end_ptr, char **end_ptr,
int base, int base,
@ -419,7 +417,7 @@ static int udevProcessPCI(struct udev_device *device,
virPCIDeviceAddress addr; virPCIDeviceAddress addr;
virPCIEDeviceInfoPtr pci_express = NULL; virPCIEDeviceInfoPtr pci_express = NULL;
virPCIDevicePtr pciDev = NULL; virPCIDevicePtr pciDev = NULL;
udevPrivate *priv = driverState->privateData; udevPrivate *priv = driver->privateData;
int tmpGroup, ret = -1; int tmpGroup, ret = -1;
char *p; char *p;
int rc; int rc;
@ -1330,12 +1328,12 @@ static int udevRemoveOneDevice(struct udev_device *device)
int ret = 0; int ret = 0;
name = udev_device_get_syspath(device); name = udev_device_get_syspath(device);
dev = virNodeDeviceFindBySysfsPath(&driverState->devs, name); dev = virNodeDeviceFindBySysfsPath(&driver->devs, name);
if (dev != NULL) { if (dev != NULL) {
VIR_DEBUG("Removing device '%s' with sysfs path '%s'", VIR_DEBUG("Removing device '%s' with sysfs path '%s'",
dev->def->name, name); dev->def->name, name);
virNodeDeviceObjRemove(&driverState->devs, dev); virNodeDeviceObjRemove(&driver->devs, dev);
} else { } else {
VIR_DEBUG("Failed to find device to remove that has udev name '%s'", VIR_DEBUG("Failed to find device to remove that has udev name '%s'",
name); name);
@ -1369,7 +1367,7 @@ static int udevSetParent(struct udev_device *device,
goto out; goto out;
} }
dev = virNodeDeviceFindBySysfsPath(&driverState->devs, dev = virNodeDeviceFindBySysfsPath(&driver->devs,
parent_sysfs_path); parent_sysfs_path);
if (dev != NULL) { if (dev != NULL) {
if (VIR_STRDUP(def->parent, dev->def->name) < 0) { if (VIR_STRDUP(def->parent, dev->def->name) < 0) {
@ -1426,7 +1424,7 @@ static int udevAddOneDevice(struct udev_device *device)
/* If this is a device change, the old definition will be freed /* If this is a device change, the old definition will be freed
* and the current definition will take its place. */ * and the current definition will take its place. */
dev = virNodeDeviceAssignDef(&driverState->devs, def); dev = virNodeDeviceAssignDef(&driver->devs, def);
if (dev == NULL) { if (dev == NULL) {
VIR_ERROR(_("Failed to create device for '%s'"), def->name); VIR_ERROR(_("Failed to create device for '%s'"), def->name);
@ -1507,15 +1505,15 @@ static int nodeStateCleanup(void)
struct udev_monitor *udev_monitor = NULL; struct udev_monitor *udev_monitor = NULL;
struct udev *udev = NULL; struct udev *udev = NULL;
if (driverState) { if (driver) {
nodeDeviceLock(driverState); nodeDeviceLock();
priv = driverState->privateData; priv = driver->privateData;
if (priv->watch != -1) if (priv->watch != -1)
virEventRemoveHandle(priv->watch); virEventRemoveHandle(priv->watch);
udev_monitor = DRV_STATE_UDEV_MONITOR(driverState); udev_monitor = DRV_STATE_UDEV_MONITOR(driver);
if (udev_monitor != NULL) { if (udev_monitor != NULL) {
udev = udev_monitor_get_udev(udev_monitor); udev = udev_monitor_get_udev(udev_monitor);
@ -1525,10 +1523,10 @@ static int nodeStateCleanup(void)
if (udev != NULL) if (udev != NULL)
udev_unref(udev); udev_unref(udev);
virNodeDeviceObjListFree(&driverState->devs); virNodeDeviceObjListFree(&driver->devs);
nodeDeviceUnlock(driverState); nodeDeviceUnlock();
virMutexDestroy(&driverState->lock); virMutexDestroy(&driver->lock);
VIR_FREE(driverState); VIR_FREE(driver);
VIR_FREE(priv); VIR_FREE(priv);
} else { } else {
ret = -1; ret = -1;
@ -1551,11 +1549,11 @@ static void udevEventHandleCallback(int watch ATTRIBUTE_UNUSED,
void *data ATTRIBUTE_UNUSED) void *data ATTRIBUTE_UNUSED)
{ {
struct udev_device *device = NULL; struct udev_device *device = NULL;
struct udev_monitor *udev_monitor = DRV_STATE_UDEV_MONITOR(driverState); struct udev_monitor *udev_monitor = DRV_STATE_UDEV_MONITOR(driver);
const char *action = NULL; const char *action = NULL;
int udev_fd = -1; int udev_fd = -1;
nodeDeviceLock(driverState); nodeDeviceLock();
udev_fd = udev_monitor_get_fd(udev_monitor); udev_fd = udev_monitor_get_fd(udev_monitor);
if (fd != udev_fd) { if (fd != udev_fd) {
VIR_ERROR(_("File descriptor returned by udev %d does not " VIR_ERROR(_("File descriptor returned by udev %d does not "
@ -1584,7 +1582,7 @@ static void udevEventHandleCallback(int watch ATTRIBUTE_UNUSED,
out: out:
udev_device_unref(device); udev_device_unref(device);
nodeDeviceUnlock(driverState); nodeDeviceUnlock();
return; return;
} }
@ -1598,7 +1596,7 @@ udevGetDMIData(union _virNodeDevCapData *data)
struct udev_device *device = NULL; struct udev_device *device = NULL;
char *tmp = NULL; char *tmp = NULL;
udev = udev_monitor_get_udev(DRV_STATE_UDEV_MONITOR(driverState)); udev = udev_monitor_get_udev(DRV_STATE_UDEV_MONITOR(driver));
device = udev_device_new_from_syspath(udev, DMI_DEVPATH); device = udev_device_new_from_syspath(udev, DMI_DEVPATH);
if (device == NULL) { if (device == NULL) {
@ -1684,7 +1682,7 @@ static int udevSetupSystemDev(void)
udevGetDMIData(&def->caps->data); udevGetDMIData(&def->caps->data);
#endif #endif
dev = virNodeDeviceAssignDef(&driverState->devs, def); dev = virNodeDeviceAssignDef(&driver->devs, def);
if (dev == NULL) { if (dev == NULL) {
VIR_ERROR(_("Failed to create device for '%s'"), def->name); VIR_ERROR(_("Failed to create device for '%s'"), def->name);
goto out; goto out;
@ -1737,21 +1735,21 @@ static int nodeStateInitialize(bool privileged,
priv->watch = -1; priv->watch = -1;
priv->privileged = privileged; priv->privileged = privileged;
if (VIR_ALLOC(driverState) < 0) { if (VIR_ALLOC(driver) < 0) {
VIR_FREE(priv); VIR_FREE(priv);
ret = -1; ret = -1;
goto out; goto out;
} }
if (virMutexInit(&driverState->lock) < 0) { if (virMutexInit(&driver->lock) < 0) {
VIR_ERROR(_("Failed to initialize mutex for driverState")); VIR_ERROR(_("Failed to initialize mutex for driver"));
VIR_FREE(priv); VIR_FREE(priv);
VIR_FREE(driverState); VIR_FREE(driver);
ret = -1; ret = -1;
goto out; goto out;
} }
nodeDeviceLock(driverState); nodeDeviceLock();
/* /*
* http://www.kernel.org/pub/linux/utils/kernel/hotplug/libudev/libudev-udev.html#udev-new * http://www.kernel.org/pub/linux/utils/kernel/hotplug/libudev/libudev-udev.html#udev-new
@ -1776,7 +1774,7 @@ static int nodeStateInitialize(bool privileged,
udev_monitor_enable_receiving(priv->udev_monitor); udev_monitor_enable_receiving(priv->udev_monitor);
/* udev can be retrieved from udev_monitor */ /* udev can be retrieved from udev_monitor */
driverState->privateData = priv; driver->privateData = priv;
/* We register the monitor with the event callback so we are /* We register the monitor with the event callback so we are
* notified by udev of device changes before we enumerate existing * notified by udev of device changes before we enumerate existing
@ -1808,7 +1806,7 @@ static int nodeStateInitialize(bool privileged,
} }
out_unlock: out_unlock:
nodeDeviceUnlock(driverState); nodeDeviceUnlock();
out: out:
if (ret == -1) if (ret == -1)
@ -1823,23 +1821,20 @@ static int nodeStateReload(void)
} }
static virDrvOpenStatus nodeDeviceOpen(virConnectPtr conn, static virDrvOpenStatus nodeDeviceOpen(virConnectPtr conn ATTRIBUTE_UNUSED,
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 (driverState == NULL) if (driver == NULL)
return VIR_DRV_OPEN_DECLINED; return VIR_DRV_OPEN_DECLINED;
conn->nodeDevicePrivateData = driverState;
return VIR_DRV_OPEN_SUCCESS; return VIR_DRV_OPEN_SUCCESS;
} }
static int nodeDeviceClose(virConnectPtr conn) static int nodeDeviceClose(virConnectPtr conn ATTRIBUTE_UNUSED)
{ {
conn->nodeDevicePrivateData = NULL;
return 0; return 0;
} }