const char *regfunc,
bool forceload)
{
- char *modfile = NULL;
- int ret;
+ VIR_AUTOFREE(char *) modfile = NULL;
if (!(modfile = virFileFindResourceFull(name,
"libvirt_storage_backend_",
"LIBVIRT_STORAGE_BACKEND_DIR")))
return -1;
- ret = virModuleLoad(modfile, regfunc, forceload);
-
- VIR_FREE(modfile);
-
- return ret;
+ return virModuleLoad(modfile, regfunc, forceload);
}
virStorageVolDefPtr vol)
{
virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
- char *tmp, *devpath, *partname;
+ char *tmp, *partname;
bool addVol = false;
+ VIR_AUTOFREE(char *) devpath = NULL;
/* Prepended path will be same for all partitions, so we can
* strip the path to form a reasonable pool-unique name
* way of doing this...
*/
vol->target.path = virStorageBackendStablePath(pool, devpath, true);
- VIR_FREE(devpath);
if (vol->target.path == NULL)
goto error;
}
*/
virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
- char *parthelper_path;
struct virStorageBackendDiskPoolVolData cbdata = {
.pool = pool,
.vol = vol,
};
- int ret;
+ VIR_AUTOFREE(char *) parthelper_path = NULL;
VIR_AUTOPTR(virCommand) cmd = NULL;
if (!(parthelper_path = virFileFindResource("libvirt_parthelper",
def->allocation = 0;
def->capacity = def->available = 0;
- ret = virCommandRunNul(cmd,
- 6,
- virStorageBackendDiskMakeVol,
- &cbdata);
- VIR_FREE(parthelper_path);
- return ret;
+ return virCommandRunNul(cmd, 6, virStorageBackendDiskMakeVol, &cbdata);
}
static int
virStorageBackendDiskReadGeometry(virStoragePoolObjPtr pool)
{
virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
- char *parthelper_path;
- int ret;
+ VIR_AUTOFREE(char *) parthelper_path = NULL;
VIR_AUTOPTR(virCommand) cmd = NULL;
if (!(parthelper_path = virFileFindResource("libvirt_parthelper",
"-g",
NULL);
- ret = virCommandRunNul(cmd,
- 3,
- virStorageBackendDiskMakePoolGeometry,
- pool);
- VIR_FREE(parthelper_path);
- return ret;
+ return virCommandRunNul(cmd, 3, virStorageBackendDiskMakePoolGeometry,
+ pool);
}
static int
unsigned int flags)
{
char *part_num = NULL;
- char *devpath = NULL;
char *dev_name;
virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
char *src_path = def->source.devices[0].path;
char *srcname = last_component(src_path);
bool isDevMapperDevice;
- int rc = -1;
+ VIR_AUTOFREE(char *) devpath = NULL;
VIR_AUTOPTR(virCommand) cmd = NULL;
virCheckFlags(0, -1);
virReportSystemError(errno,
_("Couldn't read volume target path '%s'"),
vol->target.path);
- goto cleanup;
+ return -1;
}
dev_name = last_component(devpath);
}
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Volume path '%s' did not start with parent "
"pool source device name."), dev_name);
- goto cleanup;
+ return -1;
}
part_num = dev_name + strlen(srcname);
virReportError(VIR_ERR_INTERNAL_ERROR,
_("cannot parse partition number from target "
"'%s'"), dev_name);
- goto cleanup;
+ return -1;
}
/* eg parted /dev/sda rm 2 or /dev/mapper/mpathc rm 2 */
part_num,
NULL);
if (virCommandRun(cmd, NULL) < 0)
- goto cleanup;
+ return -1;
/* Refreshing the pool is the easiest option as LOGICAL and EXTENDED
* partition allocation/capacity management is handled within
*/
virStoragePoolObjClearVols(pool);
if (virStorageBackendDiskRefreshPool(pool) < 0)
- goto cleanup;
+ return -1;
- rc = 0;
- cleanup:
- VIR_FREE(devpath);
- return rc;
+ return 0;
}
virStorageBackendDiskCreateVol(virStoragePoolObjPtr pool,
virStorageVolDefPtr vol)
{
- int res = -1;
- char *partFormat = NULL;
unsigned long long startOffset = 0, endOffset = 0;
virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
virErrorPtr save_err;
+ VIR_AUTOFREE(char *)partFormat = NULL;
VIR_AUTOPTR(virCommand) cmd = NULL;
cmd = virCommandNewArgList(PARTED,
vol->target.encryption->format != VIR_STORAGE_ENCRYPTION_FORMAT_LUKS) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("storage pool only supports LUKS encrypted volumes"));
- goto cleanup;
+ return -1;
}
if (virStorageBackendDiskPartFormat(pool, vol, &partFormat) != 0)
- goto cleanup;
+ return -1;
virCommandAddArg(cmd, partFormat);
/* If we're going to encrypt using LUKS, then we could need up to
if (virStorageBackendDiskPartBoundaries(pool, &startOffset, &endOffset,
vol->target.capacity) < 0)
- goto cleanup;
+ return -1;
virCommandAddArgFormat(cmd, "%lluB", startOffset);
virCommandAddArgFormat(cmd, "%lluB", endOffset);
if (virCommandRun(cmd, NULL) < 0)
- goto cleanup;
+ return -1;
/* wait for device node to show up */
virWaitForDevices();
goto error;
}
- res = 0;
-
- cleanup:
- VIR_FREE(partFormat);
- return res;
+ return 0;
error:
/* Best effort to remove the partition. Ignore any errors
ignore_value(virStorageBackendDiskDeleteVol(pool, vol, 0));
virSetError(save_err);
virFreeError(save_err);
- goto cleanup;
+ return -1;
}
{
int ret = -1;
virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
- char *src = NULL;
FILE *mtab;
struct mntent ent;
char buf[1024];
int rc1, rc2;
+ VIR_AUTOFREE(char *) src = NULL;
if ((mtab = fopen(_PATH_MOUNTED, "r")) == NULL) {
virReportSystemError(errno,
cleanup:
VIR_FORCE_FCLOSE(mtab);
- VIR_FREE(src);
return ret;
}
virStorageBackendFileSystemMount(virStoragePoolObjPtr pool)
{
virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
- char *src = NULL;
- int ret = -1;
int rc;
+ VIR_AUTOFREE(char *) src = NULL;
VIR_AUTOPTR(virCommand) cmd = NULL;
if (virStorageBackendFileSystemIsValid(pool) < 0)
return -1;
cmd = virStorageBackendFileSystemMountCmd(MOUNT, def, src);
- if (virCommandRun(cmd, NULL) < 0)
- goto cleanup;
-
- ret = 0;
- cleanup:
- VIR_FREE(src);
- return ret;
+ return virCommandRun(cmd, NULL);
}
void **data)
{
virStoragePoolFSMountOptionsDefPtr cmdopts = NULL;
- xmlNodePtr *nodes = NULL;
int nnodes;
size_t i;
int ret = -1;
+ VIR_AUTOFREE(xmlNodePtr *)nodes = NULL;
if (xmlXPathRegisterNs(ctxt, BAD_CAST "fs",
BAD_CAST STORAGE_POOL_FS_NAMESPACE_HREF) < 0) {
ret = 0;
cleanup:
- VIR_FREE(nodes);
virStoragePoolDefFSNamespaceFree(cmdopts);
return ret;
}
if (glfs_set_volfile_server(ret->vol, "tcp",
ret->uri->server, ret->uri->port) < 0 ||
glfs_init(ret->vol) < 0) {
- char *uri = virURIFormat(ret->uri);
-
- virReportSystemError(errno, _("failed to connect to %s"),
- NULLSTR(uri));
- VIR_FREE(uri);
+ VIR_AUTOFREE(char *) uri = NULL;
+ uri = virURIFormat(ret->uri);
+ virReportSystemError(errno, _("failed to connect to %s"), NULLSTR(uri));
goto error;
}
virStorageVolDefPtr vol,
const char *name)
{
- int ret = -1;
- char *path = NULL;
char *tmp;
+ VIR_AUTOFREE(char *) path = NULL;
VIR_FREE(vol->key);
VIR_FREE(vol->target.path);
if (name) {
VIR_FREE(vol->name);
if (VIR_STRDUP(vol->name, name) < 0)
- goto cleanup;
+ return -1;
}
if (virAsprintf(&path, "%s%s%s", state->volname, state->dir,
vol->name) < 0)
- goto cleanup;
+ return -1;
tmp = state->uri->path;
if (virAsprintf(&state->uri->path, "/%s", path) < 0) {
state->uri->path = tmp;
- goto cleanup;
+ return -1;
}
if (!(vol->target.path = virURIFormat(state->uri))) {
VIR_FREE(state->uri->path);
state->uri->path = tmp;
- goto cleanup;
+ return -1;
}
VIR_FREE(state->uri->path);
state->uri->path = tmp;
/* the path is unique enough to serve as a volume key */
if (VIR_STRDUP(vol->key, vol->target.path) < 0)
- goto cleanup;
-
- ret = 0;
+ return -1;
- cleanup:
- VIR_FREE(path);
- return ret;
+ return 0;
}
int ret = -1;
glfs_fd_t *fd = NULL;
virStorageSourcePtr meta = NULL;
- char *header = NULL;
ssize_t len;
int backingFormat;
VIR_AUTOPTR(virStorageVolDef) vol = NULL;
+ VIR_AUTOFREE(char *) header = NULL;
*volptr = NULL;
virStorageSourceFree(meta);
if (fd)
glfs_close(fd);
- VIR_FREE(header);
return ret;
}
virStorageBackendISCSIFindLUs(virStoragePoolObjPtr pool,
const char *session)
{
- char *sysfs_path;
- int retval = -1;
uint32_t host;
+ VIR_AUTOFREE(char *) sysfs_path = NULL;
if (virAsprintf(&sysfs_path,
"/sys/class/iscsi_session/session%s/device", session) < 0)
- goto cleanup;
+ return -1;
if (virStorageBackendISCSIGetHostNumber(sysfs_path, &host) < 0)
- goto cleanup;
+ return -1;
if (virStorageBackendSCSIFindLUs(pool, host) < 0)
- goto cleanup;
-
- retval = 0;
-
- cleanup:
-
- VIR_FREE(sysfs_path);
+ return -1;
- return retval;
+ return 0;
}
.nsources = 0,
.sources = NULL
};
- char *portal = NULL;
+ VIR_AUTOFREE(char *) portal = NULL;
VIR_AUTOPTR(virStoragePoolSource) source = NULL;
virCheckFlags(0, NULL);
for (i = 0; i < ntargets; i++)
VIR_FREE(targets[i]);
VIR_FREE(targets);
- VIR_FREE(portal);
return ret;
}
bool *isActive)
{
virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
- char *session = NULL;
int ret = -1;
+ VIR_AUTOFREE(char *) session = NULL;
*isActive = false;
return -1;
}
- if ((session = virStorageBackendISCSISession(pool, true)) != NULL) {
+ if ((session = virStorageBackendISCSISession(pool, true)))
*isActive = true;
- VIR_FREE(session);
- }
ret = 0;
return ret;
virStorageBackendISCSIStartPool(virStoragePoolObjPtr pool)
{
virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
- char *portal = NULL;
- char *session = NULL;
- int ret = -1;
+ VIR_AUTOFREE(char *) portal = NULL;
+ VIR_AUTOFREE(char *) session = NULL;
if (def->source.nhost != 1) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
if ((session = virStorageBackendISCSISession(pool, true)) == NULL) {
if ((portal = virStorageBackendISCSIPortal(&def->source)) == NULL)
- goto cleanup;
+ return -1;
/* Create a static node record for the IQN target. Must be done
* in order for login to the target */
if (virISCSINodeNew(portal, def->source.devices[0].path) < 0)
- goto cleanup;
+ return -1;
if (virStorageBackendISCSISetAuth(portal, &def->source) < 0)
- goto cleanup;
+ return -1;
if (virISCSIConnectionLogin(portal,
def->source.initiator.iqn,
def->source.devices[0].path) < 0)
- goto cleanup;
+ return -1;
}
- ret = 0;
-
- cleanup:
- VIR_FREE(portal);
- VIR_FREE(session);
- return ret;
+ return 0;
}
static int
virStorageBackendISCSIRefreshPool(virStoragePoolObjPtr pool)
{
virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
- char *session = NULL;
+ VIR_AUTOFREE(char *) session = NULL;
def->allocation = def->capacity = def->available = 0;
if ((session = virStorageBackendISCSISession(pool, false)) == NULL)
- goto cleanup;
+ return -1;
if (virISCSIRescanLUNs(session) < 0)
- goto cleanup;
+ return -1;
if (virStorageBackendISCSIFindLUs(pool, session) < 0)
- goto cleanup;
- VIR_FREE(session);
+ return -1;
return 0;
-
- cleanup:
- VIR_FREE(session);
- return -1;
}
virStorageBackendISCSIStopPool(virStoragePoolObjPtr pool)
{
virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
- char *portal;
- char *session;
- int ret = -1;
+ VIR_AUTOFREE(char *) portal = NULL;
+ VIR_AUTOFREE(char *) session = NULL;
if ((session = virStorageBackendISCSISession(pool, true)) == NULL)
return 0;
- VIR_FREE(session);
if ((portal = virStorageBackendISCSIPortal(&def->source)) == NULL)
return -1;
if (virISCSIConnectionLogout(portal,
def->source.initiator.iqn,
def->source.devices[0].path) < 0)
- goto cleanup;
- ret = 0;
+ return -1;
- cleanup:
- VIR_FREE(portal);
- return ret;
+ return 0;
}
virStorageBackend virStorageBackendISCSI = {
}
for (tmp_addr = addr; tmp_addr; tmp_addr = tmp_addr->next) {
- char *target = NULL;
+ VIR_AUTOFREE(char *) target = NULL;
if (VIR_STRDUP(target, tmp_addr->target_name) < 0)
goto cleanup;
- if (VIR_APPEND_ELEMENT(tmp_targets, tmp_ntargets, target) < 0) {
- VIR_FREE(target);
+ if (VIR_APPEND_ELEMENT(tmp_targets, tmp_ntargets, target) < 0)
goto cleanup;
- }
}
VIR_STEAL_PTR(*targets, tmp_targets);
.nsources = 0,
.sources = NULL
};
- char *portal = NULL;
+ VIR_AUTOFREE(char *) portal = NULL;
VIR_AUTOPTR(virStoragePoolSource) source = NULL;
virCheckFlags(0, NULL);
for (i = 0; i < ntargets; i++)
VIR_FREE(targets[i]);
VIR_FREE(targets);
- VIR_FREE(portal);
return ret;
}
{
virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
struct iscsi_context *iscsi = NULL;
- char *portal = NULL;
+ VIR_AUTOFREE(char *) portal = NULL;
if (!(iscsi = virISCSIDirectCreateContext(def->source.initiator.iqn)))
goto error;
VIR_STEAL_PTR(*portalRet, portal);
cleanup:
- VIR_FREE(portal);
return iscsi;
error:
virStorageBackendISCSIDirectRefreshPool(virStoragePoolObjPtr pool)
{
struct iscsi_context *iscsi = NULL;
- char *portal = NULL;
int ret = -1;
- if (!(iscsi = virStorageBackendISCSIDirectSetConnection(pool, &portal)))
- goto cleanup;
- if (virISCSIDirectReportLuns(pool, iscsi, portal) < 0)
- goto disconect;
+ VIR_AUTOFREE(char *) portal = NULL;
- ret = 0;
- disconect:
+ if (!(iscsi = virStorageBackendISCSIDirectSetConnection(pool, &portal)))
+ return -1;
+ ret = virISCSIDirectReportLuns(pool, iscsi, portal);
virISCSIDirectDisconnect(iscsi);
iscsi_destroy_context(iscsi);
- cleanup:
- VIR_FREE(portal);
return ret;
}
struct scsi_task *task = NULL;
int lun = 0;
int ret = -1;
- unsigned char *data;
+ VIR_AUTOFREE(unsigned char *) data = NULL;
if (virStorageBackendISCSIDirectGetLun(vol, &lun) < 0)
return ret;
if (!(task = iscsi_write10_sync(iscsi, lun, lba, data,
block_size * BLOCK_PER_PACKET,
block_size, 0, 0, 0, 0, 0)))
- goto cleanup;
+ return -1;
scsi_free_scsi_task(task);
lba += BLOCK_PER_PACKET;
} else {
if (!(task = iscsi_write10_sync(iscsi, lun, lba, data, block_size,
block_size, 0, 0, 0, 0, 0)))
- goto cleanup;
+ return -1;
scsi_free_scsi_task(task);
lba++;
}
}
- ret = 0;
- cleanup:
- VIR_FREE(data);
- return ret;
+ return 0;
}
static int
{
int nextents, ret = -1;
const char *regex_unit = "(\\S+)\\((\\S+)\\)";
- char *regex = NULL;
- regex_t *reg = NULL;
- regmatch_t *vars = NULL;
char *p = NULL;
size_t i;
int err, nvars;
unsigned long long offset, size, length;
virStorageVolSourceExtent extent;
+ VIR_AUTOFREE(char *) regex = NULL;
+ VIR_AUTOFREE(regex_t *) reg = NULL;
+ VIR_AUTOFREE(regmatch_t *) vars = NULL;
memset(&extent, 0, sizeof(extent));
for (i = 0; i < nextents; i++) {
size_t j;
int len;
- char *offset_str = NULL;
+ VIR_AUTOFREE(char *) offset_str = NULL;
j = (i * 2) + 1;
len = vars[j].rm_eo - vars[j].rm_so;
if (virStrToLong_ull(offset_str, NULL, 10, &offset) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("malformed volume extent offset value"));
- VIR_FREE(offset_str);
goto cleanup;
}
- VIR_FREE(offset_str);
extent.start = offset * size;
extent.end = (offset * size) + length;
ret = 0;
cleanup:
- VIR_FREE(regex);
- VIR_FREE(reg);
- VIR_FREE(vars);
VIR_FREE(extent.path);
return ret;
}
void *data)
{
virStoragePoolSourceListPtr sourceList = data;
- char *pvname = NULL;
- char *vgname = NULL;
- int retval = -1;
size_t i;
virStoragePoolSourceDevicePtr dev;
virStoragePoolSource *thisSource;
+ VIR_AUTOFREE(char *) pvname = NULL;
+ VIR_AUTOFREE(char *) vgname = NULL;
if (VIR_STRDUP(pvname, groups[0]) < 0 ||
VIR_STRDUP(vgname, groups[1]) < 0)
- goto error;
+ return -1;
thisSource = NULL;
for (i = 0; i < sourceList->nsources; i++) {
if (thisSource == NULL) {
if (!(thisSource = virStoragePoolSourceListNewSource(sourceList)))
- goto error;
+ return -1;
VIR_STEAL_PTR(thisSource->name, vgname);
}
if (VIR_REALLOC_N(thisSource->devices, thisSource->ndevice + 1) != 0)
- goto error;
+ return -1;
dev = &thisSource->devices[thisSource->ndevice];
thisSource->ndevice++;
memset(dev, 0, sizeof(*dev));
VIR_STEAL_PTR(dev->path, pvname);
- retval = 0;
-
- error:
- VIR_FREE(pvname);
- VIR_FREE(vgname);
-
- return retval;
+ return 0;
}
/*
virStorageBackendCreateVols(virStoragePoolObjPtr pool,
struct dm_names *names)
{
- int retval = -1, is_mpath = 0;
- char *map_device = NULL;
+ int is_mpath = 0;
uint32_t minor = -1;
uint32_t next;
+ VIR_AUTOFREE(char *) map_device = NULL;
do {
is_mpath = virStorageBackendIsMultipath(names->name);
if (is_mpath < 0)
- goto out;
+ return -1;
if (is_mpath == 1) {
if (virAsprintf(&map_device, "mapper/%s", names->name) < 0)
- goto out;
+ return -1;
if (virStorageBackendGetMinorNumber(names->name, &minor) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Failed to get %s minor number"),
names->name);
- goto out;
+ return -1;
}
if (virStorageBackendMpathNewVol(pool, minor, map_device) < 0)
- goto out;
+ return -1;
VIR_FREE(map_device);
}
} while (next);
- retval = 0;
- out:
- VIR_FREE(map_device);
- return retval;
+ return 0;
}
void **data)
{
virStoragePoolRBDConfigOptionsDefPtr cmdopts = NULL;
- xmlNodePtr *nodes = NULL;
int nnodes;
size_t i;
int ret = -1;
+ VIR_AUTOFREE(xmlNodePtr *)nodes = NULL;
if (xmlXPathRegisterNs(ctxt, BAD_CAST "rbd",
BAD_CAST STORAGE_POOL_RBD_NAMESPACE_HREF) < 0) {
ret = 0;
cleanup:
- VIR_FREE(nodes);
virStoragePoolDefRBDNamespaceFree(cmdopts);
return ret;
}
char *rados_key = NULL;
virBuffer mon_host = VIR_BUFFER_INITIALIZER;
size_t i;
- char *mon_buff = NULL;
const char *client_mount_timeout = "30";
const char *mon_op_timeout = "30";
const char *osd_op_timeout = "30";
const char *rbd_default_format = "2";
virConnectPtr conn = NULL;
+ VIR_AUTOFREE(char *) mon_buff = NULL;
if (authdef) {
VIR_DEBUG("Using cephx authorization, username: %s", authdef->username);
virObjectUnref(conn);
virBufferFreeAndReset(&mon_host);
- VIR_FREE(mon_buff);
return ret;
}
int ret = -1;
int len = -1;
int r = 0;
- char *name, *names = NULL;
+ char *name;
virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
virStorageBackendRBDStatePtr ptr = NULL;
struct rados_cluster_stat_t clusterstat;
struct rados_pool_stat_t poolstat;
+ VIR_AUTOFREE(char *) names = NULL;
if (!(ptr = virStorageBackendRBDNewState(pool)))
goto cleanup;
ret = 0;
cleanup:
- VIR_FREE(names);
virStorageBackendRBDFreeState(&ptr);
return ret;
}
int max_snaps = 128;
int snap_count, protected;
size_t i;
- rbd_snap_info_t *snaps = NULL;
rbd_image_t image = NULL;
+ VIR_AUTOFREE(rbd_snap_info_t *) snaps = NULL;
if ((r = rbd_open(ioctx, vol->name, &image, NULL)) < 0) {
virReportSystemError(-r, _("failed to open the RBD image '%s'"),
if (snaps)
rbd_snap_list_end(snaps);
- VIR_FREE(snaps);
-
if (image)
rbd_close(image);
int max_snaps = 128;
size_t i;
int diff;
- rbd_snap_info_t *snaps = NULL;
rbd_image_info_t info;
+ VIR_AUTOFREE(rbd_snap_info_t *) snaps = NULL;
if ((r = rbd_stat(image, &info, sizeof(info))) < 0) {
virReportSystemError(-r, _("failed to stat the RBD image %s"),
if (snaps)
rbd_snap_list_end(snaps);
- VIR_FREE(snaps);
-
return ret;
}
uint64_t stripe_count;
uint64_t stripe_unit;
virBuffer snapname = VIR_BUFFER_INITIALIZER;
- char *snapname_buff = NULL;
rbd_image_t image = NULL;
+ VIR_AUTOFREE(char *) snapname_buff = NULL;
if ((r = rbd_open(io, origvol, &image, NULL)) < 0) {
virReportSystemError(-r, _("failed to open the RBD image %s"),
cleanup:
virBufferFreeAndReset(&snapname);
- VIR_FREE(snapname_buff);
if (image)
rbd_close(image);
uint64_t stripe_count)
{
int r = -1;
- int ret = -1;
unsigned long long offset = 0;
unsigned long long length;
- char *writebuf;
+ VIR_AUTOFREE(char *) writebuf = NULL;
if (VIR_ALLOC_N(writebuf, info->obj_size * stripe_count) < 0)
- goto cleanup;
+ return -1;
while (offset < info->size) {
length = MIN((info->size - offset), (info->obj_size * stripe_count));
virReportSystemError(-r, _("writing %llu bytes failed on "
"RBD image %s at offset %llu"),
length, imgname, offset);
- goto cleanup;
+ return -1;
}
VIR_DEBUG("Wrote %llu bytes to RBD image %s at offset %llu",
offset += length;
}
- ret = 0;
-
- cleanup:
- VIR_FREE(writebuf);
-
- return ret;
+ return 0;
}
static int
{
int fd = -1;
int retval = -1;
- char *path = NULL;
+ VIR_AUTOFREE(char *) path = NULL;
VIR_DEBUG("Triggering rescan of host %d", host);
if (virAsprintf(&path, "%s/host%u/scan",
LINUX_SYSFS_SCSI_HOST_PREFIX, host) < 0)
- goto cleanup;
+ return -1;
VIR_DEBUG("Scan trigger path is '%s'", path);
cleanup:
VIR_FORCE_CLOSE(fd);
- VIR_FREE(path);
VIR_DEBUG("Rescan of host %d complete", host);
return retval;
}
getAdapterName(virStorageAdapterPtr adapter)
{
char *name = NULL;
- char *parentaddr = NULL;
if (adapter->type == VIR_STORAGE_ADAPTER_TYPE_SCSI_HOST) {
virStorageAdapterSCSIHostPtr scsi_host = &adapter->data.scsi_host;
addr->slot,
addr->function,
unique_id)))
- goto cleanup;
+ return NULL;
} else {
ignore_value(VIR_STRDUP(name, scsi_host->name));
}
}
}
- cleanup:
- VIR_FREE(parentaddr);
return name;
}
const char *parent_name)
{
unsigned int host_num;
- char *scsi_host_name = NULL;
- char *vhba_parent = NULL;
bool retval = false;
virConnectPtr conn = NULL;
+ VIR_AUTOFREE(char *) scsi_host_name = NULL;
+ VIR_AUTOFREE(char *) vhba_parent = NULL;
VIR_DEBUG("name=%s, parent_name=%s", name, parent_name);
cleanup:
virObjectUnref(conn);
- VIR_FREE(vhba_parent);
- VIR_FREE(scsi_host_name);
return retval;
}
const char *configFile,
virStorageAdapterFCHostPtr fchost)
{
- char *name = NULL;
virStoragePoolFCRefreshInfoPtr cbdata = NULL;
virThread thread;
- int ret = -1;
+ VIR_AUTOFREE(char *) name = NULL;
VIR_DEBUG("configFile='%s' parent='%s', wwnn='%s' wwpn='%s'",
NULLSTR(configFile), NULLSTR(fchost->parent),
*/
if ((name = virVHBAGetHostByWWN(NULL, fchost->wwnn, fchost->wwpn))) {
if (!(checkName(name)))
- goto cleanup;
+ return -1;
/* If a parent was provided, let's make sure the 'name' we've
* retrieved has the same parent. If not this will cause failure. */
if (!fchost->parent || checkParent(name, fchost->parent))
- ret = 0;
+ return 0;
- goto cleanup;
+ return -1;
}
/* Since we're creating the vHBA, then we need to manage removing it
fchost->managed = VIR_TRISTATE_BOOL_YES;
if (configFile) {
if (virStoragePoolSaveConfig(configFile, def) < 0)
- goto cleanup;
+ return -1;
}
}
if (!(name = virNodeDeviceCreateVport(fchost)))
- goto cleanup;
+ return -1;
/* Creating our own VPORT didn't leave enough time to find any LUN's,
* so, let's create a thread whose job it is to call the FindLU's with
}
}
- ret = 0;
-
- cleanup:
- VIR_FREE(name);
- return ret;
+ return 0;
}
bool *isActive)
{
virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
- char *path = NULL;
- char *name = NULL;
unsigned int host;
- int ret = -1;
+ VIR_AUTOFREE(char *) path = NULL;
+ VIR_AUTOFREE(char *) name = NULL;
*isActive = false;
}
if (virSCSIHostGetNumber(name, &host) < 0)
- goto cleanup;
+ return -1;
if (virAsprintf(&path, "%s/host%d",
LINUX_SYSFS_SCSI_HOST_PREFIX, host) < 0)
- goto cleanup;
+ return -1;
*isActive = virFileExists(path);
- ret = 0;
- cleanup:
- VIR_FREE(path);
- VIR_FREE(name);
- return ret;
+ return 0;
}
static int
virStorageBackendSCSIRefreshPool(virStoragePoolObjPtr pool)
{
virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
- char *name = NULL;
unsigned int host;
- int ret = -1;
+ VIR_AUTOFREE(char *) name = NULL;
def->allocation = def->capacity = def->available = 0;
return -1;
if (virSCSIHostGetNumber(name, &host) < 0)
- goto out;
+ return -1;
VIR_DEBUG("Scanning host%u", host);
if (virStorageBackendSCSITriggerRescan(host) < 0)
- goto out;
+ return -1;
if (virStorageBackendSCSIFindLUs(pool, host) < 0)
- goto out;
+ return -1;
- ret = 0;
- out:
- VIR_FREE(name);
- return ret;
+ return 0;
}
static int
virStorageBackendSheepdogRefreshAllVol(virStoragePoolObjPtr pool)
{
- int ret = -1;
- char *output = NULL;
size_t i;
+ VIR_AUTOFREE(char *) output = NULL;
VIR_AUTOPTR(virString) lines = NULL;
VIR_AUTOPTR(virString) cells = NULL;
VIR_AUTOPTR(virCommand) cmd = NULL;
virStorageBackendSheepdogAddHostArg(cmd, pool);
virCommandSetOutputBuffer(cmd, &output);
if (virCommandRun(cmd, NULL) < 0)
- goto cleanup;
+ return -1;
lines = virStringSplit(output, "\n", 0);
if (lines == NULL)
- goto cleanup;
+ return -1;
for (i = 0; lines[i]; i++) {
const char *line = lines[i];
if (cells != NULL &&
virStringListLength((const char * const *)cells) > 2) {
if (virStorageBackendSheepdogAddVolume(pool, cells[1]) < 0)
- goto cleanup;
+ return -1;
}
virStringListFree(cells);
cells = NULL;
}
- ret = 0;
-
- cleanup:
- VIR_FREE(output);
- return ret;
+ return 0;
}
static int
virStorageBackendSheepdogRefreshPool(virStoragePoolObjPtr pool)
{
- int ret = -1;
- char *output = NULL;
+ VIR_AUTOFREE(char *) output = NULL;
VIR_AUTOPTR(virCommand) cmd = NULL;
cmd = virCommandNewArgList(SHEEPDOGCLI, "node", "info", "-r", NULL);
virStorageBackendSheepdogAddHostArg(cmd, pool);
virCommandSetOutputBuffer(cmd, &output);
if (virCommandRun(cmd, NULL) < 0)
- goto cleanup;
+ return -1;
if (virStorageBackendSheepdogParseNodeInfo(virStoragePoolObjGetDef(pool),
output) < 0)
- goto cleanup;
+ return -1;
- ret = virStorageBackendSheepdogRefreshAllVol(pool);
- cleanup:
- VIR_FREE(output);
- return ret;
+ return virStorageBackendSheepdogRefreshAllVol(pool);
}
{
int ret = -1;
virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
- char *grp_name = NULL;
- char *usr_name = NULL;
- char *mode = NULL;
+ VIR_AUTOFREE(char *) grp_name = NULL;
+ VIR_AUTOFREE(char *) usr_name = NULL;
+ VIR_AUTOFREE(char *) mode = NULL;
VIR_AUTOPTR(virCommand) cmd = NULL;
/* Check the permissions */
/* Convert ids to names because vstorage uses names */
if (!(grp_name = virGetGroupName(def->target.perms.gid)))
- goto cleanup;
+ return -1;
if (!(usr_name = virGetUserName(def->target.perms.uid)))
- goto cleanup;
+ return -1;
if (virAsprintf(&mode, "%o", def->target.perms.mode) < 0)
- goto cleanup;
+ return -1;
cmd = virCommandNewArgList(VSTORAGE_MOUNT,
"-c", def->source.name,
"-g", grp_name, "-u", usr_name,
NULL);
- if (virCommandRun(cmd, NULL) < 0)
- goto cleanup;
- ret = 0;
-
- cleanup:
- VIR_FREE(mode);
- VIR_FREE(grp_name);
- VIR_FREE(usr_name);
- return ret;
+ return virCommandRun(cmd, NULL);
}
FILE *mtab;
struct mntent ent;
char buf[1024];
- char *cluster = NULL;
+ VIR_AUTOFREE(char *) cluster = NULL;
if (virAsprintf(&cluster, "vstorage://%s", def->source.name) < 0)
return -1;
cleanup:
VIR_FORCE_FCLOSE(mtab);
- VIR_FREE(cluster);
return ret;
}
virStorageBackendZFSVolModeNeeded(void)
{
int ret = -1, exit_code = -1;
- char *error = NULL;
+ VIR_AUTOFREE(char *) error = NULL;
VIR_AUTOPTR(virCommand) cmd = NULL;
/* 'zfs get' without arguments prints out
ret = 0;
cleanup:
- VIR_FREE(error);
return ret;
}
bool *isActive)
{
virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
- char *devpath;
+ VIR_AUTOFREE(char *) devpath = NULL;
if (virAsprintf(&devpath, "/dev/zvol/%s",
def->source.name) < 0)
return -1;
*isActive = virFileIsDir(devpath);
- VIR_FREE(devpath);
return 0;
}
virStorageVolDefPtr vol)
{
virStoragePoolDefPtr def = virStoragePoolObjGetDef(pool);
- char *volumes_list = NULL;
size_t i;
VIR_AUTOPTR(virString) lines = NULL;
VIR_AUTOPTR(virCommand) cmd = NULL;
+ VIR_AUTOFREE(char *) volumes_list = NULL;
/**
* $ zfs list -Hp -t volume -o name,volsize -r test
NULL);
virCommandSetOutputBuffer(cmd, &volumes_list);
if (virCommandRun(cmd, NULL) < 0)
- goto cleanup;
+ return -1;
if (!(lines = virStringSplit(volumes_list, "\n", 0)))
- goto cleanup;
+ return -1;
for (i = 0; lines[i]; i++) {
if (STREQ(lines[i], ""))
continue;
}
- cleanup:
- VIR_FREE(volumes_list);
-
return 0;
}
void *data)
{
virStorageFileBackendGlusterPrivPtr priv = data;
- char *buf = NULL;
size_t bufsiz = 0;
ssize_t ret;
struct stat st;
- int retval = -1;
+ VIR_AUTOFREE(char *) buf = NULL;
*linkpath = NULL;
realloc:
if (VIR_EXPAND_N(buf, bufsiz, 256) < 0)
- goto error;
+ return -1;
if ((ret = glfs_readlink(priv->vol, path, buf, bufsiz)) < 0) {
virReportSystemError(errno,
_("failed to read link of gluster file '%s'"),
path);
- goto error;
+ return -1;
}
if (ret == bufsiz)
VIR_STEAL_PTR(*linkpath, buf);
- retval = 0;
-
- error:
- VIR_FREE(buf);
- return retval;
+ return 0;
}
virStorageFileBackendGlusterGetUniqueIdentifier(virStorageSourcePtr src)
{
virStorageFileBackendGlusterPrivPtr priv = src->drv->priv;
- char *filePath = NULL;
+ VIR_AUTOFREE(char *) filePath = NULL;
if (priv->canonpath)
return priv->canonpath;
src->volume,
filePath));
- VIR_FREE(filePath);
-
return priv->canonpath;
}
projects / thirdparty / libvirt.git / commitdiff
