break;
}
- if (VIR_APPEND_ELEMENT(def->serials, def->nserials, chr) < 0) {
- virDomainChrDefFree(chr);
- goto error;
- }
+ VIR_APPEND_ELEMENT(def->serials, def->nserials, chr);
}
VIR_FREE(type);
disk->dst[2] = 'a' + idx;
- if (VIR_APPEND_ELEMENT(def->disks, def->ndisks, disk) < 0)
- goto error;
+ VIR_APPEND_ELEMENT(def->disks, def->ndisks, disk);
return 0;
if (!mac)
virDomainNetGenerateMAC(xmlopt, &net->mac);
- if (VIR_APPEND_ELEMENT(def->nets, def->nnets, net) < 0)
- goto error;
+ VIR_APPEND_ELEMENT(def->nets, def->nnets, net);
return 0;
error:
}
cleanup:
- if (VIR_APPEND_ELEMENT(def->videos, def->nvideos, video) < 0)
- goto error;
-
- if (VIR_APPEND_ELEMENT(def->graphics, def->ngraphics, graphics) < 0)
- goto error;
+ VIR_APPEND_ELEMENT(def->videos, def->nvideos, video);
+ VIR_APPEND_ELEMENT(def->graphics, def->ngraphics, graphics);
return 0;
node->id = bank->id;
node->cpus = virBitmapNewCopy(bank->cpus);
- if (VIR_APPEND_ELEMENT(caps->host.memBW.nodes,
- caps->host.memBW.nnodes, node) < 0) {
- goto cleanup;
- }
+ VIR_APPEND_ELEMENT(caps->host.memBW.nodes, caps->host.memBW.nnodes, node);
}
virCapsHostMemBWNodeFree(node);
node = NULL;
&bank->controls) < 0)
goto cleanup;
- if (VIR_APPEND_ELEMENT(caps->host.cache.banks,
- caps->host.cache.nbanks,
- bank) < 0) {
- goto cleanup;
- }
+ VIR_APPEND_ELEMENT(caps->host.cache.banks, caps->host.cache.nbanks, bank);
}
virCapsHostCacheBankFree(bank);
/* create the serial port definition from the console definition */
if (def->nserials == 0) {
- if (VIR_APPEND_ELEMENT(def->serials,
- def->nserials,
- def->consoles[0]) < 0)
- return -1;
+ VIR_APPEND_ELEMENT(def->serials, def->nserials, def->consoles[0]);
/* modify it to be a serial port */
def->serials[0]->deviceType = VIR_DOMAIN_CHR_DEVICE_TYPE_SERIAL;
goto cleanup;
for (i = 0; i < nnodes; i++) {
- if (!(ip = virDomainNetIPParseXML(nodes[i])) ||
- VIR_APPEND_ELEMENT(def->ips, def->nips, ip) < 0)
+ if (!(ip = virDomainNetIPParseXML(nodes[i])))
goto cleanup;
+
+ VIR_APPEND_ELEMENT(def->ips, def->nips, ip);
}
VIR_FREE(nodes);
goto cleanup;
for (i = 0; i < nnodes; i++) {
- if (!(route = virNetDevIPRouteParseXML(source, nodes[i], ctxt)) ||
- VIR_APPEND_ELEMENT(def->routes, def->nroutes, route) < 0)
+ if (!(route = virNetDevIPRouteParseXML(source, nodes[i], ctxt)))
goto cleanup;
+
+ VIR_APPEND_ELEMENT(def->routes, def->nroutes, route);
}
ret = 0;
goto error;
ipDef->prefix = prefix;
- if (VIR_APPEND_ELEMENT(def->guestIP.ips, def->guestIP.nips, ipDef) < 0)
- goto error;
+ VIR_APPEND_ELEMENT(def->guestIP.ips, def->guestIP.nips, ipDef);
return 0;
/* If no <listen/> element was found add a new one created by parsing
* <graphics/> element. */
if (def->nListens == 0) {
- if (VIR_APPEND_ELEMENT(def->listens, def->nListens, newListen) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(def->listens, def->nListens, newListen);
} else {
virDomainGraphicsListenDef *glisten = &def->listens[0];
int
virDomainHostdevInsert(virDomainDef *def, virDomainHostdevDef *hostdev)
{
- return VIR_APPEND_ELEMENT(def->hostdevs, def->nhostdevs, hostdev);
+ VIR_APPEND_ELEMENT(def->hostdevs, def->nhostdevs, hostdev);
+
+ return 0;
}
virDomainHostdevDef *
virDomainHostdevInsert(def, &net->data.hostdev.def) < 0)
return -1;
- if (VIR_APPEND_ELEMENT(def->nets, def->nnets, net) < 0) {
- /* virDomainHostdevInsert just appends new hostdevs, so we are sure
- * that the hostdev we've added a few lines above is at the end of
- * array. Although, devices are indexed from zero ... */
- virDomainHostdevRemove(def, def->nhostdevs - 1);
- return -1;
- }
+ VIR_APPEND_ELEMENT(def->nets, def->nnets, net);
return 0;
}
}
} else if (newhostdev) {
/* add newhostdev to end of def->hostdevs */
- if (VIR_APPEND_ELEMENT(def->hostdevs, def->nhostdevs, newhostdev) < 0)
- return -1;
+ VIR_APPEND_ELEMENT(def->hostdevs, def->nhostdevs, newhostdev);
}
def->nets[netidx] = newnet;
iface->addrs->addr = g_strdup(entry.ipaddr);
- if (VIR_APPEND_ELEMENT(ifaces_ret, ifaces_count, iface) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(ifaces_ret, ifaces_count, iface);
}
}
}
virDomainShmemDefInsert(virDomainDef *def,
virDomainShmemDef *shmem)
{
- return VIR_APPEND_ELEMENT(def->shmems, def->nshmems, shmem);
+ VIR_APPEND_ELEMENT(def->shmems, def->nshmems, shmem);
+
+ return 0;
}
input->type = type;
input->bus = bus;
- if (VIR_APPEND_ELEMENT(def->inputs, def->ninputs, input) < 0) {
- VIR_FREE(input);
- return -1;
- }
+ VIR_APPEND_ELEMENT(def->inputs, def->ninputs, input);
return 0;
}
if (virResctrlMonitorSetID(domresmon->instance, id) < 0)
goto cleanup;
- if (VIR_APPEND_ELEMENT(resctrl->monitors,
- resctrl->nmonitors,
- domresmon) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(resctrl->monitors, resctrl->nmonitors, domresmon);
VIR_FREE(id);
VIR_FREE(tmp);
goto cleanup;
}
- if (VIR_APPEND_ELEMENT(def->resctrls, def->nresctrls, resctrl) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(def->resctrls, def->nresctrls, resctrl);
ret = 0;
cleanup:
* only append the new @newresctrl object to domain if any of them is
* not zero. */
if (newresctrl && (nmons || n)) {
- if (VIR_APPEND_ELEMENT(def->resctrls, def->nresctrls, newresctrl) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(def->resctrls, def->nresctrls, newresctrl);
}
ret = 0;
if (!(video = virDomainVideoDefNew(xmlopt)))
return -1;
video->type = VIR_DOMAIN_VIDEO_TYPE_DEFAULT;
- if (VIR_APPEND_ELEMENT(def->videos, def->nvideos, video) < 0)
- return -1;
+ VIR_APPEND_ELEMENT(def->videos, def->nvideos, video);
return 0;
}
int
virDomainFSInsert(virDomainDef *def, virDomainFSDef *fs)
{
- return VIR_APPEND_ELEMENT(def->fss, def->nfss, fs);
+ VIR_APPEND_ELEMENT(def->fss, def->nfss, fs);
+
+ return 0;
}
virDomainFSDef *
if (virNetworkDHCPRangeDefParseXML(networkName, def, cur, &range) < 0)
goto cleanup;
- if (VIR_APPEND_ELEMENT(def->ranges, def->nranges, range) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(def->ranges, def->nranges, range);
} else if (cur->type == XML_ELEMENT_NODE &&
virXMLNodeNameEqual(cur, "host")) {
if (virNetworkDHCPHostDefParseXML(networkName, def, cur,
&host, false) < 0)
goto cleanup;
- if (VIR_APPEND_ELEMENT(def->hosts, def->nhosts, host) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(def->hosts, def->nhosts, host);
} else if (VIR_SOCKET_ADDR_IS_FAMILY(&def->address, AF_INET) &&
cur->type == XML_ELEMENT_NODE &&
virXMLNodeNameEqual(cur, "bootp")) {
networkName);
goto error;
}
- if (VIR_APPEND_ELEMENT(def->names, def->nnames, name) < 0)
- goto error;
+ VIR_APPEND_ELEMENT(def->names, def->nnames, name);
}
}
cur = cur->next;
type->name = virXPathString("string(./name)", ctxt);
- if (VIR_APPEND_ELEMENT(*mdev_types,
- *nmdev_types, type) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(*mdev_types, *nmdev_types, type);
}
ret = 0;
if (virPCIDeviceAddressParseXML(addrNodes[i], pciAddr) < 0)
return -1;
- if (VIR_APPEND_ELEMENT(pci_dev->iommuGroupDevices,
- pci_dev->nIommuGroupDevices,
- pciAddr) < 0)
- return -1;
+ VIR_APPEND_ELEMENT(pci_dev->iommuGroupDevices,
+ pci_dev->nIommuGroupDevices,
+ pciAddr);
}
return 0;
if (virPCIDeviceAddressParseXML(addresses[i], addr) < 0)
return -1;
- if (VIR_APPEND_ELEMENT(pci_dev->virtual_functions,
- pci_dev->num_virtual_functions,
- addr) < 0)
- return -1;
+ VIR_APPEND_ELEMENT(pci_dev->virtual_functions,
+ pci_dev->num_virtual_functions,
+ addr);
}
pci_dev->flags |= VIR_NODE_DEV_CAP_FLAG_PCI_VIRTUAL_FUNCTION;
return -1;
}
- return VIR_APPEND_ELEMENT(mdev->attributes,
- mdev->nattributes,
- attr);
+ VIR_APPEND_ELEMENT(mdev->attributes, mdev->nattributes, attr);
+
+ return 0;
}
static int
cb->filter_opaque = filter_opaque;
cb->legacy = legacy;
- if (VIR_APPEND_ELEMENT(cbList->callbacks, cbList->count, cb) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(cbList->callbacks, cbList->count, cb);
/* When additional filtering is being done, every client callback
* is matched to exactly one server callback. */
ret++;
}
- cleanup:
virObjectEventCallbackFree(cb);
return ret;
}
if (!evtQueue)
return -1;
- if (VIR_APPEND_ELEMENT(evtQueue->events, evtQueue->count, event) < 0)
- return -1;
+ VIR_APPEND_ELEMENT(evtQueue->events, evtQueue->count, event);
+
return 0;
}
return -1;
}
- if (VIR_APPEND_ELEMENT(source->devices, source->ndevice, dev) < 0) {
- virStoragePoolSourceDeviceClear(&dev);
- return -1;
- }
-
+ VIR_APPEND_ELEMENT(source->devices, source->ndevice, dev);
}
sourcedir = virXPathString("string(./dir/@path)", ctxt);
virObjectRef(vm);
- if (VIR_APPEND_ELEMENT(*vms, *nvms, vm) < 0) {
- virObjectRWUnlock(domlist);
- virObjectUnref(vm);
- goto error;
- }
+ VIR_APPEND_ELEMENT(*vms, *nvms, vm);
}
virObjectRWUnlock(domlist);
return -1;
}
- if (VIR_APPEND_ELEMENT(map->vendors, map->nvendors, vendor) < 0)
- return -1;
+ VIR_APPEND_ELEMENT(map->vendors, map->nvendors, vendor);
return 0;
}
return -1;
}
- if (VIR_APPEND_ELEMENT(map->models, map->nmodels, model) < 0)
- return -1;
+ VIR_APPEND_ELEMENT(map->models, map->nmodels, model);
return 0;
}
return -1;
}
- if (VIR_APPEND_ELEMENT(map->vendors, map->nvendors, vendor) < 0)
- return -1;
+ VIR_APPEND_ELEMENT(map->vendors, map->nvendors, vendor);
return 0;
}
model->data.pvr[i].mask = pvr;
}
- if (VIR_APPEND_ELEMENT(map->models, map->nmodels, model) < 0)
- return -1;
+ VIR_APPEND_ELEMENT(map->models, map->nmodels, model);
return 0;
}
if (virCPUx86VendorToData(string, &vendor->data) < 0)
return -1;
- if (VIR_APPEND_ELEMENT(map->vendors, map->nvendors, vendor) < 0)
- return -1;
+ VIR_APPEND_ELEMENT(map->vendors, map->nvendors, vendor);
return 0;
}
if (!feature->migratable)
VIR_APPEND_ELEMENT_COPY(map->migrate_blockers, map->nblockers, feature);
- if (VIR_APPEND_ELEMENT(map->features, map->nfeatures, feature) < 0)
- return -1;
+ VIR_APPEND_ELEMENT(map->features, map->nfeatures, feature);
return 0;
}
if (x86ModelParseFeatures(model, ctxt, map) < 0)
return -1;
- if (VIR_APPEND_ELEMENT(map->models, map->nmodels, model) < 0)
- return -1;
+ VIR_APPEND_ELEMENT(map->models, map->nmodels, model);
return 0;
}
else if (ret == 0)
continue;
- if (VIR_APPEND_ELEMENT(iface->addrs, addrs_count, ip_addr) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(iface->addrs, addrs_count, ip_addr);
}
} else {
esxVI_String *str;
else if (ret == 0)
continue;
- if (VIR_APPEND_ELEMENT(iface->addrs, addrs_count, ip_addr) < 0)
- goto cleanup;
-
+ VIR_APPEND_ELEMENT(iface->addrs, addrs_count, ip_addr);
}
}
virNetworkPtr net = virtualswitchToNetwork(conn, hostVirtualSwitch);
if (!net)
goto cleanup;
- if (VIR_APPEND_ELEMENT(*nets, count, net) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(*nets, count, net);
} else {
++count;
}
controller->idx = idx;
- if (VIR_APPEND_ELEMENT(def->controllers, def->ncontrollers, controller) < 0)
- return -1;
+ VIR_APPEND_ELEMENT(def->controllers, def->ncontrollers, controller);
return 0;
}
disk->info.addr.drive.target = 0;
disk->info.addr.drive.unit = addr;
- if (VIR_APPEND_ELEMENT(def->disks, def->ndisks, disk) < 0)
- return -1;
+ VIR_APPEND_ELEMENT(def->disks, def->ndisks, disk);
return 0;
}
disk->bus = VIR_DOMAIN_DISK_BUS_FDC;
disk->dst = g_strdup("fda");
- if (VIR_APPEND_ELEMENT(def->disks, def->ndisks, disk) < 0)
- return -1;
+ VIR_APPEND_ELEMENT(def->disks, def->ndisks, disk);
return 0;
}
disk->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DRIVE;
- if (VIR_APPEND_ELEMENT(def->disks, def->ndisks, disk) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(def->disks, def->ndisks, disk);
result = 0;
serial->source->data.file.path = g_strdup(srcPath);
- if (VIR_APPEND_ELEMENT(def->serials, def->nserials, serial) < 0) {
- virDomainChrDefFree(serial);
- return -1;
- }
+ VIR_APPEND_ELEMENT(def->serials, def->nserials, serial);
}
return 0;
/* get bridge name */
ndef->data.bridge.brname = g_strdup(vSwitch->data->Name);
- if (VIR_APPEND_ELEMENT(def->nets, def->nnets, ndef) < 0) {
- virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("Could not append definition to domain"));
- return -1;
- }
+ VIR_APPEND_ELEMENT(def->nets, def->nnets, ndef);
return 0;
}
virNetworkPtr net = hypervMsvmVirtualSwitchToNetwork(conn, entry);
if (!net)
goto cleanup;
- if (VIR_APPEND_ELEMENT(*nets, count, net) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(*nets, count, net);
} else {
++count;
}
if (!(hostdev = xenParsePCI(entry)))
return -1;
- if (VIR_APPEND_ELEMENT(def->hostdevs, def->nhostdevs, hostdev) < 0) {
- virDomainHostdevDefFree(hostdev);
- return -1;
- }
+ VIR_APPEND_ELEMENT(def->hostdevs, def->nhostdevs, hostdev);
}
return 0;
goto cleanup;
chr->deviceType = VIR_DOMAIN_CHR_DEVICE_TYPE_SERIAL;
chr->target.port = portnum;
- if (VIR_APPEND_ELEMENT(def->serials, def->nserials, chr) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(def->serials, def->nserials, chr);
}
} else {
g_autofree char *serial = NULL;
for (list = list->list; list; list = list->next) {
virDomainNetDef *net = NULL;
- int rc;
if ((list->type != VIR_CONF_STRING) || (list->str == NULL))
continue;
if (!(net = xenParseVif(list->str, vif_typename)))
return -1;
- rc = VIR_APPEND_ELEMENT(def->nets, def->nnets, net);
- if (rc < 0) {
- virDomainNetDefFree(net);
- return -1;
- }
+ VIR_APPEND_ELEMENT(def->nets, def->nnets, net);
}
return 0;
snddef = g_new0(virDomainSoundDef, 1);
snddef->model = model;
- ignore_value(VIR_APPEND_ELEMENT(def->sounds, def->nsounds, snddef));
+ VIR_APPEND_ELEMENT(def->sounds, def->nsounds, snddef);
if (!next)
break;
else
disk->bus = VIR_DOMAIN_DISK_BUS_IDE;
- if (VIR_APPEND_ELEMENT(def->disks, def->ndisks, disk) < 0)
- goto fail;
+ VIR_APPEND_ELEMENT(def->disks, def->ndisks, disk);
libxl_device_disk_dispose(libxldisk);
input->type = VIR_DOMAIN_INPUT_TYPE_TABLET;
else if (STREQ(str, "keyboard"))
input->type = VIR_DOMAIN_INPUT_TYPE_KBD;
- if (VIR_APPEND_ELEMENT(def->inputs, def->ninputs, input) < 0) {
- virDomainInputDefFree(input);
- return -1;
- }
+ VIR_APPEND_ELEMENT(def->inputs, def->ninputs, input);
}
val = val->next;
}
controller->model = usbctrl_type;
controller->opts.usbopts.ports = usbctrl_ports;
- if (VIR_APPEND_ELEMENT(def->controllers, def->ncontrollers, controller) < 0) {
- virDomainControllerDefFree(controller);
- return -1;
- }
+ VIR_APPEND_ELEMENT(def->controllers, def->ncontrollers, controller);
skipusbctrl:
list = list->next;
hostdev->source.subsys.u.usb.bus = busNum;
hostdev->source.subsys.u.usb.device = devNum;
- if (VIR_APPEND_ELEMENT(def->hostdevs, def->nhostdevs, hostdev) < 0) {
- virDomainHostdevDefFree(hostdev);
- return -1;
- }
+ VIR_APPEND_ELEMENT(def->hostdevs, def->nhostdevs, hostdev);
skipusb:
list = list->next;
channel->targetType = VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_XEN;
channel->target.name = g_steal_pointer(&name);
- if (VIR_APPEND_ELEMENT(def->channels, def->nchannels, channel) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(def->channels, def->nchannels, channel);
skipchannel:
list = list->next;
continue;
/* Maintain list in sorted order according to target device name */
- rc = VIR_APPEND_ELEMENT(def->disks, def->ndisks, disk);
- virDomainDiskDefFree(disk);
-
- if (rc < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(def->disks, def->ndisks, disk);
}
ret = 0;
- cleanup:
g_strfreev(disks);
return ret;
}
input->type = VIR_DOMAIN_INPUT_TYPE_TABLET;
else if (STREQ(str, "keyboard"))
input->type = VIR_DOMAIN_INPUT_TYPE_KBD;
- if (VIR_APPEND_ELEMENT(def->inputs, def->ninputs, input) < 0) {
- virDomainInputDefFree(input);
- return -1;
- }
+ VIR_APPEND_ELEMENT(def->inputs, def->ninputs, input);
}
}
return 0;
tmp = g_strdup(mntent.mnt_dir);
- if (VIR_APPEND_ELEMENT(mounts, nmounts, tmp) < 0) {
- g_free(tmp);
- goto cleanup;
- }
+ VIR_APPEND_ELEMENT(mounts, nmounts, tmp);
}
if (!mounts) {
return -1;
for (i = 0; i < npids; i++) {
- if (VIR_APPEND_ELEMENT(ctrl->nbdpids, ctrl->nnbdpids, pids[i]) < 0)
- return -1;
+ VIR_APPEND_ELEMENT(ctrl->nbdpids, ctrl->nnbdpids, pids[i]);
}
return 0;
0, false)))
return -1;
- if (VIR_APPEND_ELEMENT(*routes, *nroutes, route) < 0)
- return -1;
+ VIR_APPEND_ELEMENT(*routes, *nroutes, route);
return 0;
}
g_strfreev(ipparts);
- if (VIR_APPEND_ELEMENT(parseData->ips, parseData->nips, ip) < 0)
- return -1;
+ VIR_APPEND_ELEMENT(parseData->ips, parseData->nips, ip);
return 0;
}
lease->clientid = g_strdup(virJSONValueObjectGetString(lease_tmp, "client-id"));
lease->hostname = g_strdup(virJSONValueObjectGetString(lease_tmp, "hostname"));
- if (VIR_APPEND_ELEMENT(leases_ret, nleases, lease) < 0)
- goto cleanup;
-
+ VIR_APPEND_ELEMENT(leases_ret, nleases, lease);
} else {
nleases++;
}
goto error;
}
- if (VIR_APPEND_ELEMENT(outdevs, noutdevs, child) < 0)
- goto error;
+ VIR_APPEND_ELEMENT(outdevs, noutdevs, child);
}
}
inst->protoidx = idx;
inst->filtername = filter_names[i].key;
- if (VIR_APPEND_ELEMENT(*insts, *ninsts, inst) < 0)
- return -1;
+ VIR_APPEND_ELEMENT(*insts, *ninsts, inst);
}
return 0;
if (virNWFilterHashTablePutAll(vars, ruleinst->vars) < 0)
goto cleanup;
- if (VIR_APPEND_ELEMENT(inst->rules,
- inst->nrules,
- ruleinst) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(inst->rules, inst->nrules, ruleinst);
ret = 0;
cleanup:
break;
}
- if (VIR_APPEND_ELEMENT(inst->filters,
- inst->nfilters,
- obj) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(inst->filters, inst->nfilters, obj);
obj = NULL;
if (virNWFilterDefToInst(driver,
}
}
- if (VIR_APPEND_ELEMENT(def->fss, def->nfss, fs) < 0)
- goto error;
+ VIR_APPEND_ELEMENT(def->fss, def->nfss, fs);
VIR_FREE(temp);
if (!(backend = qemuBlockStorageSourceDetachPrepare(n, NULL)))
return NULL;
- if (VIR_APPEND_ELEMENT(data->srcdata, data->nsrcdata, backend) < 0)
- return NULL;
+ VIR_APPEND_ELEMENT(data->srcdata, data->nsrcdata, backend);
}
return g_steal_pointer(&data);
if (!(backend = qemuBlockStorageSourceDetachPrepare(src, driveAlias)))
return NULL;
- if (VIR_APPEND_ELEMENT(data->srcdata, data->nsrcdata, backend) < 0)
- return NULL;
+ VIR_APPEND_ELEMENT(data->srcdata, data->nsrcdata, backend);
return g_steal_pointer(&data);
}
backend->chardevAlias = chardevAlias;
backend->chardevAdded = true;
- if (VIR_APPEND_ELEMENT(data->srcdata, data->nsrcdata, backend) < 0)
- return NULL;
+ VIR_APPEND_ELEMENT(data->srcdata, data->nsrcdata, backend);
return g_steal_pointer(&data);
}
*/
if (driver->privileged && nicindexes && nnicindexes &&
net->ifname) {
- if (virNetDevGetIndex(net->ifname, &nicindex) < 0 ||
- VIR_APPEND_ELEMENT(*nicindexes, *nnicindexes, nicindex) < 0)
+ if (virNetDevGetIndex(net->ifname, &nicindex) < 0)
goto cleanup;
+
+ VIR_APPEND_ELEMENT(*nicindexes, *nnicindexes, nicindex);
}
break;
}
if (qemuBuildStorageSourceAttachPrepareCommon(disk->src, elem, qemuCaps) < 0)
return NULL;
- if (VIR_APPEND_ELEMENT(data->srcdata, data->nsrcdata, elem) < 0)
- return NULL;
+ VIR_APPEND_ELEMENT(data->srcdata, data->nsrcdata, elem);
return g_steal_pointer(&data);
}
if (!(elem = qemuBuildStorageSourceAttachPrepareChardev(disk)))
return NULL;
- if (VIR_APPEND_ELEMENT(data->srcdata, data->nsrcdata, elem) < 0)
- return NULL;
+ VIR_APPEND_ELEMENT(data->srcdata, data->nsrcdata, elem);
return g_steal_pointer(&data);
}
if (qemuBuildStorageSourceAttachPrepareCommon(src, elem, qemuCaps) < 0)
return -1;
- if (VIR_APPEND_ELEMENT(data->srcdata, data->nsrcdata, elem) < 0)
- return -1;
+ VIR_APPEND_ELEMENT(data->srcdata, data->nsrcdata, elem);
return 0;
}
hub = g_new0(virDomainHubDef, 1);
hub->type = VIR_DOMAIN_HUB_TYPE_USB;
- if (VIR_APPEND_ELEMENT(def->hubs, def->nhubs, hub) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(def->hubs, def->nhubs, hub);
}
ret = 0;
- cleanup:
VIR_FREE(hub);
return ret;
}
case VIR_DOMAIN_DEVICE_SOUND:
sound = dev->data.sound;
- if (VIR_APPEND_ELEMENT(vmdef->sounds, vmdef->nsounds, sound) < 0)
- return -1;
+ VIR_APPEND_ELEMENT(vmdef->sounds, vmdef->nsounds, sound);
dev->data.sound = NULL;
break;
return -1;
}
- if (VIR_APPEND_ELEMENT(vmdef->rngs, vmdef->nrngs, dev->data.rng) < 0)
- return -1;
+ VIR_APPEND_ELEMENT(vmdef->rngs, vmdef->nrngs, dev->data.rng);
dev->data.rng = NULL;
break;
case VIR_DOMAIN_DEVICE_REDIRDEV:
redirdev = dev->data.redirdev;
- if (VIR_APPEND_ELEMENT(vmdef->redirdevs, vmdef->nredirdevs, redirdev) < 0)
- return -1;
+ VIR_APPEND_ELEMENT(vmdef->redirdevs, vmdef->nredirdevs, redirdev);
dev->data.redirdev = NULL;
break;
break;
case VIR_DOMAIN_DEVICE_INPUT:
- if (VIR_APPEND_ELEMENT(vmdef->inputs, vmdef->ninputs, dev->data.input) < 0)
- return -1;
+ VIR_APPEND_ELEMENT(vmdef->inputs, vmdef->ninputs, dev->data.input);
break;
case VIR_DOMAIN_DEVICE_VSOCK:
&res->stats, &res->nstats) < 0)
goto error;
- if (VIR_APPEND_ELEMENT(*resdata, *nresdata, res) < 0)
- goto error;
+ VIR_APPEND_ELEMENT(*resdata, *nresdata, res);
}
}
tmp->name = g_strdup(fwpath);
tmp->nvram = g_strdup(nvrampath);
- if (VIR_APPEND_ELEMENT(*fws, *nfws, tmp) < 0)
- return -1;
+ VIR_APPEND_ELEMENT(*fws, *nfws, tmp);
}
}
}
if (!(job = qemuMonitorJSONGetJobInfoOne(virJSONValueArrayGet(data, i))))
return -1;
- if (VIR_APPEND_ELEMENT(*jobs, *njobs, job) < 0)
- return -1;
+ VIR_APPEND_ELEMENT(*jobs, *njobs, job);
}
return 0;
g_free(next);
next = g_strdup(item.target);
- if (addToData &&
- VIR_APPEND_ELEMENT(data->items, data->nitems, item) < 0)
- return -1;
+ if (addToData)
+ VIR_APPEND_ELEMENT(data->items, data->nitems, item);
if (!isLink)
break;
vcpupriv->vcpus != 0) {
vcpupriv->alias = g_strdup_printf("vcpu%zu", i);
- if (VIR_APPEND_ELEMENT(bootHotplug, nbootHotplug, vcpu) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(bootHotplug, nbootHotplug, vcpu);
}
}
callback->callbackID = -1;
callback->legacy = true;
ref = callback;
- if (VIR_APPEND_ELEMENT(priv->domainEventCallbacks,
- priv->ndomainEventCallbacks,
- callback) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(priv->domainEventCallbacks,
+ priv->ndomainEventCallbacks,
+ callback);
if ((callbackID = virConnectDomainEventRegisterAny(conn,
NULL,
callback->callbackID = -1;
callback->legacy = true;
ref = callback;
- if (VIR_APPEND_ELEMENT(priv->domainEventCallbacks,
- priv->ndomainEventCallbacks,
- callback) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(priv->domainEventCallbacks,
+ priv->ndomainEventCallbacks,
+ callback);
if ((callbackID = virConnectDomainEventRegisterAny(conn,
NULL,
callback->eventID = args->eventID;
callback->callbackID = -1;
ref = callback;
- if (VIR_APPEND_ELEMENT(priv->domainEventCallbacks,
- priv->ndomainEventCallbacks,
- callback) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(priv->domainEventCallbacks,
+ priv->ndomainEventCallbacks,
+ callback);
if ((callbackID = virConnectDomainEventRegisterAny(conn,
dom,
callback->eventID = args->eventID;
callback->callbackID = -1;
ref = callback;
- if (VIR_APPEND_ELEMENT(priv->networkEventCallbacks,
- priv->nnetworkEventCallbacks,
- callback) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(priv->networkEventCallbacks,
+ priv->nnetworkEventCallbacks,
+ callback);
if ((callbackID = virConnectNetworkEventRegisterAny(conn,
net,
callback->eventID = args->eventID;
callback->callbackID = -1;
ref = callback;
- if (VIR_APPEND_ELEMENT(priv->storageEventCallbacks,
- priv->nstorageEventCallbacks,
- callback) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(priv->storageEventCallbacks,
+ priv->nstorageEventCallbacks,
+ callback);
if ((callbackID = virConnectStoragePoolEventRegisterAny(conn,
pool,
callback->eventID = args->eventID;
callback->callbackID = -1;
ref = callback;
- if (VIR_APPEND_ELEMENT(priv->nodeDeviceEventCallbacks,
- priv->nnodeDeviceEventCallbacks,
- callback) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(priv->nodeDeviceEventCallbacks,
+ priv->nnodeDeviceEventCallbacks,
+ callback);
if ((callbackID = virConnectNodeDeviceEventRegisterAny(conn,
dev,
callback->eventID = args->eventID;
callback->callbackID = -1;
ref = callback;
- if (VIR_APPEND_ELEMENT(priv->secretEventCallbacks,
- priv->nsecretEventCallbacks,
- callback) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(priv->secretEventCallbacks,
+ priv->nsecretEventCallbacks,
+ callback);
if ((callbackID = virConnectSecretEventRegisterAny(conn,
secret,
callback->eventID = -1;
callback->callbackID = -1;
ref = callback;
- if (VIR_APPEND_ELEMENT(priv->qemuEventCallbacks,
- priv->nqemuEventCallbacks,
- callback) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(priv->qemuEventCallbacks,
+ priv->nqemuEventCallbacks,
+ callback);
if ((callbackID = virConnectDomainQemuMonitorEventRegister(conn,
dom,
if (!srv)
return -1;
- return VIR_APPEND_ELEMENT(*data->servers, data->nservers, srv);
+ VIR_APPEND_ELEMENT(*data->servers, data->nservers, srv);
+
+ return 0;
}
newfd);
goto error;
}
- if (VIR_APPEND_ELEMENT(msg->fds, msg->nfds, newfd) < 0)
- goto error;
+ VIR_APPEND_ELEMENT(msg->fds, msg->nfds, newfd);
return 0;
error:
VIR_FORCE_CLOSE(newfd);
for (i = 0; i < srv->nclients; i++) {
virNetServerClient *client = virObjectRef(srv->clients[i]);
- if (VIR_APPEND_ELEMENT(list, nclients, client) < 0) {
- virObjectUnref(client);
- goto cleanup;
- }
+ VIR_APPEND_ELEMENT(list, nclients, client);
}
*clts = g_steal_pointer(&list);
ret = nclients;
- cleanup:
virObjectListFreeCount(list, nclients);
virObjectUnlock(srv);
return ret;
item->remember = remember;
item->restore = restore;
- if (VIR_APPEND_ELEMENT(list->items, list->nItems, item) < 0)
- return -1;
+ VIR_APPEND_ELEMENT(list->items, list->nItems, item);
return 0;
}
} else {
/* The seclabel must be added to @vm prior calling domainGenSecurityLabel
* which may require seclabel to be presented already */
- if (generated &&
- VIR_APPEND_ELEMENT(vm->seclabels, vm->nseclabels, seclabel) < 0)
- goto cleanup;
+ if (generated)
+ VIR_APPEND_ELEMENT(vm->seclabels, vm->nseclabels, seclabel);
if (sec_managers[i]->drv->domainGenSecurityLabel(sec_managers[i], vm) < 0) {
if (VIR_DELETE_ELEMENT(vm->seclabels,
item->remember = remember;
item->restore = restore;
- if (VIR_APPEND_ELEMENT(list->items, list->nItems, item) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(list->items, list->nItems, item);
ret = 0;
- cleanup:
virSecuritySELinuxContextItemFree(item);
return ret;
}
if (!disk_seclabel)
return -1;
disk_seclabel->labelskip = true;
- if (VIR_APPEND_ELEMENT(src->seclabels, src->nseclabels,
- disk_seclabel) < 0) {
- virSecurityDeviceLabelDefFree(disk_seclabel);
- return -1;
- }
+ VIR_APPEND_ELEMENT(src->seclabels, src->nseclabels, disk_seclabel);
ret = 0;
}
extent.start = offset * size;
extent.end = (offset * size) + length;
- if (VIR_APPEND_ELEMENT(vol->source.extents, vol->source.nextent,
- extent) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(vol->source.extents, vol->source.nextent, extent);
}
ret = 0;
namedup = g_strdup(name);
- if (VIR_APPEND_ELEMENT(names, nnames, namedup) < 0)
- return NULL;
+ VIR_APPEND_ELEMENT(names, nnames, namedup);
name += strlen(name) + 1;
}
* necessary memory re-allocation has already been done.
*
* These macros are safe to use on arguments with side effects.
- *
- * Returns -1 on failure (with OOM error reported), 0 on success
*/
#define VIR_APPEND_ELEMENT(ptr, count, newelem) \
- virInsertElementsN(&(ptr), sizeof(*(ptr)), -1, &(count), \
- VIR_TYPEMATCH(ptr, &(newelem)), &(newelem), true, false)
+ virAppendElement(&(ptr), sizeof(*(ptr)), &(count), \
+ VIR_TYPEMATCH(ptr, &(newelem)), &(newelem), true, false)
#define VIR_APPEND_ELEMENT_COPY(ptr, count, newelem) \
virAppendElement(&(ptr), sizeof(*(ptr)), &(count), \
VIR_TYPEMATCH(ptr, &(newelem)), &(newelem), false, false)
target = g_strdup(groups[1]);
- if (VIR_APPEND_ELEMENT(list->targets, list->ntargets, target) < 0)
- return -1;
+ VIR_APPEND_ELEMENT(list->targets, list->ntargets, target);
return 0;
}
ret = VIR_INSERT_ELEMENT(object->data.object.pairs, 0,
object->data.object.npairs, pair);
} else {
- ret = VIR_APPEND_ELEMENT(object->data.object.pairs,
- object->data.object.npairs, pair);
+ VIR_APPEND_ELEMENT(object->data.object.pairs,
+ object->data.object.npairs, pair);
+ ret = 0;
}
if (ret == 0)
* lose the old entry
*/
at = virLogFindOutput(list, noutputs, output->dest, output->name);
- if (VIR_APPEND_ELEMENT(list, noutputs, output) < 0) {
- virLogOutputFree(output);
- return -1;
- }
+ VIR_APPEND_ELEMENT(list, noutputs, output);
if (at >= 0) {
virLogOutputFree(list[at]);
VIR_DELETE_ELEMENT(list, at, noutputs);
if (!(filter = virLogParseFilter(*next)))
return -1;
- if (VIR_APPEND_ELEMENT(list, nfilters, filter)) {
- virLogFilterFree(filter);
- return -1;
- }
+ VIR_APPEND_ELEMENT(list, nfilters, filter);
}
*filters = g_steal_pointer(&list);
_("device %s is already in use"), (*dev)->path);
return -1;
}
- return VIR_APPEND_ELEMENT(list->devs, list->count, *dev);
+ VIR_APPEND_ELEMENT(list->devs, list->count, *dev);
+
+ return 0;
}
if (virMediatedDeviceTypeReadAttrs(tmppath, &mdev_type) < 0)
goto cleanup;
- if (VIR_APPEND_ELEMENT(mdev_types, nmdev_types, mdev_type) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(mdev_types, nmdev_types, mdev_type);
}
if (dirret < 0)
/* Only return global multicast MAC addresses for
* specified interface */
if (entry->global && STREQ(ifname, entry->name)) {
- if (VIR_APPEND_ELEMENT(mcast->entries, mcast->nentries, entry))
- return -1;
+ VIR_APPEND_ELEMENT(mcast->entries, mcast->nentries, entry);
} else {
memset(entry, 0, sizeof(virNetDevMcastEntry));
}
return -1;
}
- if (!(tmp = virNVMeDeviceCopy(dev)) ||
- VIR_APPEND_ELEMENT(list->devs, list->count, tmp) < 0) {
- virNVMeDeviceFree(tmp);
+ if (!(tmp = virNVMeDeviceCopy(dev)))
return -1;
- }
+
+ VIR_APPEND_ELEMENT(list->devs, list->count, tmp);
return 0;
}
_("Device %s is already in use"), dev->name);
return -1;
}
- return VIR_APPEND_ELEMENT(list->devs, list->count, dev);
+ VIR_APPEND_ELEMENT(list->devs, list->count, dev);
+
+ return 0;
}
*copyAddr = *newDevAddr;
- if (VIR_APPEND_ELEMENT(*addrList->iommuGroupDevices,
- *addrList->nIommuGroupDevices, copyAddr) < 0)
- return -1;
+ VIR_APPEND_ELEMENT(*addrList->iommuGroupDevices,
+ *addrList->nIommuGroupDevices, copyAddr);
return 0;
}
goto error;
}
- if (VIR_APPEND_ELEMENT(*virtual_functions, *num_virtual_functions,
- config_addr) < 0)
- goto error;
+ VIR_APPEND_ELEMENT(*virtual_functions, *num_virtual_functions, config_addr);
} while (1);
VIR_DEBUG("Found %zu virtual functions for %s",
goto cleanup;
tmp_pid = tmp;
- if (VIR_APPEND_ELEMENT(*pids, *npids, tmp_pid) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(*pids, *npids, tmp_pid);
}
if (value < 0)
if (rv < 0)
goto cleanup;
- if (VIR_APPEND_ELEMENT(stat->vals, stat->nvals, val) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(stat->vals, stat->nvals, val);
stat->features[i] = g_strdup(resources[i]);
}
- if (VIR_APPEND_ELEMENT(*stats, *nstats, stat) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(*stats, *nstats, stat);
}
/* Sort in id's ascending order */
copy->drvname = g_strdup(drvname);
copy->domname = g_strdup(domname);
- if (VIR_APPEND_ELEMENT(dev->used_by, dev->n_used_by, copy) < 0)
- return -1;
+ VIR_APPEND_ELEMENT(dev->used_by, dev->n_used_by, copy);
return 0;
}
return -1;
}
- return VIR_APPEND_ELEMENT(list->devs, list->count, dev);
+ VIR_APPEND_ELEMENT(list->devs, list->count, dev);
+
+ return 0;
}
virSCSIDevice *
_("Device %s is already in use"), dev->name);
return -1;
}
- return VIR_APPEND_ELEMENT(list->devs, list->count, dev);
+ VIR_APPEND_ELEMENT(list->devs, list->count, dev);
+
+ return 0;
}
(*dev)->name);
return -1;
}
- return VIR_APPEND_ELEMENT(list->devs, list->count, *dev);
+ VIR_APPEND_ELEMENT(list->devs, list->count, *dev);
+
+ return 0;
}
virUSBDevice *
if ((*list)[i] == gid)
goto cleanup;
}
- if (VIR_APPEND_ELEMENT(*list, i, gid) < 0) {
- ret = -1;
- VIR_FREE(*list);
- goto cleanup;
- } else {
- ret = i;
- }
+ VIR_APPEND_ELEMENT(*list, i, gid);
+ ret = i;
}
cleanup:
graphics->data.desktop.display = g_strdup(getenv("DISPLAY"));
}
- if (graphics &&
- VIR_APPEND_ELEMENT(def->graphics, def->ngraphics, graphics) < 0)
- goto cleanup;
+ if (graphics)
+ VIR_APPEND_ELEMENT(def->graphics, def->ngraphics, graphics);
gVBoxAPI.UIMachine.GetVRDEServer(machine, &VRDEServer);
if (VRDEServer)
if (reuseSingleConnection)
graphics->data.rdp.replaceUser = true;
- if (VIR_APPEND_ELEMENT(def->graphics, def->ngraphics, graphics) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(def->graphics, def->ngraphics, graphics);
}
ret = 0;
if (enabled) {
net = vboxDumpNetwork(data, adapter);
- if (VIR_APPEND_ELEMENT(def->nets, def->nnets, net) < 0) {
- VBOX_RELEASE(adapter);
- return -1;
- }
+ VIR_APPEND_ELEMENT(def->nets, def->nnets, net);
}
VBOX_RELEASE(adapter);
if (!net)
continue;
- if (VIR_APPEND_ELEMENT(def->nets, def->nnets, net) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(def->nets, def->nnets, net);
}
/* def:inputs */
video->type = VIR_DOMAIN_VIDEO_TYPE_PARALLELS;
video->vram = 0;
- if (VIR_APPEND_ELEMENT(def->videos, def->nvideos, video) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(def->videos, def->nvideos, video);
ret = 0;
cleanup:
if (!(ip = prlsdkParseNetAddress(addr)))
continue;
- if (VIR_APPEND_ELEMENT(net->guestIP.ips, net->guestIP.nips, ip) < 0) {
- VIR_FREE(ip);
- goto cleanup;
- }
+ VIR_APPEND_ELEMENT(net->guestIP.ips, net->guestIP.nips, ip);
}
ret = 0;
NULL, gw, 0, true, 0, false)))
goto cleanup;
- if (VIR_APPEND_ELEMENT(net->guestIP.routes, net->guestIP.nroutes, route) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(net->guestIP.routes, net->guestIP.nroutes, route);
}
if (*gw6 != '\0') {
NULL, gw6, 0, true, 0, false)))
goto cleanup;
- if (VIR_APPEND_ELEMENT(net->guestIP.routes, net->guestIP.nroutes, route) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(net->guestIP.routes, net->guestIP.nroutes, route);
}
ret = 0;
PrlHandle_Free(netAdapter);
netAdapter = PRL_INVALID_HANDLE;
- if (VIR_APPEND_ELEMENT(def->nets, def->nnets, net) < 0)
- goto error;
+ VIR_APPEND_ELEMENT(def->nets, def->nnets, net);
}
return 0;
PrlHandle_Free(serialPort);
serialPort = PRL_INVALID_HANDLE;
- if (VIR_APPEND_ELEMENT(*serials, *nserials, chr) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(*serials, *nserials, chr);
}
return 0;
gr->listens[0].type = VIR_DOMAIN_GRAPHICS_LISTEN_TYPE_ADDRESS;
- if (VIR_APPEND_ELEMENT(def->graphics, def->ngraphics, gr) < 0)
- goto error;
+ VIR_APPEND_ELEMENT(def->graphics, def->ngraphics, gr);
return 0;
if (virNWFilterHashTablePutAll(vars, ruleinst->vars) < 0)
goto cleanup;
- if (VIR_APPEND_ELEMENT(inst->rules,
- inst->nrules,
- ruleinst) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(inst->rules, inst->nrules, ruleinst);
ruleinst = NULL;
ret = 0;
item->opaque = opaque;
virMutexLock(&test->lock);
- if (VIR_APPEND_ELEMENT(test->items, test->nitems, item) < 0) {
- virMutexUnlock(&test->lock);
- goto error;
- }
+ VIR_APPEND_ELEMENT(test->items, test->nitems, item);
virMutexUnlock(&test->lock);
return 0;
-
- error:
- if (freecb)
- (freecb)(opaque);
- VIR_FREE(item);
- return -1;
}
void *
if (!getenv("LIBVIRT_DEBUG") && !virLogGetNbOutputs()) {
if (!(output = virLogOutputNew(virtTestLogOutput, virtTestLogClose,
&testLog, VIR_LOG_DEBUG,
- VIR_LOG_TO_STDERR, NULL)) ||
- VIR_APPEND_ELEMENT(outputs, noutputs, output) < 0 ||
- virLogDefineOutputs(outputs, noutputs) < 0) {
- virLogOutputFree(output);
+ VIR_LOG_TO_STDERR, NULL)))
+ return EXIT_FAILURE;
+
+ VIR_APPEND_ELEMENT(outputs, noutputs, output);
+
+ if (virLogDefineOutputs(outputs, noutputs) < 0) {
virLogOutputListFree(outputs, noutputs);
return EXIT_FAILURE;
}
vol.source = g_steal_pointer(&source);
vol.target = g_steal_pointer(&target);
- if (VIR_APPEND_ELEMENT(vols, nvols, vol) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(vols, nvols, vol);
}
/* print volumes specified by user that were not found in domain definition */
tmp = g_strdup(arg);
- if (VIR_APPEND_ELEMENT(row->cells, row->ncells, tmp) < 0)
- goto error;
+ VIR_APPEND_ELEMENT(row->cells, row->ncells, tmp);
arg = va_arg(ap, const char *);
}
if (!header)
goto error;
- if (VIR_APPEND_ELEMENT(table->rows, table->nrows, header) < 0)
- goto error;
+ VIR_APPEND_ELEMENT(table->rows, table->nrows, header);
return table;
error:
goto cleanup;
}
- if (VIR_APPEND_ELEMENT(table->rows, table->nrows, row) < 0)
- goto cleanup;
+ VIR_APPEND_ELEMENT(table->rows, table->nrows, row);
ret = 0;
cleanup:
projects / thirdparty / libvirt.git / commitdiff
