VIR_LOG_INIT("conf.virnodedeviceobj");
struct _virNodeDeviceObj {
- virMutex lock;
+ virObjectLockable parent;
virNodeDeviceDefPtr def; /* device definition */
};
};
+static virClassPtr virNodeDeviceObjClass;
+static void virNodeDeviceObjDispose(void *opaque);
+
+static int
+virNodeDeviceObjOnceInit(void)
+{
+ if (!(virNodeDeviceObjClass = virClassNew(virClassForObjectLockable(),
+ "virNodeDeviceObj",
+ sizeof(virNodeDeviceObj),
+ virNodeDeviceObjDispose)))
+ return -1;
+
+ return 0;
+}
+
+VIR_ONCE_GLOBAL_INIT(virNodeDeviceObj)
+
+
+static void
+virNodeDeviceObjDispose(void *opaque)
+{
+ virNodeDeviceObjPtr obj = opaque;
+
+ virNodeDeviceDefFree(obj->def);
+}
+
+
static virNodeDeviceObjPtr
virNodeDeviceObjNew(void)
{
virNodeDeviceObjPtr obj;
- if (VIR_ALLOC(obj) < 0)
+ if (virNodeDeviceObjInitialize() < 0)
return NULL;
- if (virMutexInit(&obj->lock) < 0) {
- virReportError(VIR_ERR_INTERNAL_ERROR,
- "%s", _("cannot initialize mutex"));
- VIR_FREE(obj);
+ if (!(obj = virObjectLockableNew(virNodeDeviceObjClass)))
return NULL;
- }
- virNodeDeviceObjLock(obj);
+
+ virObjectLock(obj);
return obj;
}
+void
+virNodeDeviceObjEndAPI(virNodeDeviceObjPtr *obj)
+{
+ if (!*obj)
+ return;
+
+ virObjectUnlock(*obj);
+ virObjectUnref(*obj);
+ *obj = NULL;
+}
+
+
virNodeDeviceDefPtr
virNodeDeviceObjGetDef(virNodeDeviceObjPtr obj)
{
virNodeDeviceObjPtr obj = devs->objs[i];
virNodeDeviceDefPtr def;
- virNodeDeviceObjLock(obj);
+ virObjectLock(obj);
def = obj->def;
if ((def->sysfs_path != NULL) &&
(STREQ(def->sysfs_path, sysfs_path))) {
- return obj;
+ return virObjectRef(obj);
}
- virNodeDeviceObjUnlock(obj);
+ virObjectUnlock(obj);
}
return NULL;
virNodeDeviceObjPtr obj = devs->objs[i];
virNodeDeviceDefPtr def;
- virNodeDeviceObjLock(obj);
+ virObjectLock(obj);
def = obj->def;
if (STREQ(def->name, name))
- return obj;
- virNodeDeviceObjUnlock(obj);
+ return virObjectRef(obj);
+ virObjectUnlock(obj);
}
return NULL;
virNodeDeviceObjPtr obj = devs->objs[i];
virNodeDevCapsDefPtr cap;
- virNodeDeviceObjLock(obj);
+ virObjectLock(obj);
if ((cap = virNodeDeviceFindFCCapDef(obj)) &&
STREQ_NULLABLE(cap->data.scsi_host.wwnn, parent_wwnn) &&
STREQ_NULLABLE(cap->data.scsi_host.wwpn, parent_wwpn) &&
virNodeDeviceFindVPORTCapDef(obj))
- return obj;
- virNodeDeviceObjUnlock(obj);
+ return virObjectRef(obj);
+ virObjectUnlock(obj);
}
return NULL;
virNodeDeviceObjPtr obj = devs->objs[i];
virNodeDevCapsDefPtr cap;
- virNodeDeviceObjLock(obj);
+ virObjectLock(obj);
if ((cap = virNodeDeviceFindFCCapDef(obj)) &&
STREQ_NULLABLE(cap->data.scsi_host.fabric_wwn, parent_fabric_wwn) &&
virNodeDeviceFindVPORTCapDef(obj))
- return obj;
- virNodeDeviceObjUnlock(obj);
+ return virObjectRef(obj);
+ virObjectUnlock(obj);
}
return NULL;
for (i = 0; i < devs->count; i++) {
virNodeDeviceObjPtr obj = devs->objs[i];
- virNodeDeviceObjLock(obj);
+ virObjectLock(obj);
if (virNodeDeviceObjHasCap(obj, cap))
- return obj;
- virNodeDeviceObjUnlock(obj);
+ return virObjectRef(obj);
+ virObjectUnlock(obj);
}
return NULL;
virNodeDeviceObjPtr obj = devs->objs[i];
virNodeDevCapsDefPtr cap;
- virNodeDeviceObjLock(obj);
+ virObjectLock(obj);
cap = obj->def->caps;
while (cap) {
VIR_NODE_DEV_CAP_FLAG_HBA_FC_HOST) {
if (STREQ(cap->data.scsi_host.wwnn, wwnn) &&
STREQ(cap->data.scsi_host.wwpn, wwpn))
- return obj;
+ return virObjectRef(obj);
}
}
cap = cap->next;
}
- virNodeDeviceObjUnlock(obj);
+ virObjectUnlock(obj);
}
return NULL;
}
-void
-virNodeDeviceObjFree(virNodeDeviceObjPtr obj)
-{
- if (!obj)
- return;
-
- virNodeDeviceDefFree(obj->def);
-
- virMutexDestroy(&obj->lock);
-
- VIR_FREE(obj);
-}
-
-
virNodeDeviceObjListPtr
virNodeDeviceObjListNew(void)
{
{
size_t i;
for (i = 0; i < devs->count; i++)
- virNodeDeviceObjFree(devs->objs[i]);
+ virObjectUnref(devs->objs[i]);
VIR_FREE(devs->objs);
VIR_FREE(devs);
}
return NULL;
if (VIR_APPEND_ELEMENT_COPY(devs->objs, devs->count, obj) < 0) {
- virNodeDeviceObjUnlock(obj);
- virNodeDeviceObjFree(obj);
+ virNodeDeviceObjEndAPI(&obj);
return NULL;
}
obj->def = def;
- return obj;
+ return virObjectRef(obj);
}
{
size_t i;
- virNodeDeviceObjUnlock(obj);
+ virObjectUnlock(obj);
for (i = 0; i < devs->count; i++) {
- virNodeDeviceObjLock(devs->objs[i]);
+ virObjectLock(devs->objs[i]);
if (devs->objs[i] == obj) {
- virNodeDeviceObjUnlock(devs->objs[i]);
+ virObjectUnlock(devs->objs[i]);
+ virObjectUnref(devs->objs[i]);
VIR_DELETE_ELEMENT(devs->objs, i, devs->count);
break;
}
- virNodeDeviceObjUnlock(devs->objs[i]);
+ virObjectUnlock(devs->objs[i]);
}
}
ret = virNodeDeviceFindFCParentHost(obj);
- virNodeDeviceObjUnlock(obj);
+ virNodeDeviceObjEndAPI(&obj);
return ret;
}
ret = virNodeDeviceFindFCParentHost(obj);
- virNodeDeviceObjUnlock(obj);
+ virNodeDeviceObjEndAPI(&obj);
return ret;
}
ret = virNodeDeviceFindFCParentHost(obj);
- virNodeDeviceObjUnlock(obj);
+ virNodeDeviceObjEndAPI(&obj);
return ret;
}
ret = virNodeDeviceFindFCParentHost(obj);
- virNodeDeviceObjUnlock(obj);
+ virNodeDeviceObjEndAPI(&obj);
return ret;
}
}
-void
-virNodeDeviceObjLock(virNodeDeviceObjPtr obj)
-{
- virMutexLock(&obj->lock);
-}
-
-
-void
-virNodeDeviceObjUnlock(virNodeDeviceObjPtr obj)
-{
- virMutexUnlock(&obj->lock);
-}
-
-
static bool
virNodeDeviceCapMatch(virNodeDeviceObjPtr obj,
int type)
for (i = 0; i < devs->count; i++) {
virNodeDeviceObjPtr obj = devs->objs[i];
- virNodeDeviceObjLock(obj);
+ virObjectLock(obj);
if ((!aclfilter || aclfilter(conn, obj->def)) &&
(!cap || virNodeDeviceObjHasCap(obj, cap)))
++ndevs;
- virNodeDeviceObjUnlock(obj);
+ virObjectUnlock(obj);
}
return ndevs;
for (i = 0; i < devs->count && nnames < maxnames; i++) {
virNodeDeviceObjPtr obj = devs->objs[i];
- virNodeDeviceObjLock(obj);
+ virObjectLock(obj);
if ((!aclfilter || aclfilter(conn, obj->def)) &&
(!cap || virNodeDeviceObjHasCap(obj, cap))) {
if (VIR_STRDUP(names[nnames], obj->def->name) < 0) {
- virNodeDeviceObjUnlock(obj);
+ virObjectUnlock(obj);
goto failure;
}
nnames++;
}
- virNodeDeviceObjUnlock(obj);
+ virObjectUnlock(obj);
}
return nnames;
for (i = 0; i < devs->count; i++) {
virNodeDeviceObjPtr obj = devs->objs[i];
- virNodeDeviceObjLock(obj);
+ virObjectLock(obj);
if ((!aclfilter || aclfilter(conn, obj->def)) &&
virNodeDeviceMatch(obj, flags)) {
if (devices) {
if (!(device = virGetNodeDevice(conn, obj->def->name)) ||
VIR_STRDUP(device->parent, obj->def->parent) < 0) {
virObjectUnref(device);
- virNodeDeviceObjUnlock(obj);
+ virObjectUnlock(obj);
goto cleanup;
}
tmp_devices[ndevices] = device;
}
ndevices++;
}
- virNodeDeviceObjUnlock(obj);
+ virObjectUnlock(obj);
}
if (tmp_devices) {
goto error;
}
- virNodeDeviceObjUnlock(obj);
+ virNodeDeviceObjEndAPI(&obj);
}
ret = 0;
* create the vHBA. In the long run the result is the same. */
if (!(obj = testNodeDeviceMockCreateVport(driver, wwnn, wwpn)))
return -1;
- virNodeDeviceObjUnlock(obj);
+ virNodeDeviceObjEndAPI(&obj);
return 0;
}
0);
virNodeDeviceObjListRemove(privconn->devs, obj);
- virNodeDeviceObjFree(obj);
+ virObjectUnref(obj);
testObjectEventQueue(privconn, event);
return 0;
}
}
- virNodeDeviceObjUnlock(obj);
+ virNodeDeviceObjEndAPI(&obj);
return ret;
}
ret = virNodeDeviceDefFormat(virNodeDeviceObjGetDef(obj));
- virNodeDeviceObjUnlock(obj);
+ virNodeDeviceObjEndAPI(&obj);
return ret;
}
"%s", _("no parent for this device"));
}
- virNodeDeviceObjUnlock(obj);
+ virNodeDeviceObjEndAPI(&obj);
return ret;
}
for (caps = def->caps; caps; caps = caps->next)
++ncaps;
- virNodeDeviceObjUnlock(obj);
+ virNodeDeviceObjEndAPI(&obj);
return ncaps;
}
ncaps++;
}
- virNodeDeviceObjUnlock(obj);
+ virNodeDeviceObjEndAPI(&obj);
return ncaps;
error:
while (--ncaps >= 0)
VIR_FREE(names[ncaps]);
- virNodeDeviceObjUnlock(obj);
+ virNodeDeviceObjEndAPI(&obj);
return -1;
}
goto cleanup;
xml = virNodeDeviceDefFormat(virNodeDeviceObjGetDef(objcopy));
- virNodeDeviceObjUnlock(objcopy);
+ virNodeDeviceObjEndAPI(&objcopy);
if (!xml)
goto cleanup;
dev = NULL;
cleanup:
- if (obj)
- virNodeDeviceObjUnlock(obj);
+ virNodeDeviceObjEndAPI(&obj);
testDriverUnlock(driver);
virNodeDeviceDefFree(def);
virObjectUnref(dev);
* taken, so we have to dup the parent's name and drop the lock
* before calling it. We don't need the reference to the object
* any more once we have the parent's name. */
- virNodeDeviceObjUnlock(obj);
+ virObjectUnlock(obj);
/* We do this just for basic validation, but also avoid finding a
* vport capable HBA if for some reason our vHBA doesn't exist */
if (virNodeDeviceObjListGetParentHost(driver->devs, def,
EXISTING_DEVICE) < 0) {
- obj = NULL;
+ virObjectLock(obj);
goto cleanup;
}
VIR_NODE_DEVICE_EVENT_DELETED,
0);
- virNodeDeviceObjLock(obj);
+ virObjectLock(obj);
virNodeDeviceObjListRemove(driver->devs, obj);
- virNodeDeviceObjFree(obj);
+ virObjectUnref(obj);
obj = NULL;
cleanup:
- if (obj)
- virNodeDeviceObjUnlock(obj);
+ virNodeDeviceObjEndAPI(&obj);
testObjectEventQueue(driver, event);
VIR_FREE(parent_name);
VIR_FREE(wwnn);
projects / thirdparty / libvirt.git / commitdiff
