void pci_hostHlpThread::run()
{
if ( NULL==ptr_ConnPtr || NULL==*ptr_ConnPtr ) {
emit ptrIsNull();
return;
};
if ( virConnectRef(*ptr_ConnPtr)<0 ) {
sendConnErrors();
return;
};
QStringList devices;
virNodeDevice **nodeDevices = NULL;
unsigned int flags =
VIR_CONNECT_LIST_NODE_DEVICES_CAP_PCI_DEV;
int ret = virConnectListAllNodeDevices(*ptr_ConnPtr, &nodeDevices, flags);
if ( ret<0 ) {
sendConnErrors();
} else {
// therefore correctly to use for() command, because networks[0] can not exist.
for (int i = 0; i < ret; i++) {
devices.append( QString("%1\n")
// flags: extra flags; not used yet,
// so callers should always pass 0
.arg(virNodeDeviceGetXMLDesc(nodeDevices[i], 0)));
virNodeDeviceFree(nodeDevices[i]);
};
if (nodeDevices) free(nodeDevices);
};
//int devs = virNodeNumOfDevices(ptr_ConnPtr, NULL, 0);
if ( virConnectClose(*ptr_ConnPtr)<0 )
sendConnErrors();
emit result(devices);
}
static bool
cmdNodeDeviceCreate(vshControl *ctl, const vshCmd *cmd)
{
virNodeDevicePtr dev = NULL;
const char *from = NULL;
bool ret = true;
char *buffer;
if (vshCommandOptStringReq(ctl, cmd, "file", &from) < 0)
return false;
if (virFileReadAll(from, VSH_MAX_XML_FILE, &buffer) < 0)
return false;
dev = virNodeDeviceCreateXML(ctl->conn, buffer, 0);
VIR_FREE(buffer);
if (dev != NULL) {
vshPrint(ctl, _("Node device %s created from %s\n"),
virNodeDeviceGetName(dev), from);
virNodeDeviceFree(dev);
} else {
vshError(ctl, _("Failed to create node device from %s"), from);
ret = false;
}
return ret;
}
/* private slots */
void USB_Host_Device::setAvailabledUSBDevices()
{
int i = 0;
QStringList devices;
virNodeDevice **nodeDevices = NULL;
if ( currWorkConnect!=NULL ) {
unsigned int flags =
VIR_CONNECT_LIST_NODE_DEVICES_CAP_USB_DEV;
int ret = virConnectListAllNodeDevices(currWorkConnect, &nodeDevices, flags);
if ( ret<0 ) {
sendConnErrors();
} else {
while ( nodeDevices[i] != NULL ) {
devices.append( QString("%1\n")
// flags: extra flags; not used yet,
// so callers should always pass 0
.arg(virNodeDeviceGetXMLDesc(nodeDevices[i], 0)));
virNodeDeviceFree(nodeDevices[i]);
i++;
};
};
free(nodeDevices);
};
//int devs = virNodeNumOfDevices(currWorkConnect, NULL, 0);
//qDebug()<<"Devices("<<devs<<i<<"):\n"<<devices.join("\n");
// set unique device description to devList
foreach (QString _dev, devices) {
//qDebug()<<_dev;
QString devName, devIdentity;
QDomElement capability, product, vendor;
QDomDocument doc = QDomDocument();
doc.setContent(_dev);
// filter out **** Host Controllers
if ( !doc.
firstChildElement("device").
firstChildElement("parent").
firstChild().toText().data().
startsWith("usb") ) continue;
//
capability = doc.firstChildElement("device").
firstChildElement("capability");
product = capability.firstChildElement("product");
vendor = capability.firstChildElement("vendor");
// devIdentity format: <vendor:product>
devIdentity.append(vendor.attribute("id"));
devIdentity.append(":");
devIdentity.append(product.attribute("id"));
// devName format: <vendor_product>
devName.append(vendor.firstChild().toText().data());
devName.append("\n");
devName.append(product.firstChild().toText().data());
if ( devList->findItems(devName,
Qt::MatchExactly |
Qt::MatchCaseSensitive)
.isEmpty() ) {
devList->insertItem(0, devName);
devList->item(0)->setData(Qt::UserRole, devIdentity);
};
};
static void gvir_node_device_finalize(GObject *object)
{
GVirNodeDevice *device = GVIR_NODE_DEVICE(object);
GVirNodeDevicePrivate *priv = device->priv;
virNodeDeviceFree(priv->handle);
G_OBJECT_CLASS(gvir_node_device_parent_class)->finalize(object);
}
static void
vshNodeDeviceListFree(vshNodeDeviceListPtr list)
{
int i;
if (list && list->ndevices) {
for (i = 0; i < list->ndevices; i++) {
if (list->devices[i])
virNodeDeviceFree(list->devices[i]);
}
VIR_FREE(list->devices);
}
VIR_FREE(list);
}
static bool
cmdNodeDeviceDestroy(vshControl *ctl, const vshCmd *cmd)
{
virNodeDevicePtr dev = NULL;
bool ret = false;
const char *device_value = NULL;
char **arr = NULL;
int narr;
if (vshCommandOptStringReq(ctl, cmd, "device", &device_value) < 0)
return false;
if (strchr(device_value, ',')) {
narr = vshStringToArray(device_value, &arr);
if (narr != 2) {
vshError(ctl, _("Malformed device value '%s'"), device_value);
goto cleanup;
}
if (!virValidateWWN(arr[0]) || !virValidateWWN(arr[1]))
goto cleanup;
dev = virNodeDeviceLookupSCSIHostByWWN(ctl->conn, arr[0], arr[1], 0);
} else {
dev = virNodeDeviceLookupByName(ctl->conn, device_value);
}
if (!dev) {
vshError(ctl, "%s '%s'", _("Could not find matching device"), device_value);
goto cleanup;
}
if (virNodeDeviceDestroy(dev) == 0) {
vshPrint(ctl, _("Destroyed node device '%s'\n"), device_value);
} else {
vshError(ctl, _("Failed to destroy node device '%s'"), device_value);
goto cleanup;
}
ret = true;
cleanup:
if (arr) {
VIR_FREE(*arr);
VIR_FREE(arr);
}
virNodeDeviceFree(dev);
return ret;
}
void
vert_cleanup(ErlNifEnv *env, void *obj)
{
VERT_RESOURCE *vp = obj;
if (vp->res == NULL)
return;
switch (vp->type) {
case VERT_RES_CONNECT:
(void)virConnectClose(vp->res);
break;
case VERT_RES_DOMAIN:
(void)virDomainFree(vp->res);
break;
case VERT_RES_INTERFACE:
(void)virInterfaceFree(vp->res);
break;
case VERT_RES_NETWORK:
(void)virNetworkFree(vp->res);
break;
case VERT_RES_NODEDEVICE:
(void)virNodeDeviceFree(vp->res);
break;
#if HAVE_NWFILTER
case VERT_RES_NWFILTER:
(void)virNWFilterFree(vp->res);
break;
#endif
case VERT_RES_SECRET:
(void)virSecretFree(vp->res);
break;
case VERT_RES_STORAGEPOOL:
(void)virStoragePoolFree(vp->res);
break;
case VERT_RES_STORAGEVOL:
(void)virStorageVolFree(vp->res);
break;
case VERT_RES_STREAM:
(void)virStreamFree(vp->res);
break;
default:
break;
}
vp->res = NULL;
}
static void gvir_node_device_set_property(GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GVirNodeDevice *device = GVIR_NODE_DEVICE(object);
GVirNodeDevicePrivate *priv = device->priv;
switch (prop_id) {
case PROP_HANDLE:
if (priv->handle)
virNodeDeviceFree(priv->handle);
priv->handle = g_value_dup_boxed(value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
}
}
static vshNodeDeviceListPtr
vshNodeDeviceListCollect(vshControl *ctl,
char **capnames,
int ncapnames,
unsigned int flags)
{
vshNodeDeviceListPtr list = vshMalloc(ctl, sizeof(*list));
int i;
int ret;
virNodeDevicePtr device;
bool success = false;
size_t deleted = 0;
int ndevices = 0;
char **names = NULL;
/* try the list with flags support (0.10.2 and later) */
if ((ret = virConnectListAllNodeDevices(ctl->conn,
&list->devices,
flags)) >= 0) {
list->ndevices = ret;
goto finished;
}
/* check if the command is actually supported */
if (last_error && last_error->code == VIR_ERR_NO_SUPPORT)
goto fallback;
/* there was an error during the call */
vshError(ctl, "%s", _("Failed to list node devices"));
goto cleanup;
fallback:
/* fall back to old method (0.10.1 and older) */
vshResetLibvirtError();
ndevices = virNodeNumOfDevices(ctl->conn, NULL, 0);
if (ndevices < 0) {
vshError(ctl, "%s", _("Failed to count node devices"));
goto cleanup;
}
if (ndevices == 0)
return list;
names = vshMalloc(ctl, sizeof(char *) * ndevices);
ndevices = virNodeListDevices(ctl->conn, NULL, names, ndevices, 0);
if (ndevices < 0) {
vshError(ctl, "%s", _("Failed to list node devices"));
goto cleanup;
}
list->devices = vshMalloc(ctl, sizeof(virNodeDevicePtr) * (ndevices));
list->ndevices = 0;
/* get the node devices */
for (i = 0; i < ndevices ; i++) {
if (!(device = virNodeDeviceLookupByName(ctl->conn, names[i])))
continue;
list->devices[list->ndevices++] = device;
}
/* truncate domains that weren't found */
deleted = ndevices - list->ndevices;
if (!capnames)
goto finished;
/* filter the list if the list was acquired by fallback means */
for (i = 0; i < list->ndevices; i++) {
char **caps = NULL;
int ncaps = 0;
bool match = false;
device = list->devices[i];
if ((ncaps = virNodeDeviceNumOfCaps(device)) < 0) {
vshError(ctl, "%s", _("Failed to get capability numbers "
"of the device"));
goto cleanup;
}
caps = vshMalloc(ctl, sizeof(char *) * ncaps);
if ((ncaps = virNodeDeviceListCaps(device, caps, ncaps)) < 0) {
vshError(ctl, "%s", _("Failed to get capability names of the device"));
VIR_FREE(caps);
goto cleanup;
}
/* Check if the device's capability matches with provied
* capabilities.
*/
int j, k;
for (j = 0; j < ncaps; j++) {
for (k = 0; k < ncapnames; k++) {
if (STREQ(caps[j], capnames[k])) {
match = true;
break;
}
}
}
VIR_FREE(caps);
if (!match)
goto remove_entry;
/* the device matched all filters, it may stay */
continue;
remove_entry:
/* the device has to be removed as it failed one of the filters */
virNodeDeviceFree(list->devices[i]);
list->devices[i] = NULL;
deleted++;
}
finished:
/* sort the list */
if (list->devices && list->ndevices)
qsort(list->devices, list->ndevices,
sizeof(*list->devices), vshNodeDeviceSorter);
/* truncate the list if filter simulation deleted entries */
if (deleted)
VIR_SHRINK_N(list->devices, list->ndevices, deleted);
success = true;
cleanup:
for (i = 0; i < ndevices; i++)
VIR_FREE(names[i]);
VIR_FREE(names);
if (!success) {
vshNodeDeviceListFree(list);
list = NULL;
}
return list;
}
/* private slots */
void PCI_Host_Device::setAvailabledPCIDevices()
{
int i = 0;
QStringList devices;
virNodeDevice **nodeDevices = NULL;
if ( currWorkConnect!=NULL ) {
unsigned int flags =
VIR_CONNECT_LIST_NODE_DEVICES_CAP_PCI_DEV;
int ret = virConnectListAllNodeDevices(currWorkConnect, &nodeDevices, flags);
if ( ret<0 ) {
sendConnErrors();
} else {
while ( nodeDevices[i] != NULL ) {
devices.append( QString("%1\n")
// flags: extra flags; not used yet,
// so callers should always pass 0
.arg(virNodeDeviceGetXMLDesc(nodeDevices[i], 0)));
virNodeDeviceFree(nodeDevices[i]);
i++;
};
};
free(nodeDevices);
};
//int devs = virNodeNumOfDevices(currWorkConnect, NULL, 0);
//qDebug()<<"Devices("<<devs<<i<<"):\n"<<devices.join("\n");
// set unique device description to devList
// WARNING: PCI devices can only be described by their address.
foreach (QString _dev, devices) {
//qDebug()<<_dev;
QString devName, devIdentity;
QDomElement capability, domain, bus, slot, function, vendor, product;
QDomDocument doc = QDomDocument();
doc.setContent(_dev);
capability = doc.firstChildElement("device").
firstChildElement("capability");
domain = capability.firstChildElement("domain");
bus = capability.firstChildElement("bus");
slot = capability.firstChildElement("slot");
function = capability.firstChildElement("function");
vendor = capability.firstChildElement("vendor");
product = capability.firstChildElement("product");
// devIdentity format: <domain:bus:slot:function>
devIdentity.append(domain.firstChild().toText().data());
devIdentity.append(":");
devIdentity.append(bus.firstChild().toText().data());
devIdentity.append(":");
devIdentity.append(slot.firstChild().toText().data());
devIdentity.append(":");
devIdentity.append(function.firstChild().toText().data());
// devName format: <vendor_product>
devName.append(vendor.firstChild().toText().data());
devName.append("\n");
devName.append(product.firstChild().toText().data());
if ( devList->findItems(devName,
Qt::MatchExactly |
Qt::MatchCaseSensitive)
.isEmpty() ) {
devList->insertItem(0, devName);
devList->item(0)->setData(Qt::UserRole, devIdentity);
};
};
static void
gvir_node_device_handle_free(GVirNodeDeviceHandle *src)
{
virNodeDeviceFree((virNodeDevicePtr)src);
}
