static bool cmdVolClone(vshControl *ctl, const vshCmd *cmd) { virStoragePoolPtr origpool = NULL; virStorageVolPtr origvol = NULL, newvol = NULL; const char *name = NULL; char *origxml = NULL; xmlChar *newxml = NULL; bool ret = false; unsigned int flags = 0; if (!(origvol = vshCommandOptVol(ctl, cmd, "vol", "pool", NULL))) goto cleanup; if (vshCommandOptBool(cmd, "prealloc-metadata")) flags |= VIR_STORAGE_VOL_CREATE_PREALLOC_METADATA; origpool = virStoragePoolLookupByVolume(origvol); if (!origpool) { vshError(ctl, "%s", _("failed to get parent pool")); goto cleanup; } if (vshCommandOptStringReq(ctl, cmd, "newname", &name) < 0) goto cleanup; origxml = virStorageVolGetXMLDesc(origvol, 0); if (!origxml) goto cleanup; newxml = vshMakeCloneXML(origxml, name); if (!newxml) { vshPrint(ctl, "%s", _("Failed to allocate XML buffer")); goto cleanup; } newvol = virStorageVolCreateXMLFrom(origpool, (char *) newxml, origvol, flags); if (newvol != NULL) { vshPrint(ctl, _("Vol %s cloned from %s\n"), virStorageVolGetName(newvol), virStorageVolGetName(origvol)); } else { vshError(ctl, _("Failed to clone vol from %s"), virStorageVolGetName(origvol)); goto cleanup; } ret = true; cleanup: VIR_FREE(origxml); xmlFree(newxml); if (origvol) virStorageVolFree(origvol); if (newvol) virStorageVolFree(newvol); if (origpool) virStoragePoolFree(origpool); return ret; }
static bool cmdVolClone(vshControl *ctl, const vshCmd *cmd) { virStoragePoolPtr origpool = NULL; virStorageVolPtr origvol = NULL, newvol = NULL; const char *name = NULL; char *origxml = NULL; xmlChar *newxml = NULL; bool ret = false; if (!vshConnectionUsability(ctl, ctl->conn)) goto cleanup; if (!(origvol = vshCommandOptVol(ctl, cmd, "vol", "pool", NULL))) goto cleanup; origpool = virStoragePoolLookupByVolume(origvol); if (!origpool) { vshError(ctl, "%s", _("failed to get parent pool")); goto cleanup; } if (vshCommandOptString(cmd, "newname", &name) <= 0) goto cleanup; origxml = virStorageVolGetXMLDesc(origvol, 0); if (!origxml) goto cleanup; newxml = makeCloneXML(origxml, name); if (!newxml) { vshPrint(ctl, "%s", _("Failed to allocate XML buffer")); goto cleanup; } newvol = virStorageVolCreateXMLFrom(origpool, (char *) newxml, origvol, 0); if (newvol != NULL) { vshPrint(ctl, _("Vol %s cloned from %s\n"), virStorageVolGetName(newvol), virStorageVolGetName(origvol)); } else { vshError(ctl, _("Failed to clone vol from %s"), virStorageVolGetName(origvol)); goto cleanup; } ret = true; cleanup: VIR_FREE(origxml); xmlFree(newxml); if (origvol) virStorageVolFree(origvol); if (newvol) virStorageVolFree(newvol); if (origpool) virStoragePoolFree(origpool); return ret; }
static bool cmdVolResize(vshControl *ctl, const vshCmd *cmd) { virStorageVolPtr vol; const char *capacityStr = NULL; unsigned long long capacity = 0; unsigned int flags = 0; bool ret = false; bool delta = false; if (vshCommandOptBool(cmd, "allocate")) flags |= VIR_STORAGE_VOL_RESIZE_ALLOCATE; if (vshCommandOptBool(cmd, "delta")) { delta = true; flags |= VIR_STORAGE_VOL_RESIZE_DELTA; } if (vshCommandOptBool(cmd, "shrink")) flags |= VIR_STORAGE_VOL_RESIZE_SHRINK; if (!(vol = vshCommandOptVol(ctl, cmd, "vol", "pool", NULL))) return false; if (vshCommandOptStringReq(ctl, cmd, "capacity", &capacityStr) < 0) goto cleanup; virSkipSpaces(&capacityStr); if (*capacityStr == '-') { /* The API always requires a positive value; but we allow a * negative value for convenience. */ if (delta && vshCommandOptBool(cmd, "shrink")){ capacityStr++; } else { vshError(ctl, "%s", _("negative size requires --delta and --shrink")); goto cleanup; } } if (vshVolSize(capacityStr, &capacity) < 0) { vshError(ctl, _("Malformed size %s"), capacityStr); goto cleanup; } if (virStorageVolResize(vol, capacity, flags) == 0) { vshPrint(ctl, delta ? _("Size of volume '%s' successfully changed by %s\n") : _("Size of volume '%s' successfully changed to %s\n"), virStorageVolGetName(vol), capacityStr); ret = true; } else { vshError(ctl, delta ? _("Failed to change size of volume '%s' by %s\n") : _("Failed to change size of volume '%s' to %s\n"), virStorageVolGetName(vol), capacityStr); ret = false; } cleanup: virStorageVolFree(vol); return ret; }
static int vshStorageVolSorter(const void *a, const void *b) { virStorageVolPtr *va = (virStorageVolPtr *) a; virStorageVolPtr *vb = (virStorageVolPtr *) b; if (*va && !*vb) return -1; if (!*va) return *vb != NULL; return vshStrcasecmp(virStorageVolGetName(*va), virStorageVolGetName(*vb)); }
static bool cmdVolCreateFrom(vshControl *ctl, const vshCmd *cmd) { virStoragePoolPtr pool = NULL; virStorageVolPtr newvol = NULL, inputvol = NULL; const char *from = NULL; bool ret = false; char *buffer = NULL; if (!vshConnectionUsability(ctl, ctl->conn)) goto cleanup; if (!(pool = vshCommandOptPool(ctl, cmd, "pool", NULL))) goto cleanup; if (vshCommandOptString(cmd, "file", &from) <= 0) { goto cleanup; } if (!(inputvol = vshCommandOptVol(ctl, cmd, "vol", "inputpool", NULL))) goto cleanup; if (virFileReadAll(from, VIRSH_MAX_XML_FILE, &buffer) < 0) { virshReportError(ctl); goto cleanup; } newvol = virStorageVolCreateXMLFrom(pool, buffer, inputvol, 0); if (newvol != NULL) { vshPrint(ctl, _("Vol %s created from input vol %s\n"), virStorageVolGetName(newvol), virStorageVolGetName(inputvol)); } else { vshError(ctl, _("Failed to create vol from %s"), from); goto cleanup; } ret = true; cleanup: VIR_FREE(buffer); if (pool) virStoragePoolFree(pool); if (inputvol) virStorageVolFree(inputvol); if (newvol) virStorageVolFree(newvol); return ret; }
static bool cmdVolCreateFrom(vshControl *ctl, const vshCmd *cmd) { virStoragePoolPtr pool = NULL; virStorageVolPtr newvol = NULL, inputvol = NULL; const char *from = NULL; bool ret = false; char *buffer = NULL; unsigned int flags = 0; if (!(pool = vshCommandOptPool(ctl, cmd, "pool", NULL))) goto cleanup; if (vshCommandOptBool(cmd, "prealloc-metadata")) flags |= VIR_STORAGE_VOL_CREATE_PREALLOC_METADATA; if (vshCommandOptStringReq(ctl, cmd, "file", &from) < 0) goto cleanup; if (!(inputvol = vshCommandOptVol(ctl, cmd, "vol", "inputpool", NULL))) goto cleanup; if (virFileReadAll(from, VSH_MAX_XML_FILE, &buffer) < 0) { vshReportError(ctl); goto cleanup; } newvol = virStorageVolCreateXMLFrom(pool, buffer, inputvol, flags); if (newvol != NULL) { vshPrint(ctl, _("Vol %s created from input vol %s\n"), virStorageVolGetName(newvol), virStorageVolGetName(inputvol)); } else { vshError(ctl, _("Failed to create vol from %s"), from); goto cleanup; } ret = true; cleanup: VIR_FREE(buffer); if (pool) virStoragePoolFree(pool); if (inputvol) virStorageVolFree(inputvol); if (newvol) virStorageVolFree(newvol); return ret; }
static bool cmdVolInfo(vshControl *ctl, const vshCmd *cmd) { virStorageVolInfo info; virStorageVolPtr vol; bool ret = true; if (!(vol = vshCommandOptVol(ctl, cmd, "vol", "pool", NULL))) return false; vshPrint(ctl, "%-15s %s\n", _("Name:"), virStorageVolGetName(vol)); if (virStorageVolGetInfo(vol, &info) == 0) { double val; const char *unit; vshPrint(ctl, "%-15s %s\n", _("Type:"), vshVolumeTypeToString(info.type)); val = vshPrettyCapacity(info.capacity, &unit); vshPrint(ctl, "%-15s %2.2lf %s\n", _("Capacity:"), val, unit); val = vshPrettyCapacity(info.allocation, &unit); vshPrint(ctl, "%-15s %2.2lf %s\n", _("Allocation:"), val, unit); } else { ret = false; } virStorageVolFree(vol); return ret; }
const gchar *gvir_storage_vol_get_name(GVirStorageVol *vol) { const char *name; g_return_val_if_fail(GVIR_IS_STORAGE_VOL(vol), NULL); if (!(name = virStorageVolGetName(vol->priv->handle))) { gvir_warning("Failed to get storage_vol name on %p", vol->priv->handle); return NULL; } return name; }
static bool cmdVolInfo(vshControl *ctl, const vshCmd *cmd) { virStorageVolInfo info; virStorageVolPtr vol; bool ret = true; if (!vshConnectionUsability(ctl, ctl->conn)) return false; if (!(vol = vshCommandOptVol(ctl, cmd, "vol", "pool", NULL))) return false; vshPrint(ctl, "%-15s %s\n", _("Name:"), virStorageVolGetName(vol)); if (virStorageVolGetInfo(vol, &info) == 0) { double val; const char *unit; switch(info.type) { case VIR_STORAGE_VOL_FILE: vshPrint(ctl, "%-15s %s\n", _("Type:"), _("file")); break; case VIR_STORAGE_VOL_BLOCK: vshPrint(ctl, "%-15s %s\n", _("Type:"), _("block")); break; case VIR_STORAGE_VOL_DIR: vshPrint(ctl, "%-15s %s\n", _("Type:"), _("dir")); break; case VIR_STORAGE_VOL_NETWORK: vshPrint(ctl, "%-15s %s\n", _("Type:"), _("network")); break; default: vshPrint(ctl, "%-15s %s\n", _("Type:"), _("unknown")); } val = prettyCapacity(info.capacity, &unit); vshPrint(ctl, "%-15s %2.2lf %s\n", _("Capacity:"), val, unit); val = prettyCapacity(info.allocation, &unit); vshPrint(ctl, "%-15s %2.2lf %s\n", _("Allocation:"), val, unit); } else { ret = false; } virStorageVolFree(vol); return ret; }
VolumeWrap::VolumeWrap(PoolWrap *parent, virStorageVolPtr volume_ptr, virConnectPtr connect): PackageOwner<PoolWrap::PackageDefinition>(parent), ManagedObject(package().data_Volume), _volume_ptr(volume_ptr), _conn(connect), _lvm_name(""), _has_lvm_child(false), _wrap_parent(parent) { const char *volume_key; char *volume_path; const char *volume_name; volume_key = virStorageVolGetKey(_volume_ptr); if (volume_key == NULL) { REPORT_ERR(_conn, "Error getting storage volume key\n"); throw 1; } _volume_key = volume_key; volume_path = virStorageVolGetPath(_volume_ptr); if (volume_path == NULL) { REPORT_ERR(_conn, "Error getting volume path\n"); throw 1; } _volume_path = volume_path; volume_name = virStorageVolGetName(_volume_ptr); if (volume_name == NULL) { REPORT_ERR(_conn, "Error getting volume name\n"); throw 1; } _volume_name = volume_name; _data.setProperty("key", _volume_key); _data.setProperty("path", _volume_path); _data.setProperty("name", _volume_name); _data.setProperty("childLVMName", _lvm_name); _data.setProperty("storagePool", parent->objectID()); // Set defaults _data.setProperty("capacity", (uint64_t)0); _data.setProperty("allocation", (uint64_t)0); addData(_data); printf("done\n"); }
static bool cmdVolCreate(vshControl *ctl, const vshCmd *cmd) { virStoragePoolPtr pool; virStorageVolPtr vol; const char *from = NULL; bool ret = true; char *buffer; if (!vshConnectionUsability(ctl, ctl->conn)) return false; if (!(pool = vshCommandOptPoolBy(ctl, cmd, "pool", NULL, VSH_BYNAME))) return false; if (vshCommandOptString(cmd, "file", &from) <= 0) { virStoragePoolFree(pool); return false; } if (virFileReadAll(from, VIRSH_MAX_XML_FILE, &buffer) < 0) { virshReportError(ctl); virStoragePoolFree(pool); return false; } vol = virStorageVolCreateXML(pool, buffer, 0); VIR_FREE(buffer); virStoragePoolFree(pool); if (vol != NULL) { vshPrint(ctl, _("Vol %s created from %s\n"), virStorageVolGetName(vol), from); virStorageVolFree(vol); } else { vshError(ctl, _("Failed to create vol from %s"), from); ret = false; } return ret; }
Result StorageVolControlThread::createStorageVol() { Result result; result.name = QString("%1_%2").arg(task.srcConName).arg(currPoolName); QString path = task.args.path; QByteArray xmlData; QFile f; f.setFileName(path); if ( !f.open(QIODevice::ReadOnly) ) { QString msg = QString("File \"%1\"\nnot opened.").arg(path); emit errorMsg( msg, number ); result.result = false; result.err = msg; return result; }; xmlData = f.readAll(); f.close(); if (currStoragePool!=NULL) { virStoragePoolFree(currStoragePool); currStoragePool = NULL; }; currStoragePool = virStoragePoolLookupByName( *task.srcConnPtr, currPoolName.toUtf8().data()); virStorageVolPtr storageVol = virStorageVolCreateXML( currStoragePool, xmlData.data(), VIR_STORAGE_VOL_CREATE_PREALLOC_METADATA); if ( storageVol==NULL ) { result.err = sendConnErrors(); result.result = false; return result; }; QString name = QString().fromUtf8( virStorageVolGetName(storageVol) ); result.msg.append( QString("'<b>%1</b>' StorageVol from\n\"%2\"\nis created.") .arg(name).arg(path)); virStorageVolFree(storageVol); result.result = true; return result; }
static bool cmdVolCreate(vshControl *ctl, const vshCmd *cmd) { virStoragePoolPtr pool; virStorageVolPtr vol; const char *from = NULL; bool ret = false; unsigned int flags = 0; char *buffer = NULL; if (vshCommandOptBool(cmd, "prealloc-metadata")) flags |= VIR_STORAGE_VOL_CREATE_PREALLOC_METADATA; if (!(pool = vshCommandOptPool(ctl, cmd, "pool", NULL))) return false; if (vshCommandOptStringReq(ctl, cmd, "file", &from) < 0) goto cleanup; if (virFileReadAll(from, VSH_MAX_XML_FILE, &buffer) < 0) { vshSaveLibvirtError(); goto cleanup; } if ((vol = virStorageVolCreateXML(pool, buffer, flags))) { vshPrint(ctl, _("Vol %s created from %s\n"), virStorageVolGetName(vol), from); virStorageVolFree(vol); ret = true; } else { vshError(ctl, _("Failed to create vol from %s"), from); } cleanup: VIR_FREE(buffer); virStoragePoolFree(pool); return ret; }
Result StorageVolControlThread::getAllStorageVolList() { Result result; result.name = QString("%1_%2").arg(task.srcConName).arg(currPoolName); QStringList storageVolList; if (currStoragePool!=NULL) { virStoragePoolFree(currStoragePool); currStoragePool = NULL; }; currStoragePool = virStoragePoolLookupByName( *task.srcConnPtr, currPoolName.toUtf8().data()); if ( currStoragePool!=NULL && keep_alive ) { virStorageVolPtr *storageVol = NULL; // flags: extra flags; not used yet, so callers should always pass 0 unsigned int flags = 0; int ret = virStoragePoolListAllVolumes( currStoragePool, &storageVol, flags); if ( ret<0 ) { result.err = sendConnErrors(); result.result = false; result.msg = storageVolList; return result; }; // therefore correctly to use for() command, because storageVol[0] can not exist. for (int i = 0; i < ret; i++) { QString type, capacity, allocation; virStorageVolInfo info; if ( virStorageVolGetInfo(storageVol[i], &info)+1 ) { switch (info.type) { case VIR_STORAGE_VOL_FILE: type.append("file"); break; case VIR_STORAGE_VOL_BLOCK: type.append("block"); break; case VIR_STORAGE_VOL_DIR: type.append("dir"); break; case VIR_STORAGE_VOL_NETWORK: type.append("net"); break; default: type.append("-"); break; }; allocation.append(QString("%1").arg(info.allocation)); capacity.append(QString("%1").arg(info.capacity)); } else { sendConnErrors(); type.append("-"); allocation.append("-"); capacity.append("-"); }; QStringList currentAttr; currentAttr<< QString::fromUtf8( virStorageVolGetName(storageVol[i]) ) << QString::fromUtf8( virStorageVolGetPath(storageVol[i]) ) << QString( type ) << QString( allocation ) << QString( capacity );; storageVolList.append(currentAttr); //qDebug()<<currentAttr<<"Volume"; virStorageVolFree(storageVol[i]); }; free(storageVol); } else result.err = sendConnErrors(); result.result = true; result.msg = storageVolList; return result; }