return EXIT_SUCCESS;
-error:
+ error:
return EXIT_FAILURE;
}
ret = 0;
-cleanup:
+ cleanup:
if (actualname)
unlink(actualname);
VIR_FREE(actuallog);
virResetLastError();
ret = 0;
-cleanup:
+ cleanup:
virCommandFree(cmd);
return ret;
}
goto cleanup;
ret = 0;
-cleanup:
+ cleanup:
virCommandFree(cmd);
return ret;
}
ret = checkoutput("test3");
-cleanup:
+ cleanup:
virCommandFree(cmd);
/* coverity[double_close] */
VIR_FORCE_CLOSE(newfd1);
ret = checkoutput("test4");
-cleanup:
+ cleanup:
virCommandFree(cmd);
if (pidfile)
unlink(pidfile);
ret = checkoutput("test13");
-cleanup:
+ cleanup:
virCommandFree(cmd);
VIR_FREE(outactual);
return ret;
ret = checkoutput("test14");
-cleanup:
+ cleanup:
virCommandFree(cmd);
VIR_FREE(outactual);
VIR_FREE(erractual);
ret = checkoutput("test15");
-cleanup:
+ cleanup:
VIR_FREE(cwd);
virCommandFree(cmd);
ret = checkoutput("test16");
-cleanup:
+ cleanup:
virCommandFree(cmd);
VIR_FORCE_CLOSE(fd);
VIR_FREE(outactual);
}
ret = 0;
-cleanup:
+ cleanup:
virCommandFree(cmd);
VIR_FREE(outbuf);
VIR_FREE(errbuf);
ret = 0;
-cleanup:
+ cleanup:
virCommandFree(cmd);
if (pidfile)
unlink(pidfile);
ret = 0;
-cleanup:
+ cleanup:
virCommandFree(cmd);
return ret;
}
}
ret = checkoutput("test20");
-cleanup:
+ cleanup:
virCommandFree(cmd);
VIR_FREE(buf);
return ret;
}
ret = checkoutput("test21");
-cleanup:
+ cleanup:
VIR_FREE(outbuf);
VIR_FREE(errbuf);
virCommandFree(cmd);
}
ret = 0;
-cleanup:
+ cleanup:
virCommandFree(cmd);
return ret;
}
}
ret = 0;
-cleanup:
+ cleanup:
return ret;
}
}
virMutexUnlock(&test->lock);
-cleanup:
+ cleanup:
if (test->running)
virThreadJoin(&test->thread);
cpu = virCPUDefParseXML(ctxt->node, ctxt, VIR_CPU_TYPE_AUTO);
-cleanup:
+ cleanup:
xmlXPathFreeContext(ctxt);
xmlFreeDoc(doc);
VIR_FREE(xml);
*count = n;
-cleanup:
+ cleanup:
VIR_FREE(xml);
VIR_FREE(nodes);
xmlXPathFreeContext(ctxt);
xmlFreeDoc(doc);
return cpus;
-cleanup_cpus:
+ cleanup_cpus:
for (i = 0; i < n; i++)
virCPUDefFree(cpus[i]);
VIR_FREE(cpus);
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(xml);
VIR_FREE(expected);
VIR_FREE(actual);
ret = 0;
-cleanup:
+ cleanup:
virCPUDefFree(host);
virCPUDefFree(cpu);
return ret;
ret = cpuTestCompareXML(data->arch, guest, result, 0);
-cleanup:
+ cleanup:
VIR_FREE(result);
cpuDataFree(guestData);
virCPUDefFree(host);
ret = 0;
-cleanup:
+ cleanup:
if (cpus) {
for (i = 0; i < ncpus; i++)
virCPUDefFree(cpus[i]);
ret = cpuTestCompareXML(data->arch, cpu, result,
VIR_DOMAIN_XML_UPDATE_CPU);
-cleanup:
+ cleanup:
virCPUDefFree(host);
virCPUDefFree(cpu);
VIR_FREE(result);
ret = 0;
-cleanup:
+ cleanup:
cpuDataFree(hostData);
virCPUDefFree(host);
return ret;
ret = 0;
-cleanup:
+ cleanup:
virDomainDefFree(def);
VIR_FREE(xmlData);
VIR_FREE(filename);
ret = virBufferContentAndReset(&buf);
-cleanup:
+ cleanup:
virBufferFreeAndReset(&buf);
virStringFreeList(xmlLines);
return ret;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(inXmlData);
VIR_FREE(outXmlData);
VIR_FREE(actual);
DO_TEST_IN("description_only", NULL);
DO_TEST_IN("name_only", NULL);
-cleanup:
+ cleanup:
if (testSnapshotXMLVariableLineRegex)
regfree(testSnapshotXMLVariableLineRegex);
VIR_FREE(testSnapshotXMLVariableLineRegex);
}
}
- cleanup:
+ cleanup:
VIR_FREE(datastoreName);
VIR_FREE(directoryName);
VIR_FREE(directoryAndFileName);
return result;
- failure:
+ failure:
result = -1;
goto cleanup;
goto cleanup;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(wwnn);
VIR_FREE(wwpn);
VIR_FREE(fabric_wwn);
goto cleanup;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(hostname);
return ret;
}
goto cleanup;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(hostname);
return ret;
}
if (virtTestRun("test5", test5, NULL) < 0)
ret = -1;
-cleanup:
+ cleanup:
VIR_FREE(fchost_prefix);
return ret;
}
}
ret = 0;
-cleanup:
+ cleanup:
if (st)
virStreamFree(st);
VIR_FORCE_CLOSE(fd);
goto cleanup;
ret = 0;
-cleanup:
+ cleanup:
if (st)
virStreamFree(st);
VIR_FORCE_CLOSE(fd);
ret = 0;
-cleanup:
+ cleanup:
virJSONValueFree(json);
return ret;
}
}
ret = 0;
-cleanup:
+ cleanup:
virJSONValueFree(json);
virJSONValueFree(name);
VIR_FREE(result);
break;
}
-cleanup:
+ cleanup:
VIR_FREE(newdata);
daemonConfigFree(conf);
return ret;
ret = -1;
}
-cleanup:
+ cleanup:
VIR_FREE(filename);
VIR_FREE(filedata);
VIR_FREE(params);
ret = 0;
-fail:
+ fail:
VIR_FREE(expectxml);
VIR_FREE(actualxml);
VIR_FREE(config);
result = testCompareXMLToConfigFiles(xml, config, info->expectError);
-cleanup:
+ cleanup:
VIR_FREE(xml);
VIR_FREE(config);
return result;
}
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(xml_in);
VIR_FREE(xml_out);
return ret;
ret = virXMLNodeToString(node->doc, node);
-cleanup:
+ cleanup:
VIR_FREE(xml);
xmlFreeDoc(doc);
xmlXPathFreeContext(ctxt);
ret = true;
-cleanup:
+ cleanup:
VIR_FREE(metadataXML);
VIR_FREE(metadataAPI);
result = testCompareXMLToConfFiles(inxml, outxml, info->caps);
-cleanup:
+ cleanup:
VIR_FREE(inxml);
VIR_FREE(outxml);
result = testCompareXMLToXMLFiles(inxml, outxml, info->flags);
-cleanup:
+ cleanup:
VIR_FREE(inxml);
VIR_FREE(outxml);
ret = 0;
-fail:
+ fail:
if (expectFailure) {
if (ret == 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", "Failed to fail.");
ret = 0;
}
}
-error:
+ error:
VIR_FREE(netXmlData);
VIR_FREE(updateXmlData);
VIR_FREE(outXmlData);
info->command, info->section,
info->parentIndex, info->expectFailure);
-cleanup:
+ cleanup:
VIR_FREE(netxml);
VIR_FREE(updatexml);
VIR_FREE(outxml);
ret = 0;
-fail:
+ fail:
VIR_FREE(expectData);
VIR_FREE(actualData);
return ret;
ret = 0;
-fail:
+ fail:
virBufferFreeAndReset(&buf);
VIR_FORCE_FCLOSE(cpustat);
VIR_FREE(expectData);
result = linuxTestCompareFiles(cpuinfo, sysfs_dir, output);
-cleanup:
+ cleanup:
VIR_FREE(cpuinfo);
VIR_FREE(output);
VIR_FREE(sysfs_dir);
result = linuxCPUStatsCompareFiles(cpustatfile,
testData->ncpus,
outfile);
-fail:
+ fail:
VIR_FREE(cpustatfile);
VIR_FREE(outfile);
return result;
result = testCompareXMLToXMLFiles(inxml, outxml, tp->expect_warning);
-cleanup:
+ cleanup:
VIR_FREE(inxml);
VIR_FREE(outxml);
registered = false;
ret = 0;
-cleanup:
+ cleanup:
if (registered)
virConnectDomainEventDeregister(test->conn, domainLifecycleCb);
if (dom) {
id = -1;
ret = 0;
-cleanup:
+ cleanup:
if (id >= 0)
virConnectDomainEventDeregisterAny(test->conn, id);
if (dom) {
id2 = -1;
ret = 0;
-cleanup:
+ cleanup:
if (id1 >= 0)
virConnectDomainEventDeregisterAny(test->conn, id1);
if (id2 >= 0)
}
-cleanup:
+ cleanup:
virConnectDomainEventDeregisterAny(test->conn, id);
if (dom != NULL)
virDomainFree(dom);
goto cleanup;
ret = 0;
-cleanup:
+ cleanup:
virConnectDomainEventDeregisterAny(test->conn, id);
virDomainFree(dom);
if (dom2)
goto cleanup;
}
-cleanup:
+ cleanup:
virConnectNetworkEventDeregisterAny(test->conn, id);
virNetworkDestroy(net);
}
-cleanup:
+ cleanup:
virConnectNetworkEventDeregisterAny(test->conn, id);
virNetworkFree(net);
ret = -1;
goto cleanup;
}
-cleanup:
+ cleanup:
virConnectNetworkEventDeregisterAny(test->conn, id);
return ret;
result = 0;
-cleanup:
+ cleanup:
VIR_FREE(conf);
VIR_FREE(value);
result = 0;
-cleanup:
+ cleanup:
VIR_FREE(actual);
virDomainDefFree(def);
ret = 0;
-cleanup:
+ cleanup:
qemuMonitorTestFree(test);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
qemuMonitorTestFree(test);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
qemuMonitorTestFree(test);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
qemuMonitorTestFree(test);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
virJSONValueFree(val);
return ret;
ret = 0;
-cleanup:
+ cleanup:
qemuMonitorTestFree(test);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(cpuinfo);
qemuMonitorTestFree(test);
return ret;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(reply);
qemuMonitorTestFree(test);
return ret;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(reply);
qemuMonitorTestFree(test);
return ret;
result = testCompareXMLToArgvFiles(xml, args, !!info->extraFlags);
-cleanup:
+ cleanup:
VIR_FREE(xml);
VIR_FREE(args);
return result;
return test;
-error:
+ error:
qemuMonitorTestFree(test);
return NULL;
}
xmlXPathFreeContext(ctxt);
return qemuCaps;
-error:
+ error:
VIR_FREE(nodes);
virObjectUnref(qemuCaps);
xmlFreeDoc(xml);
goto cleanup;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(repliesFile);
VIR_FREE(capsFile);
VIR_FREE(replies);
}
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(path);
VIR_FREE(help);
virObjectUnref(flags);
goto cleanup;
ret = 0;
-cleanup:
+ cleanup:
return ret;
}
ret = testQemuHotplugUpdate(vm, dev);
}
-cleanup:
+ cleanup:
VIR_FREE(domain_filename);
VIR_FREE(device_filename);
VIR_FREE(result_filename);
ret = 0;
-cleanup:
+ cleanup:
qemuMonitorTestFree(test);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
qemuMonitorTestFree(test);
VIR_FREE(package);
return ret;
ret = 0;
-cleanup:
+ cleanup:
qemuMonitorTestFree(test);
for (i = 0; i < ninfo; i++)
qemuMonitorMachineInfoFree(info[i]);
ret = 0;
-cleanup:
+ cleanup:
qemuMonitorTestFree(test);
for (i = 0; i < ncpus; i++)
VIR_FREE(cpus[i]);
#undef CHECK
ret = 0;
-cleanup:
+ cleanup:
qemuMonitorTestFree(test);
for (i = 0; i < ncommands; i++)
VIR_FREE(commands[i]);
ret = 0;
-cleanup:
+ cleanup:
qemuMonitorTestFree(test);
virStringFreeList(tpmmodels);
return ret;
ret = 0;
-cleanup:
+ cleanup:
qemuMonitorTestFree(test);
virStringFreeList(params);
return ret;
#undef CHECK_FAIL
#undef DO_CHECK
-cleanup:
+ cleanup:
qemuMonitorTestFree(test);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
qemuMonitorTestFree(test);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
qemuMonitorTestFree(test);
for (i = 0; i < npaths; i++)
qemuMonitorJSONListPathFree(paths[i]);
}
ret = 0;
-cleanup:
+ cleanup:
qemuMonitorTestFree(test);
return ret;
}
}
ret = 0;
-cleanup:
+ cleanup:
qemuMonitorTestFree(test);
return ret;
}
}
}
-cleanup:
+ cleanup:
virStringFreeList(aliases);
qemuMonitorTestFree(test);
return ret;
ret = 0;
-cleanup:
+ cleanup:
qemuMonitorTestFree(test);
return ret;
}
goto cleanup;
ret = 0;
-cleanup:
+ cleanup:
qemuMonitorTestFree(test);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(cpupids);
qemuMonitorTestFree(test);
return ret;
ret = 0;
-cleanup:
+ cleanup:
qemuMonitorTestFree(test);
return ret;
}
}
ret = 0;
-cleanup:
+ cleanup:
qemuMonitorTestFree(test);
return ret;
}
}
ret = 0;
-cleanup:
+ cleanup:
virHashFree(blockDevices);
virHashFree(expectedBlockDevices);
qemuMonitorTestFree(test);
#undef CHECK
#undef CHECK0
-cleanup:
+ cleanup:
qemuMonitorTestFree(test);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
qemuMonitorTestFree(test);
return ret;
}
}
ret = 0;
-cleanup:
+ cleanup:
qemuMonitorTestFree(test);
return ret;
}
}
ret = 0;
-cleanup:
+ cleanup:
qemuMonitorTestFree(test);
return ret;
}
}
ret = 0;
-cleanup:
+ cleanup:
virHashFree(paths);
virHashFree(expectedPaths);
qemuMonitorTestFree(test);
goto cleanup;
ret = 0;
-cleanup:
+ cleanup:
qemuMonitorTestFree(test);
return ret;
}
}
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(arch);
qemuMonitorTestFree(test);
return ret;
goto cleanup;
ret = 0;
-cleanup:
+ cleanup:
qemuMonitorTestFree(test);
return ret;
}
goto cleanup;
ret = 0;
-cleanup:
+ cleanup:
qemuMonitorTestFree(test);
return ret;
}
}
ret = 0;
-cleanup:
+ cleanup:
qemuMonitorTestFree(test);
return ret;
}
}
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(jsonFile);
VIR_FREE(dataFile);
VIR_FREE(jsonStr);
}
ret = 0;
-cleanup:
+ cleanup:
qemuMonitorTestFree(test);
cpuDataFree(cpuData);
return ret;
ret = qemuMonitorTestAddReponse(test, jsonmsg);
-cleanup:
+ cleanup:
va_end(msgargs);
VIR_FREE(msg);
VIR_FREE(jsonmsg);
VIR_EVENT_HANDLE_ERROR))
err = true;
-cleanup:
+ cleanup:
if (err) {
virNetSocketRemoveIOCallback(sock);
virNetSocketClose(sock);
return 0;
-error:
+ error:
if (freecb)
(freecb)(opaque);
VIR_FREE(item);
else
ret = qemuMonitorTestAddReponse(test, data->response);
-cleanup:
+ cleanup:
VIR_FREE(cmdcopy);
virJSONValueFree(val);
return ret;
ret = qemuMonitorTestAddReponse(test, retmsg);
-cleanup:
+ cleanup:
virJSONValueFree(val);
VIR_FREE(retmsg);
return ret;
/* arguments checked out, return the response */
ret = qemuMonitorTestAddReponse(test, data->response);
-cleanup:
+ cleanup:
VIR_FREE(argstr);
virJSONValueFree(val);
return ret;
qemuMonitorTestProcessCommandWithArgs,
data, qemuMonitorTestHandlerDataFree);
-error:
+ error:
va_end(args);
qemuMonitorTestHandlerDataFree(data);
return -1;
if (virNetSocketListen(test->server, 1) < 0)
goto error;
-cleanup:
+ cleanup:
return test;
-error:
+ error:
VIR_FREE(path);
VIR_FREE(tmpdir_template);
qemuMonitorTestFree(test);
return 0;
-error:
+ error:
return -1;
}
return test;
-error:
+ error:
virDomainChrSourceDefClear(&src);
qemuMonitorTestFree(test);
return NULL;
return test;
-error:
+ error:
virDomainChrSourceDefClear(&src);
qemuMonitorTestFree(test);
return NULL;
ret = virGetStoragePool(conn, name, fakeUUID, NULL, NULL);
-cleanup:
+ cleanup:
VIR_FREE(xmlpath);
return ret;
}
ret = virGetStorageVol(pool->conn, pool->name, volinfo[1], volinfo[0],
NULL, NULL);
-cleanup:
+ cleanup:
virStringFreeList(volinfo);
return ret;
-fallback:
+ fallback:
ret = virGetStorageVol(pool->conn, pool->name, name, "block", NULL, NULL);
goto cleanup;
}
goto cleanup;
}
-cleanup:
+ cleanup:
VIR_FREE(xmlpath);
return xmlbuf;
ret = 0;
-out:
+ out:
VIR_FREE(log);
VIR_FREE(expectargv);
VIR_FREE(actualargv);
info->migrateFrom, info->migrateFd,
flags);
-cleanup:
+ cleanup:
VIR_FREE(xml);
VIR_FREE(args);
return result;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(xml_in);
VIR_FREE(xml_out);
return ret;
info->migrateFrom, info->migrateFd,
info->json, info->expectError);
-cleanup:
+ cleanup:
VIR_FREE(xml);
VIR_FREE(args);
return result;
ret = 0;
-fail:
+ fail:
VIR_FREE(inXmlData);
VIR_FREE(outXmlData);
VIR_FREE(actual);
result = testCompareXMLToXMLFiles(inxml, outxml);
-cleanup:
+ cleanup:
VIR_FREE(inxml);
VIR_FREE(outxml);
ret = 0;
-cleanup:
+ cleanup:
VIR_FORCE_FCLOSE(fp);
VIR_FREE(path);
VIR_FREE(line);
testSELinuxMungePath(&def->os.initrd) < 0)
goto cleanup;
-cleanup:
+ cleanup:
VIR_FREE(xmlfile);
VIR_FREE(xmlstr);
return def;
ret = 0;
-cleanup:
+ cleanup:
if (testSELinuxDeleteDisks(files, nfiles) < 0)
VIR_WARN("unable to fully clean up");
return def;
-error:
+ error:
virDomainDefFree(def);
return NULL;
}
ret = 0;
-cleanup:
+ cleanup:
context_free(con);
context_free(imgcon);
virDomainDefFree(def);
result = testCompareFiles(xml, args, info->version);
-cleanup:
+ cleanup:
VIR_FREE(xml);
VIR_FREE(args);
pool->allocation == test.expected_allocation)
ret = 0;
- cleanup:
+ cleanup:
VIR_FREE(output);
VIR_FREE(poolXmlData);
virStoragePoolDefFree(pool);
vol->allocation == test.expected_allocation)
ret = 0;
- cleanup:
+ cleanup:
VIR_FREE(output);
VIR_FREE(poolXmlData);
VIR_FREE(volXmlData);
ret = 0;
- cleanup:
+ cleanup:
VIR_FREE(poolxml);
VIR_FREE(volxml);
return ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
result = testCompareXMLToXMLFiles(inxml, outxml);
-cleanup:
+ cleanup:
VIR_FREE(inxml);
VIR_FREE(outxml);
ret = 0;
-cleanup:
+ cleanup:
virStoragePoolDefFree(pool);
virStoragePoolDefFree(inputpool);
virStorageVolDefFree(vol);
cmdline, info->flags,
info->imgformat);
-cleanup:
+ cleanup:
VIR_FREE(poolxml);
VIR_FREE(volxml);
VIR_FREE(inputvolxml);
result = testCompareXMLToXMLFiles(poolxml, inxml, outxml);
-cleanup:
+ cleanup:
VIR_FREE(poolxml);
VIR_FREE(inxml);
VIR_FREE(outxml);
result = 0;
-cleanup:
+ cleanup:
VIR_FREE(sysfsExpectData);
virSysinfoDefFree(ret);
virBufferFreeAndReset(&buf);
ret = EXIT_SUCCESS;
-error:
+ error:
VIR_FREE(testdata.decoder);
VIR_FREE(testdata.sysinfo);
VIR_FREE(testdata.cpuinfo);
exit_code = EXIT_SUCCESS;
-cleanup:
+ cleanup:
VIR_FREE(buffer);
return exit_code;
}
return caps;
-error:
+ error:
virObjectUnref(caps);
return NULL;
}
return caps;
-error:
+ error:
virObjectUnref(caps);
return NULL;
}
return 0;
-error:
+ error:
/* No way to free a guest? */
virCapabilitiesFreeMachines(machines, 1);
return -1;
return 0;
-error:
+ error:
/* No way to free a guest? */
virCapabilitiesFreeMachines(machines, 1);
return -1;
return 0;
-error:
+ error:
virCapabilitiesFreeMachines(machines, ARRAY_CARDINALITY(s390_machines));
return -1;
}
return 0;
-error:
+ error:
virCapabilitiesFreeMachines(capsmachines, ARRAY_CARDINALITY(machines));
return -1;
}
return 0;
-error:
+ error:
virCapabilitiesFreeMachines(capsmachines, ARRAY_CARDINALITY(machines));
return -1;
}
return caps;
-cleanup:
+ cleanup:
virCapabilitiesFreeMachines(machines, nmachines);
virObjectUnref(caps);
return NULL;
return caps;
-cleanup:
+ cleanup:
virCapabilitiesFreeMachines(machines, nmachines);
virObjectUnref(caps);
return NULL;
}
ret = 0;
-cleanup:
+ cleanup:
return ret;
}
ret = 0;
-error:
+ error:
virBitmapFree(bitmap);
return ret;
}
ret = 0;
-error:
+ error:
virBitmapFree(bitmap);
VIR_FREE(bitsString2);
return ret;
goto error;
ret = 0;
-error:
+ error:
virBitmapFree(bitmap);
return ret;
}
virBitmapFree(bitmap);
return 0;
-error:
+ error:
virBitmapFree(bitmap);
return -1;
}
goto error;
ret = 0;
-error:
+ error:
virBitmapFree(bitmap);
VIR_FREE(data2);
return ret;
ret = 0;
-error:
+ error:
virBitmapFree(bitmap);
VIR_FREE(str);
return ret;
return 0;
-error:
+ error:
virBitmapFree(bitmap);
return -1;
}
goto cleanup;
ret = 0;
-cleanup:
+ cleanup:
virBitmapFree(bitmap);
return ret;
}
goto cleanup;
ret = 0;
-cleanup:
+ cleanup:
virBitmapFree(bitmap);
return ret;
virBufferAsprintf(buf, "%s", addstr);
ret = 0;
-out:
+ out:
bufret = virBufferContentAndReset(buf);
if (!bufret) {
TEST_ERROR("Buffer had error set");
ret = 0;
-cleanup:
+ cleanup:
virBufferFreeAndReset(buf);
VIR_FREE(result);
return ret;
return caps;
-error:
+ error:
virCapabilitiesClearHostNUMACellCPUTopology(cell_cpus, MAX_CPUS_IN_CELL);
VIR_FREE(cell_cpus);
virObjectUnref(caps);
ret = 0;
-error:
+ error:
virObjectUnref(caps);
virBitmapFree(nodemask);
virBitmapFree(cpumap);
goto cleanup;
ret = 0;
-cleanup:
+ cleanup:
if (fd != -1 && close(fd) < 0)
ret = -1;
free(filepath);
}
ret = 0;
-cleanup:
+ cleanup:
return ret;
}
ret = validateCgroup(cgroup, "", mountsFull, links, placement);
-cleanup:
+ cleanup:
virCgroupFree(&cgroup);
return ret;
}
}
ret = validateCgroup(cgroup, "/virtualmachines.partition", mountsFull, links, placementFull);
-cleanup:
+ cleanup:
virCgroupFree(&cgroup);
return ret;
}
ret = validateCgroup(cgroup, "/deployment.partition/production.partition",
mountsFull, links, placementFull);
-cleanup:
+ cleanup:
virCgroupFree(&cgroup);
return ret;
}
ret = validateCgroup(cgroup, "/user/berrange.user/production.partition",
mountsFull, links, placementFull);
-cleanup:
+ cleanup:
virCgroupFree(&cgroup);
return ret;
}
ret = validateCgroup(domaincgroup, "/production.partition/foo.libvirt-lxc", mountsFull, links, placement);
-cleanup:
+ cleanup:
virCgroupFree(&partitioncgroup);
virCgroupFree(&domaincgroup);
return ret;
*/
ret = validateCgroup(domaincgroup, "/_cgroup.evil/net_cls.evil/__evil.evil/_cpu.foo.libvirt-lxc", mountsFull, links, placement);
-cleanup:
+ cleanup:
virCgroupFree(&partitioncgroup3);
virCgroupFree(&partitioncgroup2);
virCgroupFree(&partitioncgroup1);
ret = validateCgroup(cgroup, "", mountsAllInOne, linksAllInOne, placement);
-cleanup:
+ cleanup:
virCgroupFree(&cgroup);
return ret;
}
ret = validateCgroup(cgroup, "", mountsLogind, linksLogind, placement);
-cleanup:
+ cleanup:
virCgroupFree(&cgroup);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
virCgroupFree(&cgroup);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
virCgroupFree(&cgroup);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
virCgroupFree(&cgroup);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
virCgroupFree(&cgroup);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(out_string);
VIR_FREE(out_signature);
VIR_FREE(out_objectpath);
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(out_str1);
VIR_FREE(out_str2);
dbus_message_unref(msg);
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(out_str1);
VIR_FREE(out_str2);
dbus_message_unref(msg);
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(out_int32);
VIR_FREE(out_str1);
VIR_FREE(out_str2);
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(out_string);
VIR_FREE(out_signature);
VIR_FREE(out_objectpath);
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(out_str1);
VIR_FREE(out_str2);
VIR_FREE(out_key1);
goto cleanup;
ret = 0;
-cleanup:
+ cleanup:
return ret;
}
goto cleanup;
ret = 0;
-cleanup:
+ cleanup:
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
virHashFree(hash);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
virHashFree(hash);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
virHashFree(hash);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
virHashFree(hash);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
virHashFree(hash);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
virHashFree(hash);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
virHashFree(hash);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
virHashFree(hash);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(array);
virHashFree(hash);
return ret;
ret = 0;
-cleanup:
+ cleanup:
virHashFree(hash1);
virHashFree(hash2);
return ret;
return 0;
-cleanup:
+ cleanup:
myCleanup();
return -1;
}
ret = true;
# endif
-cleanup:
+ cleanup:
VIR_FORCE_CLOSE(kvmfd);
return ret;
ret = 0;
-cleanup:
+ cleanup:
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
return ret;
}
static int
ret = 0;
-cleanup:
+ cleanup:
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
return ret;
}
}
ret = 0;
-cleanup:
+ cleanup:
virObjectUnref(ident);
return ret;
}
}
ret = 0;
-cleanup:
+ cleanup:
virObjectUnref(identa);
virObjectUnref(identb);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
virObjectUnref(ident);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
virCommandSetDryRun(NULL, NULL, NULL);
VIR_FREE(actual_session);
return ret;
ret = 0;
-cleanup:
+ cleanup:
virCommandSetDryRun(NULL, NULL, NULL);
for (i = 0; i < ntargets; i++)
VIR_FREE(targets[i]);
#undef TRANSLATE
ret = 0;
-cleanup:
+ cleanup:
return ret;
}
#undef TRANSLATE
ret = 0;
-cleanup:
+ cleanup:
return ret;
}
}
ret = 0;
-cleanup:
+ cleanup:
virKeyFileFree(kf);
return ret;
}
}
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(outbuf);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(actual_cmd);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
virCommandSetDryRun(NULL, NULL, NULL);
VIR_FREE(errbuf);
return ret;
ret = 0;
-cleanup:
+ cleanup:
virCommandSetDryRun(NULL, NULL, NULL);
VIR_FREE(errbuf);
return ret;
ret = 0;
-cleanup:
+ cleanup:
virLockSpaceFree(lockspace);
rmdir(LOCKSPACE_DIR);
return ret;
ret = 0;
-cleanup:
+ cleanup:
virLockSpaceFree(lockspace);
rmdir(LOCKSPACE_DIR);
return ret;
ret = 0;
-cleanup:
+ cleanup:
virLockSpaceFree(lockspace);
rmdir(LOCKSPACE_DIR);
return ret;
ret = 0;
-cleanup:
+ cleanup:
virLockSpaceFree(lockspace);
rmdir(LOCKSPACE_DIR);
return ret;
ret = 0;
-cleanup:
+ cleanup:
virLockSpaceFree(lockspace);
rmdir(LOCKSPACE_DIR);
return ret;
ret = 0;
-cleanup:
+ cleanup:
virLockSpaceFree(lockspace);
rmdir(LOCKSPACE_DIR);
return ret;
ret = 0;
-cleanup:
+ cleanup:
virLockSpaceFree(lockspace);
rmdir(LOCKSPACE_DIR);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
virCommandSetDryRun(NULL, NULL, NULL);
virNetDevBandwidthFree(band);
virBufferFreeAndReset(&buf);
}
ret = 0;
-cleanup:
+ cleanup:
virNetMessageFree(msg);
return ret;
}
}
ret = 0;
-cleanup:
+ cleanup:
virNetMessageFree(msg);
return ret;
}
}
ret = 0;
-cleanup:
+ cleanup:
if (err.message)
VIR_FREE(*err.message);
if (err.str1)
}
ret = 0;
-cleanup:
+ cleanup:
xdr_free((xdrproc_t)xdr_virNetMessageError, (void*)&err);
virNetMessageFree(msg);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
virNetMessageFree(msg);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
VIR_FORCE_CLOSE(s4);
VIR_FORCE_CLOSE(s6);
return ret;
ret = 0;
-cleanup:
+ cleanup:
virObjectUnref(ssock);
for (i = 0; i < nlsock; i++)
virObjectUnref(lsock[i]);
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(path);
virObjectUnref(lsock);
virObjectUnref(ssock);
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(path);
virObjectUnref(lsock);
virObjectUnref(ssock);
ret = 0;
-cleanup:
+ cleanup:
virObjectUnref(csock);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
virObjectUnref(csock);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
virObjectUnref(csock);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
virObjectUnref(ctxt);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
virObjectUnref(serverCtxt);
virObjectUnref(clientCtxt);
virObjectUnref(serverSess);
goto cleanup;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(newpath);
realclose(fd);
return ret;
callbacks[nCallbacks++].fd = fd;
ret = 0;
-cleanup:
+ cleanup:
return ret;
}
}
ret = 0;
-cleanup:
+ cleanup:
return ret;
}
dev->driver = driver;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(devpath);
VIR_FREE(driverpath);
return ret;
dev->driver = NULL;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(devpath);
VIR_FREE(driverpath);
return ret;
}
ret = pci_driver_bind(driver, dev);
-cleanup:
+ cleanup:
return ret;
}
}
ret = pci_driver_unbind(dev->driver, dev);
-cleanup:
+ cleanup:
return ret;
}
static int
}
ret = 0;
-cleanup:
+ cleanup:
return ret;
}
}
ret = 0;
-cleanup:
+ cleanup:
return ret;
}
}
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(path);
VIR_FREE(driver);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
virPCIDeviceFree(dev);
return ret;
}
}
ret = 0;
-cleanup:
+ cleanup:
for (i = 0; i < nDev; i++)
virPCIDeviceFree(dev[i]);
virObjectUnref(activeDevs);
}
ret = 0;
-cleanup:
+ cleanup:
for (i = 0; i < nDev; i++)
virPCIDeviceFree(dev[i]);
virObjectUnref(activeDevs);
}
ret = 0;
-cleanup:
+ cleanup:
virObjectUnref(activeDevs);
virObjectUnref(inactiveDevs);
return ret;
ret = 0;
virPCIDeviceFree(dev);
-cleanup:
+ cleanup:
return ret;
}
goto cleanup;
ret = 0;
-cleanup:
+ cleanup:
virPCIDeviceFree(dev);
return ret;
}
virPCIDeviceGetStubDriver(dev));
}
-cleanup:
+ cleanup:
virPCIDeviceFree(dev);
return ret;
}
goto cleanup;
ret = 0;
-cleanup:
+ cleanup:
virPCIDeviceFree(dev);
return ret;
}
goto cleanup;
ret = 0;
-cleanup:
+ cleanup:
virPCIDeviceFree(dev);
return ret;
}
goto cleanup;
ret = 0;
-cleanup:
+ cleanup:
virPCIDeviceFree(dev);
return ret;
}
}
ret = 0;
-cleanup:
+ cleanup:
virObjectUnref(alloc);
return ret;
}
}
ret = 0;
-cleanup:
+ cleanup:
virObjectUnref(alloc);
return ret;
}
goto cleanup;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(name);
return ret;
}
goto cleanup;
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(sgname);
if (free_dev)
virSCSIDeviceFree(dev);
if (virtTestRun("test2", test2, NULL) < 0)
ret = -1;
-cleanup:
+ cleanup:
VIR_FREE(virscsi_prefix);
return ret;
}
result = 0;
-cleanup:
+ cleanup:
VIR_FREE(actualData);
return result;
#endif
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(buf);
virCommandFree(cmd);
if (ret)
testCleanupImages();
return ret;
-skip:
+ skip:
fputs("qemu-img is too old; skipping this test\n", stderr);
ret = EXIT_AM_SKIP;
goto cleanup;
}
ret = 0;
-cleanup:
+ cleanup:
virStorageFileFreeMetadata(meta);
return ret;
}
}
ret = 0;
-cleanup:
+ cleanup:
virStringFreeList(got);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(got);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
for (i = 0; i < ARRAY_CARDINALITY(array); i++)
VIR_FREE(array[i]);
return ret;
}
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(dst);
return ret;
}
}
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(uristr);
virURIFree(uri);
return ret;
return path;
-error:
+ error:
errno = ENOMEM;
return NULL;
}
ret = 0;
-cleanup:
+ cleanup:
virObjectUnref(devs);
virUSBDeviceFree(dev);
return ret;
ret = 0;
-cleanup:
+ cleanup:
virObjectUnref(list);
virObjectUnref(devlist);
virUSBDeviceFree(dev);
ret = 0;
-cleanup:
+ cleanup:
VIR_FREE(path);
VIR_FREE(databuf);
return ret;
return;
- failure:
+ failure:
virObjectUnref(caps);
caps = NULL;
}
ret = 0;
- cleanup:
+ cleanup:
VIR_FREE(vmxData);
VIR_FREE(xmlData);
VIR_FREE(formatted);
ret = testCompareFiles(vmx, xml);
- cleanup:
+ cleanup:
VIR_FREE(vmx);
VIR_FREE(xml);
goto cleanup;
}
- cleanup:
+ cleanup:
VIR_FREE(copyOfFileName);
return src;
else
result = testCompareFormatXML(cfg, xml, info->version);
-cleanup:
+ cleanup:
VIR_FREE(xml);
VIR_FREE(cfg);
result = testCompareFiles(xml, args, info->version);
-cleanup:
+ cleanup:
VIR_FREE(xml);
VIR_FREE(args);
return;
- failure:
+ failure:
virObjectUnref(caps);
virObjectUnref(xmlopt);
caps = NULL;
result = 0;
- failure:
+ failure:
VIR_FREE(xmlData);
VIR_FREE(vmxData);
VIR_FREE(formatted);
result = testCompareFiles(xml, vmx, info->virtualHW_version);
- cleanup:
+ cleanup:
VIR_FREE(xml);
VIR_FREE(vmx);
success = true;
- cleanup:
+ cleanup:
if (! success) {
VIR_FREE(absolutePath);
}
projects / libvirt.git / commitdiff