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;
}
