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 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; }
Result StorageVolControlThread::resizeStorageVol() { Result result; result.name = QString("%1_%2").arg(task.srcConName).arg(currPoolName); QString name = task.object; if (currStoragePool!=NULL) { virStoragePoolFree(currStoragePool); currStoragePool = NULL; }; currStoragePool = virStoragePoolLookupByName( *task.srcConnPtr, currPoolName.toUtf8().data()); unsigned long long capacity = task.args.size; bool resized = false; virStorageVol *storageVol = virStorageVolLookupByName( currStoragePool, name.toUtf8().data()); if ( storageVol!=NULL ) { int ret = virStorageVolResize( storageVol, capacity, VIR_STORAGE_VOL_RESIZE_ALLOCATE | VIR_STORAGE_VOL_RESIZE_SHRINK); if ( ret<0 ) { result.err = sendConnErrors(); } else resized = true; virStorageVolFree(storageVol); } else result.err = sendConnErrors(); result.msg.append( QString("'<b>%1</b>' StorageVol %2 Resized to %3 (bytes).") .arg(name).arg((resized)?"":"don't").arg(capacity)); result.result = resized; return result; }
Result StorageVolControlThread::deleteStorageVol() { Result result; result.name = QString("%1_%2").arg(task.srcConName).arg(currPoolName); QString name = task.object; if (currStoragePool!=NULL) { virStoragePoolFree(currStoragePool); currStoragePool = NULL; }; currStoragePool = virStoragePoolLookupByName( *task.srcConnPtr, currPoolName.toUtf8().data()); // flags: extra flags; not used yet, so callers should always pass 0 unsigned int flags = 0; bool deleted = false; virStorageVol *storageVol = virStorageVolLookupByName( currStoragePool, name.toUtf8().data()); if ( storageVol!=NULL ) { deleted = (virStorageVolDelete(storageVol, flags)+1) ? true : false; if (!deleted) result.err = sendConnErrors(); virStorageVolFree(storageVol); } else result.err = sendConnErrors(); result.msg.append(QString("'<b>%1</b>' StorageVol %2 Deleted.") .arg(name).arg((deleted)?"":"don't")); result.result = deleted; return result; }
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 void gvir_storage_vol_finalize(GObject *object) { GVirStorageVol *vol = GVIR_STORAGE_VOL(object); GVirStorageVolPrivate *priv = vol->priv; virStorageVolFree(priv->handle); G_OBJECT_CLASS(gvir_storage_vol_parent_class)->finalize(object); }
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; }
static void vshStorageVolListFree(vshStorageVolListPtr list) { size_t i; if (list && list->vols) { for (i = 0; i < list->nvols; i++) { if (list->vols[i]) virStorageVolFree(list->vols[i]); } VIR_FREE(list->vols); } VIR_FREE(list); }
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 bool cmdVolWipe(vshControl *ctl, const vshCmd *cmd) { virStorageVolPtr vol; bool ret = false; const char *name; const char *algorithm_str = NULL; int algorithm = VIR_STORAGE_VOL_WIPE_ALG_ZERO; int funcRet; if (!vshConnectionUsability(ctl, ctl->conn)) return false; if (!(vol = vshCommandOptVol(ctl, cmd, "vol", "pool", &name))) { return false; } if (vshCommandOptString(cmd, "algorithm", &algorithm_str) < 0) { vshError(ctl, "%s", _("missing argument")); goto out; } if (algorithm_str && (algorithm = virStorageVolWipeAlgorithmTypeFromString(algorithm_str)) < 0) { vshError(ctl, _("Unsupported algorithm '%s'"), algorithm_str); goto out; } if ((funcRet = virStorageVolWipePattern(vol, algorithm, 0)) < 0) { if (last_error->code == VIR_ERR_NO_SUPPORT && algorithm == VIR_STORAGE_VOL_WIPE_ALG_ZERO) funcRet = virStorageVolWipe(vol, 0); } if (funcRet < 0) { vshError(ctl, _("Failed to wipe vol %s"), name); goto out; } vshPrint(ctl, _("Vol %s wiped\n"), name); ret = true; out: virStorageVolFree(vol); return ret; }
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; }
static bool cmdVolDelete(vshControl *ctl, const vshCmd *cmd) { virStorageVolPtr vol; bool ret = true; const char *name; if (!(vol = vshCommandOptVol(ctl, cmd, "vol", "pool", &name))) { return false; } if (virStorageVolDelete(vol, 0) == 0) { vshPrint(ctl, _("Vol %s deleted\n"), name); } else { vshError(ctl, _("Failed to delete vol %s"), name); ret = false; } virStorageVolFree(vol); return ret; }
static bool cmdVolDumpXML(vshControl *ctl, const vshCmd *cmd) { virStorageVolPtr vol; bool ret = true; char *dump; if (!(vol = vshCommandOptVol(ctl, cmd, "vol", "pool", NULL))) return false; dump = virStorageVolGetXMLDesc(vol, 0); if (dump != NULL) { vshPrint(ctl, "%s", dump); VIR_FREE(dump); } else { ret = false; } virStorageVolFree(vol); return ret; }
Result StorageVolControlThread::getStorageVolXMLDesc() { Result result; result.name = QString("%1_%2").arg(task.srcConName).arg(currPoolName); QString name = task.object; if (currStoragePool!=NULL) { virStoragePoolFree(currStoragePool); currStoragePool = NULL; }; currStoragePool = virStoragePoolLookupByName( *task.srcConnPtr, currPoolName.toUtf8().data()); bool read = false; char *Returns = NULL; // flags: extra flags; not used yet, so callers should always pass 0 unsigned int flags = 0; virStorageVol *storageVol = virStorageVolLookupByName( currStoragePool, name.toUtf8().data()); if ( storageVol!=NULL ) { Returns = virStorageVolGetXMLDesc(storageVol, flags); if ( Returns==NULL ) result.err = sendConnErrors(); else read = true; virStorageVolFree(storageVol); } else result.err = sendConnErrors(); QTemporaryFile f; f.setAutoRemove(false); f.setFileTemplate(QString("%1%2XML_Desc-XXXXXX.xml") .arg(QDir::tempPath()).arg(QDir::separator())); read = f.open(); if (read) f.write(Returns); result.fileName.append(f.fileName()); f.close(); if ( Returns!=NULL ) free(Returns); result.msg.append(QString("'<b>%1</b>' StorageVol %2 XML'ed") .arg(name).arg((read)?"":"don't")); result.result = read; return result; }
static void gvir_storage_vol_set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { GVirStorageVol *vol = GVIR_STORAGE_VOL(object); GVirStorageVolPrivate *priv = vol->priv; switch (prop_id) { case PROP_HANDLE: if (priv->handle) virStorageVolFree(priv->handle); priv->handle = g_value_dup_boxed(value); break; case PROP_POOL: priv->pool = g_value_get_object(value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); } }
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; }
static bool cmdVolUpload(vshControl *ctl, const vshCmd *cmd) { const char *file = NULL; virStorageVolPtr vol = NULL; bool ret = false; int fd = -1; virStreamPtr st = NULL; const char *name = NULL; unsigned long long offset = 0, length = 0; if (!vshConnectionUsability(ctl, ctl->conn)) goto cleanup; if (vshCommandOptULongLong(cmd, "offset", &offset) < 0) { vshError(ctl, _("Unable to parse integer")); return false; } if (vshCommandOptULongLong(cmd, "length", &length) < 0) { vshError(ctl, _("Unable to parse integer")); return false; } if (!(vol = vshCommandOptVol(ctl, cmd, "vol", "pool", &name))) { return false; } if (vshCommandOptString(cmd, "file", &file) < 0) { vshError(ctl, _("file must not be empty")); goto cleanup; } if ((fd = open(file, O_RDONLY)) < 0) { vshError(ctl, _("cannot read %s"), file); goto cleanup; } st = virStreamNew(ctl->conn, 0); if (virStorageVolUpload(vol, st, offset, length, 0) < 0) { vshError(ctl, _("cannot upload to volume %s"), name); goto cleanup; } if (virStreamSendAll(st, cmdVolUploadSource, &fd) < 0) { vshError(ctl, _("cannot send data to volume %s"), name); goto cleanup; } if (VIR_CLOSE(fd) < 0) { vshError(ctl, _("cannot close file %s"), file); virStreamAbort(st); goto cleanup; } if (virStreamFinish(st) < 0) { vshError(ctl, _("cannot close volume %s"), name); goto cleanup; } ret = true; cleanup: if (vol) virStorageVolFree(vol); if (st) virStreamFree(st); VIR_FORCE_CLOSE(fd); return ret; }
Result StorageVolControlThread::wipeStorageVol() { Result result; result.name = QString("%1_%2").arg(task.srcConName).arg(currPoolName); QString name, algorithm; name = task.object; if (currStoragePool!=NULL) { virStoragePoolFree(currStoragePool); currStoragePool = NULL; }; currStoragePool = virStoragePoolLookupByName( *task.srcConnPtr, currPoolName.toUtf8().data()); //flags: extra flags; not used yet, so callers should always pass 0 unsigned int flags = 0; unsigned int alg = task.args.sign; bool wiped = false; virStorageVol *storageVol = virStorageVolLookupByName( currStoragePool, name.toUtf8().data()); if ( storageVol!=NULL ) { int ret = virStorageVolWipePattern(storageVol, alg, flags); if ( ret<0 ) { result.err = sendConnErrors(); } else wiped = true; virStorageVolFree(storageVol); } else result.err = sendConnErrors(); switch (alg) { case VIR_STORAGE_VOL_WIPE_ALG_ZERO: algorithm.append("ZERO"); break; case VIR_STORAGE_VOL_WIPE_ALG_NNSA: algorithm.append("NNSA"); break; case VIR_STORAGE_VOL_WIPE_ALG_DOD: algorithm.append("DOD"); break; case VIR_STORAGE_VOL_WIPE_ALG_BSI: algorithm.append("BSI"); break; case VIR_STORAGE_VOL_WIPE_ALG_GUTMANN: algorithm.append("GUTMANN"); break; case VIR_STORAGE_VOL_WIPE_ALG_PFITZNER7: algorithm.append("PFITZNER7"); break; case VIR_STORAGE_VOL_WIPE_ALG_PFITZNER33: algorithm.append("PFITZNER33"); break; case VIR_STORAGE_VOL_WIPE_ALG_RANDOM: algorithm.append("RANDOM"); break; case VIR_STORAGE_VOL_WIPE_ALG_SCHNEIER: algorithm.append("SCHNEIER"); break; default: algorithm.append("NONE"); break; }; result.msg.append( QString("'<b>%1</b>' StorageVol %2 Wiped with %3 algorithm.") .arg(name).arg((wiped)?"":"don't").arg(algorithm)); result.result = wiped; return result; }
Result StorageVolControlThread::uploadStorageVol() { Result result; result.name = QString("%1_%2").arg(task.srcConName).arg(currPoolName); QString name, path; name = task.object; path = task.args.path; //qDebug()<<path<<"upload"; if (currStoragePool!=NULL) { virStoragePoolFree(currStoragePool); currStoragePool = NULL; }; currStoragePool = virStoragePoolLookupByName( *task.srcConnPtr, currPoolName.toUtf8().data()); QFile *f = new QFile(path); f->open(QIODevice::ReadOnly); bool uploaded = false; virStreamPtr stream = virStreamNew(*task.srcConnPtr, 0); unsigned long long offset = 0; unsigned long long length = f->size(); // flags: extra flags; not used yet, so callers should always pass 0 unsigned int flags = 0; virStorageVol *storageVol = virStorageVolLookupByName( currStoragePool, name.toUtf8().data()); if ( storageVol!=NULL ) { int ret = virStorageVolUpload( storageVol, stream, offset, length, flags); if ( ret<0 ) { result.err = sendConnErrors(); } else { uploaded = true; length = 0; int got, saved, step; step = 0; char buf[BLOCK_SIZE]; while ( 1 && keep_alive ) { got = f->read(buf, BLOCK_SIZE); if (got == 0) break; if ( got<0 ) { QString msg = QString("ReadError after (%2): %1 bytes") .arg(length).arg(step); emit errorMsg( msg, number ); result.err = msg; } else { saved = virStreamSend(stream, buf, got); if (saved < 0) { result.err = sendConnErrors(); uploaded = false; break; }; step++; length += saved; //qDebug()<<"got<>saved:length"<<got<<saved<<step<<length; }; }; virStreamFinish(stream); }; virStorageVolFree(storageVol); } else result.err = sendConnErrors(); if ( stream!=NULL ) virStreamFree(stream); f->close(); delete f; f = 0; result.msg.append( QString("'<b>%1</b>' StorageVol %2 Uploaded from %3 (%4).") .arg(name).arg((uploaded)?"":"don't") .arg(path).arg(length)); result.result = uploaded; return result; }
virStorageVolPtr vshCommandOptVolBy(vshControl *ctl, const vshCmd *cmd, const char *optname, const char *pooloptname, const char **name, unsigned int flags) { virStorageVolPtr vol = NULL; virStoragePoolPtr pool = NULL; const char *n = NULL, *p = NULL; virCheckFlags(VSH_BYUUID | VSH_BYNAME, NULL); if (vshCommandOptStringReq(ctl, cmd, optname, &n) < 0) return NULL; if (pooloptname != NULL && vshCommandOptStringReq(ctl, cmd, pooloptname, &p) < 0) return NULL; if (p) { if (!(pool = vshCommandOptPoolBy(ctl, cmd, pooloptname, name, flags))) return NULL; if (virStoragePoolIsActive(pool) != 1) { vshError(ctl, _("pool '%s' is not active"), p); virStoragePoolFree(pool); return NULL; } } vshDebug(ctl, VSH_ERR_DEBUG, "%s: found option <%s>: %s\n", cmd->def->name, optname, n); if (name) *name = n; /* try it by name */ if (pool && (flags & VSH_BYNAME)) { vshDebug(ctl, VSH_ERR_DEBUG, "%s: <%s> trying as vol name\n", cmd->def->name, optname); vol = virStorageVolLookupByName(pool, n); } /* try it by key */ if (!vol && (flags & VSH_BYUUID)) { vshDebug(ctl, VSH_ERR_DEBUG, "%s: <%s> trying as vol key\n", cmd->def->name, optname); vol = virStorageVolLookupByKey(ctl->conn, n); } /* try it by path */ if (!vol && (flags & VSH_BYUUID)) { vshDebug(ctl, VSH_ERR_DEBUG, "%s: <%s> trying as vol path\n", cmd->def->name, optname); vol = virStorageVolLookupByPath(ctl->conn, n); } if (!vol) { if (pool || !pooloptname) vshError(ctl, _("failed to get vol '%s'"), n); else vshError(ctl, _("failed to get vol '%s', specifying --%s " "might help"), n, pooloptname); } /* If the pool was specified, then make sure that the returned * volume is from the given pool */ if (pool && vol) { virStoragePoolPtr volpool = NULL; if ((volpool = virStoragePoolLookupByVolume(vol))) { if (STRNEQ(virStoragePoolGetName(volpool), virStoragePoolGetName(pool))) { vshResetLibvirtError(); vshError(ctl, _("Requested volume '%s' is not in pool '%s'"), n, virStoragePoolGetName(pool)); virStorageVolFree(vol); vol = NULL; } virStoragePoolFree(volpool); } } if (pool) virStoragePoolFree(pool); return vol; }
VolumeWrap::~VolumeWrap() { virStorageVolFree(_volume_ptr); delData(_data); }
static void gvir_storage_vol_handle_free(GVirStorageVolHandle *src) { virStorageVolFree((virStorageVolPtr)src); }
static bool cmdVolCreateAs(vshControl *ctl, const vshCmd *cmd) { virStoragePoolPtr pool; virStorageVolPtr vol; char *xml; const char *name, *capacityStr = NULL, *allocationStr = NULL, *format = NULL; const char *snapshotStrVol = NULL, *snapshotStrFormat = NULL; unsigned long long capacity, allocation = 0; virBuffer buf = VIR_BUFFER_INITIALIZER; if (!vshConnectionUsability(ctl, ctl->conn)) return false; if (!(pool = vshCommandOptPoolBy(ctl, cmd, "pool", NULL, VSH_BYNAME))) return false; if (vshCommandOptString(cmd, "name", &name) <= 0) goto cleanup; if (vshCommandOptString(cmd, "capacity", &capacityStr) <= 0) goto cleanup; if (vshVolSize(capacityStr, &capacity) < 0) { vshError(ctl, _("Malformed size %s"), capacityStr); goto cleanup; } if (vshCommandOptString(cmd, "allocation", &allocationStr) > 0 && vshVolSize(allocationStr, &allocation) < 0) { vshError(ctl, _("Malformed size %s"), allocationStr); goto cleanup; } if (vshCommandOptString(cmd, "format", &format) < 0 || vshCommandOptString(cmd, "backing-vol", &snapshotStrVol) < 0 || vshCommandOptString(cmd, "backing-vol-format", &snapshotStrFormat) < 0) { vshError(ctl, "%s", _("missing argument")); goto cleanup; } virBufferAddLit(&buf, "<volume>\n"); virBufferAsprintf(&buf, " <name>%s</name>\n", name); virBufferAsprintf(&buf, " <capacity>%llu</capacity>\n", capacity); if (allocationStr) virBufferAsprintf(&buf, " <allocation>%llu</allocation>\n", allocation); if (format) { virBufferAddLit(&buf, " <target>\n"); virBufferAsprintf(&buf, " <format type='%s'/>\n",format); virBufferAddLit(&buf, " </target>\n"); } /* Convert the snapshot parameters into backingStore XML */ if (snapshotStrVol) { /* Lookup snapshot backing volume. Try the backing-vol * parameter as a name */ vshDebug(ctl, VSH_ERR_DEBUG, "%s: Look up backing store volume '%s' as name\n", cmd->def->name, snapshotStrVol); virStorageVolPtr snapVol = virStorageVolLookupByName(pool, snapshotStrVol); if (snapVol) vshDebug(ctl, VSH_ERR_DEBUG, "%s: Backing store volume found using '%s' as name\n", cmd->def->name, snapshotStrVol); if (snapVol == NULL) { /* Snapshot backing volume not found by name. Try the * backing-vol parameter as a key */ vshDebug(ctl, VSH_ERR_DEBUG, "%s: Look up backing store volume '%s' as key\n", cmd->def->name, snapshotStrVol); snapVol = virStorageVolLookupByKey(ctl->conn, snapshotStrVol); if (snapVol) vshDebug(ctl, VSH_ERR_DEBUG, "%s: Backing store volume found using '%s' as key\n", cmd->def->name, snapshotStrVol); } if (snapVol == NULL) { /* Snapshot backing volume not found by key. Try the * backing-vol parameter as a path */ vshDebug(ctl, VSH_ERR_DEBUG, "%s: Look up backing store volume '%s' as path\n", cmd->def->name, snapshotStrVol); snapVol = virStorageVolLookupByPath(ctl->conn, snapshotStrVol); if (snapVol) vshDebug(ctl, VSH_ERR_DEBUG, "%s: Backing store volume found using '%s' as path\n", cmd->def->name, snapshotStrVol); } if (snapVol == NULL) { vshError(ctl, _("failed to get vol '%s'"), snapshotStrVol); goto cleanup; } char *snapshotStrVolPath; if ((snapshotStrVolPath = virStorageVolGetPath(snapVol)) == NULL) { virStorageVolFree(snapVol); goto cleanup; } /* Create XML for the backing store */ virBufferAddLit(&buf, " <backingStore>\n"); virBufferAsprintf(&buf, " <path>%s</path>\n",snapshotStrVolPath); if (snapshotStrFormat) virBufferAsprintf(&buf, " <format type='%s'/>\n",snapshotStrFormat); virBufferAddLit(&buf, " </backingStore>\n"); /* Cleanup snapshot allocations */ VIR_FREE(snapshotStrVolPath); virStorageVolFree(snapVol); } virBufferAddLit(&buf, "</volume>\n"); if (virBufferError(&buf)) { vshPrint(ctl, "%s", _("Failed to allocate XML buffer")); goto cleanup; } xml = virBufferContentAndReset(&buf); vol = virStorageVolCreateXML(pool, xml, 0); VIR_FREE(xml); virStoragePoolFree(pool); if (vol != NULL) { vshPrint(ctl, _("Vol %s created\n"), name); virStorageVolFree(vol); return true; } else { vshError(ctl, _("Failed to create vol %s"), name); return false; } cleanup: virBufferFreeAndReset(&buf); virStoragePoolFree(pool); return false; }
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; }
/** * gvir_storage_pool_refresh: * @pool: the storage pool * @cancellable: (allow-none)(transfer none): cancellation object */ gboolean gvir_storage_pool_refresh(GVirStoragePool *pool, GCancellable *cancellable, GError **err) { GVirStoragePoolPrivate *priv; GHashTable *vol_hash; gchar **volumes = NULL; gint nvolumes = 0; gboolean ret = FALSE; gint i; virStoragePoolPtr vpool = NULL; GError *lerr = NULL; g_return_val_if_fail(GVIR_IS_STORAGE_POOL(pool), FALSE); g_return_val_if_fail((cancellable == NULL) || G_IS_CANCELLABLE(cancellable), FALSE); g_return_val_if_fail(err == NULL || *err == NULL, FALSE); priv = pool->priv; vpool = priv->handle; if (virStoragePoolRefresh(vpool, 0) < 0) { gvir_set_error_literal(err, GVIR_STORAGE_POOL_ERROR, 0, "Unable to refresh storage pool"); goto cleanup; } volumes = fetch_list(vpool, "Storage Volumes", virStoragePoolNumOfVolumes, virStoragePoolListVolumes, cancellable, &nvolumes, &lerr); if (lerr) { g_propagate_error(err, lerr); lerr = NULL; goto cleanup; } if (g_cancellable_set_error_if_cancelled(cancellable, err)) goto cleanup; vol_hash = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_object_unref); for (i = 0 ; i < nvolumes ; i++) { if (g_cancellable_set_error_if_cancelled(cancellable, err)) goto cleanup; virStorageVolPtr vvolume; GVirStorageVol *volume; vvolume = virStorageVolLookupByName(vpool, volumes[i]); if (!vvolume) continue; volume = GVIR_STORAGE_VOL(g_object_new(GVIR_TYPE_STORAGE_VOL, "handle", vvolume, "pool", pool, NULL)); virStorageVolFree(vvolume); g_hash_table_insert(vol_hash, g_strdup(volumes[i]), volume); } g_mutex_lock(priv->lock); if (priv->volumes) g_hash_table_unref(priv->volumes); priv->volumes = vol_hash; g_mutex_unlock(priv->lock); ret = TRUE; cleanup: for (i = 0 ; i < nvolumes ; i++) g_free(volumes[i]); g_free(volumes); return ret; }
static bool cmdVolDownload(vshControl *ctl, const vshCmd *cmd) { const char *file = NULL; virStorageVolPtr vol = NULL; bool ret = false; int fd = -1; virStreamPtr st = NULL; const char *name = NULL; unsigned long long offset = 0, length = 0; bool created = false; if (!vshConnectionUsability(ctl, ctl->conn)) return false; if (vshCommandOptULongLong(cmd, "offset", &offset) < 0) { vshError(ctl, _("Unable to parse integer")); return false; } if (vshCommandOptULongLong(cmd, "length", &length) < 0) { vshError(ctl, _("Unable to parse integer")); return false; } if (!(vol = vshCommandOptVol(ctl, cmd, "vol", "pool", &name))) return false; if (vshCommandOptString(cmd, "file", &file) < 0) { vshError(ctl, _("file must not be empty")); goto cleanup; } if ((fd = open(file, O_WRONLY|O_CREAT|O_EXCL, 0666)) < 0) { if (errno != EEXIST || (fd = open(file, O_WRONLY|O_TRUNC, 0666)) < 0) { vshError(ctl, _("cannot create %s"), file); goto cleanup; } } else { created = true; } st = virStreamNew(ctl->conn, 0); if (virStorageVolDownload(vol, st, offset, length, 0) < 0) { vshError(ctl, _("cannot download from volume %s"), name); goto cleanup; } if (virStreamRecvAll(st, vshStreamSink, &fd) < 0) { vshError(ctl, _("cannot receive data from volume %s"), name); goto cleanup; } if (VIR_CLOSE(fd) < 0) { vshError(ctl, _("cannot close file %s"), file); virStreamAbort(st); goto cleanup; } if (virStreamFinish(st) < 0) { vshError(ctl, _("cannot close volume %s"), name); goto cleanup; } ret = true; cleanup: VIR_FORCE_CLOSE(fd); if (!ret && created) unlink(file); if (vol) virStorageVolFree(vol); if (st) virStreamFree(st); return ret; }