void virNodeDeviceObjRemove(virNodeDeviceObjListPtr devs, const virNodeDeviceObjPtr dev) { unsigned int i; virNodeDeviceObjUnlock(dev); for (i = 0; i < devs->count; i++) { virNodeDeviceObjLock(dev); if (devs->objs[i] == dev) { virNodeDeviceObjUnlock(dev); virNodeDeviceObjFree(devs->objs[i]); if (i < (devs->count - 1)) memmove(devs->objs + i, devs->objs + i + 1, sizeof(*(devs->objs)) * (devs->count - (i + 1))); if (VIR_REALLOC_N(devs->objs, devs->count - 1) < 0) { ; /* Failure to reduce memory allocation isn't fatal */ } devs->count--; break; } virNodeDeviceObjUnlock(dev); } }
static int nodeListDevices(virConnectPtr conn, const char *cap, char **const names, int maxnames, unsigned int flags ATTRIBUTE_UNUSED) { virDeviceMonitorStatePtr driver = conn->devMonPrivateData; int ndevs = 0; unsigned int i; nodeDeviceLock(driver); for (i = 0; i < driver->devs.count && ndevs < maxnames; i++) { virNodeDeviceObjLock(driver->devs.objs[i]); if (cap == NULL || virNodeDeviceHasCap(driver->devs.objs[i], cap)) { if ((names[ndevs++] = strdup(driver->devs.objs[i]->def->name)) == NULL) { virNodeDeviceObjUnlock(driver->devs.objs[i]); virReportOOMError(); goto failure; } } virNodeDeviceObjUnlock(driver->devs.objs[i]); } nodeDeviceUnlock(driver); return ndevs; failure: nodeDeviceUnlock(driver); --ndevs; while (--ndevs >= 0) VIR_FREE(names[ndevs]); return -1; }
int nodeDeviceDestroy(virNodeDevicePtr dev) { int ret = -1; virDeviceMonitorStatePtr driver = dev->conn->devMonPrivateData; virNodeDeviceObjPtr obj = NULL; char *parent_name = NULL, *wwnn = NULL, *wwpn = NULL; int parent_host = -1; nodeDeviceLock(driver); obj = virNodeDeviceFindByName(&driver->devs, dev->name); nodeDeviceUnlock(driver); if (!obj) { virReportError(VIR_ERR_NO_NODE_DEVICE, NULL); goto out; } if (virNodeDeviceGetWWNs(obj->def, &wwnn, &wwpn) == -1) { goto out; } parent_name = strdup(obj->def->parent); /* virNodeDeviceGetParentHost will cause the device object's lock to be * 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); obj = NULL; if (parent_name == NULL) { virReportOOMError(); goto out; } if (virNodeDeviceGetParentHost(&driver->devs, dev->name, parent_name, &parent_host) == -1) { goto out; } if (nodeDeviceVportCreateDelete(parent_host, wwpn, wwnn, VPORT_DELETE) == -1) { goto out; } ret = 0; out: if (obj) virNodeDeviceObjUnlock(obj); VIR_FREE(parent_name); VIR_FREE(wwnn); VIR_FREE(wwpn); return ret; }
virNodeDevicePtr nodeDeviceLookupSCSIHostByWWN(virConnectPtr conn, const char *wwnn, const char *wwpn, unsigned int flags) { size_t i; virNodeDeviceObjListPtr devs = &driver->devs; virNodeDevCapsDefPtr cap = NULL; virNodeDeviceObjPtr obj = NULL; virNodeDeviceDefPtr def; virNodeDevicePtr dev = NULL; virCheckFlags(0, NULL); nodeDeviceLock(); for (i = 0; i < devs->count; i++) { obj = devs->objs[i]; virNodeDeviceObjLock(obj); def = virNodeDeviceObjGetDef(obj); cap = def->caps; while (cap) { if (cap->data.type == VIR_NODE_DEV_CAP_SCSI_HOST) { nodeDeviceSysfsGetSCSIHostCaps(&cap->data.scsi_host); if (cap->data.scsi_host.flags & VIR_NODE_DEV_CAP_FLAG_HBA_FC_HOST) { if (STREQ(cap->data.scsi_host.wwnn, wwnn) && STREQ(cap->data.scsi_host.wwpn, wwpn)) { if (virNodeDeviceLookupSCSIHostByWWNEnsureACL(conn, def) < 0) goto error; if ((dev = virGetNodeDevice(conn, def->name))) { if (VIR_STRDUP(dev->parent, def->parent) < 0) { virObjectUnref(dev); dev = NULL; } } virNodeDeviceObjUnlock(obj); goto out; } } } cap = cap->next; } virNodeDeviceObjUnlock(obj); } out: nodeDeviceUnlock(); return dev; error: virNodeDeviceObjUnlock(obj); goto out; }
virNodeDevicePtr nodeDeviceLookupSCSIHostByWWN(virConnectPtr conn, const char *wwnn, const char *wwpn, unsigned int flags) { size_t i; virNodeDeviceDriverStatePtr driver = conn->nodeDevicePrivateData; virNodeDeviceObjListPtr devs = &driver->devs; virNodeDevCapsDefPtr cap = NULL; virNodeDeviceObjPtr obj = NULL; virNodeDevicePtr dev = NULL; virCheckFlags(0, NULL); nodeDeviceLock(driver); for (i = 0; i < devs->count; i++) { obj = devs->objs[i]; virNodeDeviceObjLock(obj); cap = obj->def->caps; while (cap) { if (cap->type == VIR_NODE_DEV_CAP_SCSI_HOST) { detect_scsi_host_caps(&cap->data); if (cap->data.scsi_host.flags & VIR_NODE_DEV_CAP_FLAG_HBA_FC_HOST) { if (STREQ(cap->data.scsi_host.wwnn, wwnn) && STREQ(cap->data.scsi_host.wwpn, wwpn)) { if (virNodeDeviceLookupSCSIHostByWWNEnsureACL(conn, obj->def) < 0) goto out; dev = virGetNodeDevice(conn, obj->def->name); virNodeDeviceObjUnlock(obj); goto out; } } } cap = cap->next; } virNodeDeviceObjUnlock(obj); } out: nodeDeviceUnlock(driver); return dev; }
virNodeDevicePtr nodeDeviceLookupByName(virConnectPtr conn, const char *name) { virNodeDeviceDriverStatePtr driver = conn->nodeDevicePrivateData; virNodeDeviceObjPtr obj; virNodeDevicePtr ret = NULL; nodeDeviceLock(driver); obj = virNodeDeviceFindByName(&driver->devs, name); nodeDeviceUnlock(driver); if (!obj) { virReportError(VIR_ERR_NO_NODE_DEVICE, NULL); goto cleanup; } if (virNodeDeviceLookupByNameEnsureACL(conn, obj->def) < 0) goto cleanup; ret = virGetNodeDevice(conn, name); cleanup: if (obj) virNodeDeviceObjUnlock(obj); return ret; }
static char *nodeDeviceDumpXML(virNodeDevicePtr dev, unsigned int flags ATTRIBUTE_UNUSED) { virDeviceMonitorStatePtr driver = dev->conn->devMonPrivateData; virNodeDeviceObjPtr obj; char *ret = NULL; nodeDeviceLock(driver); obj = virNodeDeviceFindByName(&driver->devs, dev->name); nodeDeviceUnlock(driver); if (!obj) { virNodeDeviceReportError(VIR_ERR_NO_NODE_DEVICE, _("no node device with matching name '%s'"), dev->name); goto cleanup; } update_driver_name(obj); update_caps(obj); ret = virNodeDeviceDefFormat(obj->def); cleanup: if (obj) virNodeDeviceObjUnlock(obj); return ret; }
virNodeDevicePtr nodeDeviceLookupByName(virConnectPtr conn, const char *name) { virNodeDeviceObjPtr obj; virNodeDevicePtr ret = NULL; nodeDeviceLock(); obj = virNodeDeviceFindByName(&driver->devs, name); nodeDeviceUnlock(); if (!obj) { virReportError(VIR_ERR_NO_NODE_DEVICE, _("no node device with matching name '%s'"), name); goto cleanup; } if (virNodeDeviceLookupByNameEnsureACL(conn, obj->def) < 0) goto cleanup; ret = virGetNodeDevice(conn, name); cleanup: if (obj) virNodeDeviceObjUnlock(obj); return ret; }
int nodeNumOfDevices(virConnectPtr conn, const char *cap, unsigned int flags) { int ndevs = 0; size_t i; if (virNodeNumOfDevicesEnsureACL(conn) < 0) return -1; virCheckFlags(0, -1); nodeDeviceLock(); for (i = 0; i < driver->devs.count; i++) { virNodeDeviceObjPtr obj = driver->devs.objs[i]; virNodeDeviceObjLock(obj); if (virNodeNumOfDevicesCheckACL(conn, obj->def) && ((cap == NULL) || virNodeDeviceHasCap(obj, cap))) ++ndevs; virNodeDeviceObjUnlock(obj); } nodeDeviceUnlock(); return ndevs; }
char * nodeDeviceGetParent(virNodeDevicePtr dev) { virNodeDeviceObjPtr obj; virNodeDeviceDefPtr def; char *ret = NULL; if (!(obj = nodeDeviceObjFindByName(dev->name))) return NULL; def = virNodeDeviceObjGetDef(obj); if (virNodeDeviceGetParentEnsureACL(dev->conn, def) < 0) goto cleanup; if (def->parent) { if (VIR_STRDUP(ret, def->parent) < 0) goto cleanup; } else { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("no parent for this device")); } cleanup: virNodeDeviceObjUnlock(obj); return ret; }
char * nodeDeviceGetXMLDesc(virNodeDevicePtr dev, unsigned int flags) { virNodeDeviceObjPtr obj; char *ret = NULL; virCheckFlags(0, NULL); nodeDeviceLock(); obj = virNodeDeviceFindByName(&driver->devs, dev->name); nodeDeviceUnlock(); if (!obj) { virReportError(VIR_ERR_NO_NODE_DEVICE, _("no node device with matching name '%s'"), dev->name); goto cleanup; } if (virNodeDeviceGetXMLDescEnsureACL(dev->conn, obj->def) < 0) goto cleanup; update_driver_name(obj); if (update_caps(obj) < 0) goto cleanup; ret = virNodeDeviceDefFormat(obj->def); cleanup: if (obj) virNodeDeviceObjUnlock(obj); return ret; }
char * nodeDeviceGetXMLDesc(virNodeDevicePtr dev, unsigned int flags) { virNodeDeviceObjPtr obj; virNodeDeviceDefPtr def; char *ret = NULL; virCheckFlags(0, NULL); if (!(obj = nodeDeviceObjFindByName(dev->name))) return NULL; def = virNodeDeviceObjGetDef(obj); if (virNodeDeviceGetXMLDescEnsureACL(dev->conn, def) < 0) goto cleanup; if (nodeDeviceUpdateDriverName(def) < 0) goto cleanup; if (nodeDeviceUpdateCaps(def) < 0) goto cleanup; ret = virNodeDeviceDefFormat(def); cleanup: virNodeDeviceObjUnlock(obj); return ret; }
int nodeDeviceNumOfCaps(virNodeDevicePtr dev) { virNodeDeviceDriverStatePtr driver = dev->conn->nodeDevicePrivateData; virNodeDeviceObjPtr obj; virNodeDevCapsDefPtr caps; int ncaps = 0; int ret = -1; nodeDeviceLock(driver); obj = virNodeDeviceFindByName(&driver->devs, dev->name); nodeDeviceUnlock(driver); if (!obj) { virReportError(VIR_ERR_NO_NODE_DEVICE, _("no node device with matching name '%s'"), dev->name); goto cleanup; } if (virNodeDeviceNumOfCapsEnsureACL(dev->conn, obj->def) < 0) goto cleanup; for (caps = obj->def->caps; caps; caps = caps->next) ++ncaps; ret = ncaps; cleanup: if (obj) virNodeDeviceObjUnlock(obj); return ret; }
virNodeDevicePtr nodeDeviceLookupByName(virConnectPtr conn, const char *name) { virNodeDeviceObjPtr obj; virNodeDeviceDefPtr def; virNodeDevicePtr ret = NULL; if (!(obj = nodeDeviceObjFindByName(name))) return NULL; def = virNodeDeviceObjGetDef(obj); if (virNodeDeviceLookupByNameEnsureACL(conn, def) < 0) goto cleanup; if ((ret = virGetNodeDevice(conn, name))) { if (VIR_STRDUP(ret->parent, def->parent) < 0) { virObjectUnref(ret); ret = NULL; } } cleanup: virNodeDeviceObjUnlock(obj); return ret; }
char * nodeDeviceGetParent(virNodeDevicePtr dev) { virNodeDeviceObjPtr obj; char *ret = NULL; nodeDeviceLock(); obj = virNodeDeviceFindByName(&driver->devs, dev->name); nodeDeviceUnlock(); if (!obj) { virReportError(VIR_ERR_NO_NODE_DEVICE, _("no node device with matching name '%s'"), dev->name); goto cleanup; } if (virNodeDeviceGetParentEnsureACL(dev->conn, obj->def) < 0) goto cleanup; if (obj->def->parent) { if (VIR_STRDUP(ret, obj->def->parent) < 0) goto cleanup; } else { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("no parent for this device")); } cleanup: if (obj) virNodeDeviceObjUnlock(obj); return ret; }
char * nodeDeviceGetParent(virNodeDevicePtr dev) { virDeviceMonitorStatePtr driver = dev->conn->devMonPrivateData; virNodeDeviceObjPtr obj; char *ret = NULL; nodeDeviceLock(driver); obj = virNodeDeviceFindByName(&driver->devs, dev->name); nodeDeviceUnlock(driver); if (!obj) { virReportError(VIR_ERR_NO_NODE_DEVICE, _("no node device with matching name '%s'"), dev->name); goto cleanup; } if (obj->def->parent) { ret = strdup(obj->def->parent); if (!ret) virReportOOMError(); } else { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("no parent for this device")); } cleanup: if (obj) virNodeDeviceObjUnlock(obj); return ret; }
static virNodeDevicePtr nodeDeviceLookupByWWN(virConnectPtr conn, const char *wwnn, const char *wwpn) { unsigned int i; virDeviceMonitorStatePtr driver = conn->devMonPrivateData; virNodeDeviceObjListPtr devs = &driver->devs; virNodeDevCapsDefPtr cap = NULL; virNodeDeviceObjPtr obj = NULL; virNodeDevicePtr dev = NULL; nodeDeviceLock(driver); for (i = 0; i < devs->count; i++) { obj = devs->objs[i]; virNodeDeviceObjLock(obj); cap = obj->def->caps; while (cap) { if (cap->type == VIR_NODE_DEV_CAP_SCSI_HOST) { check_fc_host(&cap->data); if (cap->data.scsi_host.flags & VIR_NODE_DEV_CAP_FLAG_HBA_FC_HOST) { if (STREQ(cap->data.scsi_host.wwnn, wwnn) && STREQ(cap->data.scsi_host.wwpn, wwpn)) { dev = virGetNodeDevice(conn, obj->def->name); virNodeDeviceObjUnlock(obj); goto out; } } } cap = cap->next; } virNodeDeviceObjUnlock(obj); } out: nodeDeviceUnlock(driver); return dev; }
int nodeDeviceListCaps(virNodeDevicePtr dev, char **const names, int maxnames) { virNodeDeviceObjPtr obj; virNodeDevCapsDefPtr caps; int ncaps = 0; int ret = -1; nodeDeviceLock(); obj = virNodeDeviceFindByName(&driver->devs, dev->name); nodeDeviceUnlock(); if (!obj) { virReportError(VIR_ERR_NO_NODE_DEVICE, _("no node device with matching name '%s'"), dev->name); goto cleanup; } if (virNodeDeviceListCapsEnsureACL(dev->conn, obj->def) < 0) goto cleanup; for (caps = obj->def->caps; caps && ncaps < maxnames; caps = caps->next) { if (VIR_STRDUP(names[ncaps++], virNodeDevCapTypeToString(caps->data.type)) < 0) goto cleanup; if (caps->data.type == VIR_NODE_DEV_CAP_SCSI_HOST) { if (ncaps < maxnames && caps->data.scsi_host.flags & VIR_NODE_DEV_CAP_FLAG_HBA_FC_HOST) { if (VIR_STRDUP(names[ncaps++], virNodeDevCapTypeToString(VIR_NODE_DEV_CAP_FC_HOST)) < 0) goto cleanup; } if (ncaps < maxnames && caps->data.scsi_host.flags & VIR_NODE_DEV_CAP_FLAG_HBA_VPORT_OPS) { if (VIR_STRDUP(names[ncaps++], virNodeDevCapTypeToString(VIR_NODE_DEV_CAP_VPORTS)) < 0) goto cleanup; } } } ret = ncaps; cleanup: if (obj) virNodeDeviceObjUnlock(obj); if (ret == -1) { --ncaps; while (--ncaps >= 0) VIR_FREE(names[ncaps]); } return ret; }
int nodeDeviceDestroy(virNodeDevicePtr dev) { int ret = -1; virNodeDeviceObjPtr obj = NULL; virNodeDeviceDefPtr def; char *wwnn = NULL, *wwpn = NULL; int parent_host = -1; if (!(obj = nodeDeviceObjFindByName(dev->name))) return -1; def = virNodeDeviceObjGetDef(obj); nodeDeviceLock(); if (virNodeDeviceDestroyEnsureACL(dev->conn, def) < 0) goto cleanup; if (virNodeDeviceGetWWNs(def, &wwnn, &wwpn) < 0) goto cleanup; /* virNodeDeviceGetParentHost will cause the device object's lock * to be taken, so grab the object def which will have the various * fields used to search (name, parent, parent_wwnn, parent_wwpn, * or parent_fabric_wwn) and drop the object lock. */ virNodeDeviceObjUnlock(obj); obj = NULL; if ((parent_host = virNodeDeviceObjGetParentHost(&driver->devs, def, EXISTING_DEVICE)) < 0) goto cleanup; if (virVHBAManageVport(parent_host, wwpn, wwnn, VPORT_DELETE) < 0) goto cleanup; ret = 0; cleanup: nodeDeviceUnlock(); virNodeDeviceObjUnlock(obj); VIR_FREE(wwnn); VIR_FREE(wwpn); return ret; }
int nodeListDevices(virConnectPtr conn, const char *cap, char **const names, int maxnames, unsigned int flags) { virNodeDeviceDriverStatePtr driver = conn->nodeDevicePrivateData; int ndevs = 0; size_t i; if (virNodeListDevicesEnsureACL(conn) < 0) return -1; virCheckFlags(0, -1); nodeDeviceLock(driver); for (i = 0; i < driver->devs.count && ndevs < maxnames; i++) { virNodeDeviceObjPtr obj = driver->devs.objs[i]; virNodeDeviceObjLock(obj); if (virNodeListDevicesCheckACL(conn, obj->def) && (cap == NULL || virNodeDeviceHasCap(obj, cap))) { if (VIR_STRDUP(names[ndevs++], obj->def->name) < 0) { virNodeDeviceObjUnlock(obj); goto failure; } } virNodeDeviceObjUnlock(obj); } nodeDeviceUnlock(driver); return ndevs; failure: nodeDeviceUnlock(driver); --ndevs; while (--ndevs >= 0) VIR_FREE(names[ndevs]); return -1; }
int nodeDeviceListCaps(virNodeDevicePtr dev, char **const names, int maxnames) { virNodeDeviceObjPtr obj; virNodeDeviceDefPtr def; virNodeDevCapsDefPtr caps; int ncaps = 0; int ret = -1; if (!(obj = nodeDeviceObjFindByName(dev->name))) return -1; def = virNodeDeviceObjGetDef(obj); if (virNodeDeviceListCapsEnsureACL(dev->conn, def) < 0) goto cleanup; for (caps = def->caps; caps && ncaps < maxnames; caps = caps->next) { if (VIR_STRDUP(names[ncaps++], virNodeDevCapTypeToString(caps->data.type)) < 0) goto cleanup; if (caps->data.type == VIR_NODE_DEV_CAP_SCSI_HOST) { if (ncaps < maxnames && caps->data.scsi_host.flags & VIR_NODE_DEV_CAP_FLAG_HBA_FC_HOST) { if (VIR_STRDUP(names[ncaps++], virNodeDevCapTypeToString(VIR_NODE_DEV_CAP_FC_HOST)) < 0) goto cleanup; } if (ncaps < maxnames && caps->data.scsi_host.flags & VIR_NODE_DEV_CAP_FLAG_HBA_VPORT_OPS) { if (VIR_STRDUP(names[ncaps++], virNodeDevCapTypeToString(VIR_NODE_DEV_CAP_VPORTS)) < 0) goto cleanup; } } } ret = ncaps; cleanup: virNodeDeviceObjUnlock(obj); if (ret == -1) { --ncaps; while (--ncaps >= 0) VIR_FREE(names[ncaps]); } return ret; }
virNodeDeviceObjPtr virNodeDeviceFindByName(const virNodeDeviceObjListPtr devs, const char *name) { unsigned int i; for (i = 0; i < devs->count; i++) { virNodeDeviceObjLock(devs->objs[i]); if (STREQ(devs->objs[i]->def->name, name)) return devs->objs[i]; virNodeDeviceObjUnlock(devs->objs[i]); } return NULL; }
virNodeDeviceObjPtr virNodeDeviceFindBySysfsPath(const virNodeDeviceObjListPtr devs, const char *sysfs_path) { unsigned int i; for (i = 0; i < devs->count; i++) { virNodeDeviceObjLock(devs->objs[i]); if ((devs->objs[i]->def->sysfs_path != NULL) && (STREQ(devs->objs[i]->def->sysfs_path, sysfs_path))) { return devs->objs[i]; } virNodeDeviceObjUnlock(devs->objs[i]); } return NULL; }
/* * Return the NPIV dev's parent device name */ int virNodeDeviceGetParentHost(const virNodeDeviceObjListPtr devs, const char *dev_name, const char *parent_name, int *parent_host) { virNodeDeviceObjPtr parent = NULL; virNodeDevCapsDefPtr cap = NULL; int ret = 0; parent = virNodeDeviceFindByName(devs, parent_name); if (parent == NULL) { virNodeDeviceReportError(VIR_ERR_INTERNAL_ERROR, _("Could not find parent device for '%s'"), dev_name); ret = -1; goto out; } cap = parent->def->caps; while (cap != NULL) { if (cap->type == VIR_NODE_DEV_CAP_SCSI_HOST && (cap->data.scsi_host.flags & VIR_NODE_DEV_CAP_FLAG_HBA_VPORT_OPS)) { *parent_host = cap->data.scsi_host.host; break; } cap = cap->next; } if (cap == NULL) { virNodeDeviceReportError(VIR_ERR_INTERNAL_ERROR, _("Parent device %s is not capable " "of vport operations"), parent->def->name); ret = -1; } virNodeDeviceObjUnlock(parent); out: return ret; }
int nodeDeviceNumOfCaps(virNodeDevicePtr dev) { virNodeDeviceObjPtr obj; virNodeDevCapsDefPtr caps; int ncaps = 0; int ret = -1; nodeDeviceLock(); obj = virNodeDeviceFindByName(&driver->devs, dev->name); nodeDeviceUnlock(); if (!obj) { virReportError(VIR_ERR_NO_NODE_DEVICE, _("no node device with matching name '%s'"), dev->name); goto cleanup; } if (virNodeDeviceNumOfCapsEnsureACL(dev->conn, obj->def) < 0) goto cleanup; for (caps = obj->def->caps; caps; caps = caps->next) { ++ncaps; if (caps->data.type == VIR_NODE_DEV_CAP_SCSI_HOST) { if (caps->data.scsi_host.flags & VIR_NODE_DEV_CAP_FLAG_HBA_FC_HOST) ncaps++; if (caps->data.scsi_host.flags & VIR_NODE_DEV_CAP_FLAG_HBA_VPORT_OPS) ncaps++; } } ret = ncaps; cleanup: if (obj) virNodeDeviceObjUnlock(obj); return ret; }
static int nodeNumOfDevices(virConnectPtr conn, const char *cap, unsigned int flags ATTRIBUTE_UNUSED) { virDeviceMonitorStatePtr driver = conn->devMonPrivateData; int ndevs = 0; unsigned int i; nodeDeviceLock(driver); for (i = 0; i < driver->devs.count; i++) { virNodeDeviceObjLock(driver->devs.objs[i]); if ((cap == NULL) || virNodeDeviceHasCap(driver->devs.objs[i], cap)) ++ndevs; virNodeDeviceObjUnlock(driver->devs.objs[i]); } nodeDeviceUnlock(driver); return ndevs; }
static int nodeDeviceListCaps(virNodeDevicePtr dev, char **const names, int maxnames) { virDeviceMonitorStatePtr driver = dev->conn->devMonPrivateData; virNodeDeviceObjPtr obj; virNodeDevCapsDefPtr caps; int ncaps = 0; int ret = -1; nodeDeviceLock(driver); obj = virNodeDeviceFindByName(&driver->devs, dev->name); nodeDeviceUnlock(driver); if (!obj) { virNodeDeviceReportError(VIR_ERR_NO_NODE_DEVICE, _("no node device with matching name '%s'"), dev->name); goto cleanup; } for (caps = obj->def->caps; caps && ncaps < maxnames; caps = caps->next) { names[ncaps] = strdup(virNodeDevCapTypeToString(caps->type)); if (names[ncaps++] == NULL) { virReportOOMError(); goto cleanup; } } ret = ncaps; cleanup: if (obj) virNodeDeviceObjUnlock(obj); if (ret == -1) { --ncaps; while (--ncaps >= 0) VIR_FREE(names[ncaps]); } return ret; }
int nodeDeviceListCaps(virNodeDevicePtr dev, char **const names, int maxnames) { virNodeDeviceDriverStatePtr driver = dev->conn->nodeDevicePrivateData; virNodeDeviceObjPtr obj; virNodeDevCapsDefPtr caps; int ncaps = 0; int ret = -1; nodeDeviceLock(driver); obj = virNodeDeviceFindByName(&driver->devs, dev->name); nodeDeviceUnlock(driver); if (!obj) { virReportError(VIR_ERR_NO_NODE_DEVICE, _("no node device with matching name '%s'"), dev->name); goto cleanup; } if (virNodeDeviceListCapsEnsureACL(dev->conn, obj->def) < 0) goto cleanup; for (caps = obj->def->caps; caps && ncaps < maxnames; caps = caps->next) { if (VIR_STRDUP(names[ncaps++], virNodeDevCapTypeToString(caps->type)) < 0) goto cleanup; } ret = ncaps; cleanup: if (obj) virNodeDeviceObjUnlock(obj); if (ret == -1) { --ncaps; while (--ncaps >= 0) VIR_FREE(names[ncaps]); } return ret; }
virNodeDeviceObjPtr virNodeDeviceAssignDef(virNodeDeviceObjListPtr devs, const virNodeDeviceDefPtr def) { virNodeDeviceObjPtr device; if ((device = virNodeDeviceFindByName(devs, def->name))) { virNodeDeviceDefFree(device->def); device->def = def; return device; } if (VIR_ALLOC(device) < 0) { virReportOOMError(); return NULL; } if (virMutexInit(&device->lock) < 0) { virNodeDeviceReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("cannot initialize mutex")); VIR_FREE(device); return NULL; } virNodeDeviceObjLock(device); device->def = def; if (VIR_REALLOC_N(devs->objs, devs->count+1) < 0) { device->def = NULL; virNodeDeviceObjUnlock(device); virNodeDeviceObjFree(device); virReportOOMError(); return NULL; } devs->objs[devs->count++] = device; return device; }
int nodeDeviceNumOfCaps(virNodeDevicePtr dev) { virNodeDeviceObjPtr obj; virNodeDeviceDefPtr def; virNodeDevCapsDefPtr caps; int ncaps = 0; int ret = -1; if (!(obj = nodeDeviceObjFindByName(dev->name))) return -1; def = virNodeDeviceObjGetDef(obj); if (virNodeDeviceNumOfCapsEnsureACL(dev->conn, def) < 0) goto cleanup; for (caps = def->caps; caps; caps = caps->next) { ++ncaps; if (caps->data.type == VIR_NODE_DEV_CAP_SCSI_HOST) { if (caps->data.scsi_host.flags & VIR_NODE_DEV_CAP_FLAG_HBA_FC_HOST) ncaps++; if (caps->data.scsi_host.flags & VIR_NODE_DEV_CAP_FLAG_HBA_VPORT_OPS) ncaps++; } } ret = ncaps; cleanup: virNodeDeviceObjUnlock(obj); return ret; }