const char *devmap_file,
char **devicesmap_out)
{
- virDomainDiskDefPtr hdd, cd, userdef, diskdef;
+ virDomainDiskDefPtr hdd;
+ virDomainDiskDefPtr cd;
+ virDomainDiskDefPtr userdef;
+ virDomainDiskDefPtr diskdef;
virCommandPtr cmd;
unsigned int best_idx = UINT_MAX;
size_t i;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
bhyveConnPtr privconn = conn->privateData;
virDomainDefPtr def = NULL;
- virCommandPtr cmd = NULL, loadcmd = NULL;
+ virCommandPtr cmd = NULL;
+ virCommandPtr loadcmd = NULL;
char *ret = NULL;
virCheckFlags(0, NULL);
virDomainUSBAddressSetAddHub(virDomainUSBAddressSetPtr addrs,
virDomainHubDefPtr hub)
{
- virDomainUSBAddressHubPtr targetHub = NULL, newHub = NULL;
+ virDomainUSBAddressHubPtr targetHub = NULL;
+ virDomainUSBAddressHubPtr newHub = NULL;
int ret = -1;
int targetPort;
g_autofree char *portStr = NULL;
virDomainChrRemove(virDomainDefPtr vmdef,
virDomainChrDefPtr chr)
{
- virDomainChrDefPtr ret = NULL, **arrPtr = NULL;
+ virDomainChrDefPtr ret = NULL;
+ virDomainChrDefPtr **arrPtr = NULL;
size_t i, *cntPtr = NULL;
if (virDomainChrGetDomainPtrsInternal(vmdef, chr->deviceType,
}
for (i = 0; i < sibling; i++) {
- virDomainNumaDistancePtr ldist, rdist;
+ virDomainNumaDistancePtr ldist;
+ virDomainNumaDistancePtr rdist;
unsigned int sibling_id, sibling_value;
/* siblings are in order of parsing or explicitly numbered */
GHashTable *hash)
{
size_t i, j;
- virNWFilterVarValuePtr varValue, tmp;
+ virNWFilterVarValuePtr varValue;
+ virNWFilterVarValuePtr tmp;
const char *value;
varValue = virHashLookup(hash, cie->varNames[0]);
unsigned int flags) /* virNetworkUpdateFlags */
{
int ret = -1;
- virNetworkDefPtr livedef = NULL, configdef = NULL;
+ virNetworkDefPtr livedef = NULL;
+ virNetworkDefPtr configdef = NULL;
/* normalize config data, and check for common invalid requests. */
if (virNetworkObjConfigChangeSetup(obj, xmlopt, flags) < 0)
const char *type)
{
size_t i, j;
- virBlkioDevicePtr dest, src;
+ virBlkioDevicePtr dest;
+ virBlkioDevicePtr src;
for (i = 0; i < src_size; i++) {
bool found = false;
/* Step 6: Set driver and domain information */
for (i = 0; i < virPCIDeviceListCount(pcidevs); i++) {
- virPCIDevicePtr pci, actual;
+ virPCIDevicePtr pci;
+ virPCIDevicePtr actual;
/* We need to look up the actual device and set the information
* there because 'pci' only contain address information and will
static int
libxlDomainDetachDeviceConfig(virDomainDefPtr vmdef, virDomainDeviceDefPtr dev)
{
- virDomainDiskDefPtr disk, detach;
- virDomainHostdevDefPtr hostdev, det_hostdev;
- virDomainControllerDefPtr cont, det_cont;
+ virDomainDiskDefPtr disk;
+ virDomainDiskDefPtr detach;
+ virDomainHostdevDefPtr hostdev;
+ virDomainHostdevDefPtr det_hostdev;
+ virDomainControllerDefPtr cont;
+ virDomainControllerDefPtr det_cont;
virDomainNetDefPtr net;
int idx;
xenFormatSerial(virConfValuePtr list, virDomainChrDefPtr serial)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
- virConfValuePtr val, tmp;
+ virConfValuePtr val;
+ virConfValuePtr tmp;
int ret;
if (serial) {
const char *vif_typename)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
- virConfValuePtr val, tmp;
+ virConfValuePtr val;
+ virConfValuePtr tmp;
char macaddr[VIR_MAC_STRING_BUFLEN];
virBufferAsprintf(&buf, "mac=%s", virMacAddrFormat(&net->mac, macaddr));
for (i = 0; i < def->nhostdevs; i++) {
if (def->hostdevs[i]->mode == VIR_DOMAIN_HOSTDEV_MODE_SUBSYS &&
def->hostdevs[i]->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI) {
- virConfValuePtr val, tmp;
+ virConfValuePtr val;
+ virConfValuePtr tmp;
char *buf;
const char *permissive_str = NULL;
return -1;
}
} else {
- virConfValuePtr vfb, disp;
+ virConfValuePtr vfb;
+ virConfValuePtr disp;
char *vfbstr = NULL;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
xenFormatXLVnode(virConfValuePtr list,
virBufferPtr buf)
{
- virConfValuePtr numaPnode, tmp;
+ virConfValuePtr numaPnode;
+ virConfValuePtr tmp;
numaPnode = g_new0(virConfValue, 1);
int ret = -1;
size_t i;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
- virConfValuePtr numaVnode, tmp;
+ virConfValuePtr numaVnode;
+ virConfValuePtr tmp;
virBitmapPtr cpumask = virDomainNumaGetNodeCpumask(numa, node);
size_t nodeSize = virDomainNumaGetNodeMemorySize(numa, node) / 1024;
g_autofree char *nodeVcpus = NULL;
xenFormatXLDisk(virConfValuePtr list, virDomainDiskDefPtr disk)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
- virConfValuePtr val, tmp;
+ virConfValuePtr val;
+ virConfValuePtr tmp;
int format = virDomainDiskGetFormat(disk);
const char *driver = virDomainDiskGetDriver(disk);
g_autofree char *target = NULL;
{
size_t i;
const char *devtype;
- virConfValuePtr usbdevices = NULL, lastdev;
+ virConfValuePtr usbdevices = NULL;
+ virConfValuePtr lastdev;
if (def->os.type == VIR_DOMAIN_OSTYPE_HVM) {
usbdevices = g_new0(virConfValue, 1);
for (i = 0; i < def->ncontrollers; i++) {
if (def->controllers[i]->type == VIR_DOMAIN_CONTROLLER_TYPE_USB) {
- virConfValuePtr val, tmp;
+ virConfValuePtr val;
+ virConfValuePtr tmp;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
if (def->controllers[i]->model != -1) {
for (i = 0; i < def->nhostdevs; i++) {
if (def->hostdevs[i]->mode == VIR_DOMAIN_HOSTDEV_MODE_SUBSYS &&
def->hostdevs[i]->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB) {
- virConfValuePtr val, tmp;
+ virConfValuePtr val;
+ virConfValuePtr tmp;
char *buf;
buf = g_strdup_printf("hostbus=%x,hostaddr=%x",
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
int sourceType = channel->source->type;
- virConfValuePtr val, tmp;
+ virConfValuePtr val;
+ virConfValuePtr tmp;
/* connection */
virBufferAddLit(&buf, "connection=");
args->list = NULL;
for (i = 0; i < nsdata->num_args; i++) {
- virConfValuePtr val, tmp;
+ virConfValuePtr val;
+ virConfValuePtr tmp;
val = g_new0(virConfValue, 1);
virDomainDiskDefPtr disk)
{
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
- virConfValuePtr val, tmp;
+ virConfValuePtr val;
+ virConfValuePtr tmp;
const char *src = virDomainDiskGetSource(disk);
int format = virDomainDiskGetFormat(disk);
const char *driver = virDomainDiskGetDriver(disk);
static int virLXCControllerSetupCpuAffinity(virLXCControllerPtr ctrl)
{
int hostcpus, maxcpu = CPU_SETSIZE;
- virBitmapPtr cpumap, cpumapToSet;
+ virBitmapPtr cpumap;
+ virBitmapPtr cpumapToSet;
VIR_DEBUG("Setting CPU affinity");
virDomainDeviceDefPtr dev)
{
int ret = -1;
- virDomainDiskDefPtr disk, det_disk;
+ virDomainDiskDefPtr disk;
+ virDomainDiskDefPtr det_disk;
virDomainNetDefPtr net;
- virDomainHostdevDefPtr hostdev, det_hostdev;
+ virDomainHostdevDefPtr hostdev;
+ virDomainHostdevDefPtr det_hostdev;
int idx;
switch (dev->type) {
virLXCDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm = NULL;
virDomainDefPtr vmdef = NULL;
- virDomainDeviceDefPtr dev = NULL, dev_copy = NULL;
+ virDomainDeviceDefPtr dev = NULL;
+ virDomainDeviceDefPtr dev_copy = NULL;
int ret = -1;
virLXCDriverConfigPtr cfg = virLXCDriverGetConfig(driver);
virCapsPtr caps = NULL;
virDomainObjPtr vm = NULL;
virDomainDefPtr vmdef = NULL;
- virDomainDeviceDefPtr dev = NULL, dev_copy = NULL;
+ virDomainDeviceDefPtr dev = NULL;
+ virDomainDeviceDefPtr dev_copy = NULL;
int ret = -1;
virLXCDriverConfigPtr cfg = virLXCDriverGetConfig(driver);
size_t i;
virNetworkDNSDefPtr dns = &def->dns;
bool wantDNS = dns->enable != VIR_TRISTATE_BOOL_NO;
- virNetworkIPDefPtr tmpipdef, ipdef, ipv4def, ipv6def;
+ virNetworkIPDefPtr tmpipdef;
+ virNetworkIPDefPtr ipdef;
+ virNetworkIPDefPtr ipv4def;
+ virNetworkIPDefPtr ipv6def;
bool ipv6SLAAC;
*configstr = NULL;
virNetworkDefPtr def = virNetworkObjGetDef(obj);
size_t i;
pid_t dnsmasqPid;
- virNetworkIPDefPtr ipdef, ipv4def, ipv6def;
+ virNetworkIPDefPtr ipdef;
+ virNetworkIPDefPtr ipv4def;
+ virNetworkIPDefPtr ipv6def;
g_autoptr(dnsmasqContext) dctx = NULL;
/* if no IP addresses specified, nothing to do */
const char *ifname,
virNWFilterRuleInstPtr rule)
{
- virNWFilterVarCombIterPtr vciter, tmp;
+ virNWFilterVarCombIterPtr vciter;
+ virNWFilterVarCombIterPtr tmp;
int ret = -1;
/* rule->vars holds all the variables names that this rule will access.
const char *ifname,
virNWFilterRuleInstPtr rule)
{
- virNWFilterVarCombIterPtr vciter, tmp;
+ virNWFilterVarCombIterPtr vciter;
+ virNWFilterVarCombIterPtr tmp;
int ret = -1;
/* rule->vars holds all the variables names that this rule will access.
virDomainDeviceDefPtr dev,
bool persist)
{
- virDomainFSDefPtr fs, cur;
+ virDomainFSDefPtr fs;
+ virDomainFSDefPtr cur;
int pos;
if (dev->type == VIR_DOMAIN_DEVICE_FS) {
unsigned int nmountpoints)
{
int ret = -1;
- virJSONValuePtr cmd, arg = NULL;
+ virJSONValuePtr cmd;
+ virJSONValuePtr arg = NULL;
virJSONValuePtr reply = NULL;
if (mountpoints && nmountpoints) {
if ((flags & VIR_DOMAIN_XML_MIGRATABLE)) {
size_t i;
int toremove = 0;
- virDomainControllerDefPtr usb = NULL, pci = NULL;
+ virDomainControllerDefPtr usb = NULL;
+ virDomainControllerDefPtr pci = NULL;
/* If only the default USB controller is present, we can remove it
* and make the XML compatible with older versions of libvirt which
unsigned int parse_flags,
virDomainXMLOptionPtr xmlopt)
{
- virDomainDiskDefPtr disk, det_disk;
+ virDomainDiskDefPtr disk;
+ virDomainDiskDefPtr det_disk;
virDomainNetDefPtr net;
virDomainSoundDefPtr sound;
- virDomainHostdevDefPtr hostdev, det_hostdev;
- virDomainLeaseDefPtr lease, det_lease;
- virDomainControllerDefPtr cont, det_cont;
+ virDomainHostdevDefPtr hostdev;
+ virDomainHostdevDefPtr det_hostdev;
+ virDomainLeaseDefPtr lease;
+ virDomainLeaseDefPtr det_lease;
+ virDomainControllerDefPtr cont;
+ virDomainControllerDefPtr det_cont;
virDomainChrDefPtr chr;
virDomainFSDefPtr fs;
virDomainMemoryDefPtr mem;
virDomainDefPtr def;
virDomainDefPtr persistentDef;
int ret = -1;
- virDomainNetDefPtr net = NULL, persistentNet = NULL;
+ virDomainNetDefPtr net = NULL;
+ virDomainNetDefPtr persistentNet = NULL;
g_autoptr(virNetDevBandwidth) bandwidth = NULL;
g_autoptr(virNetDevBandwidth) newBandwidth = NULL;
g_autoptr(virQEMUDriverConfig) cfg = NULL;
qemuMonitorJSONQueryFdsetsParse(virJSONValuePtr msg,
qemuMonitorFdsetsPtr *fdsets)
{
- virJSONValuePtr returnArray, entry;
+ virJSONValuePtr returnArray;
+ virJSONValuePtr entry;
size_t i;
g_autoptr(qemuMonitorFdsets) sets = g_new0(qemuMonitorFdsets, 1);
int ninfo;
{
int ret = -1;
const char *tmp;
- virJSONValuePtr returnArray, entry, table, element;
+ virJSONValuePtr returnArray;
+ virJSONValuePtr entry;
+ virJSONValuePtr table;
+ virJSONValuePtr element;
size_t nTable;
size_t i;
virNetDevRxFilterPtr fil = virNetDevRxFilterNew();
const char *file)
{
int ret = -1;
- virJSONValuePtr cmd, reply = NULL;
+ virJSONValuePtr cmd;
+ virJSONValuePtr reply = NULL;
cmd = qemuMonitorJSONMakeCommand("screendump",
"s:filename", file,
bool skipauth)
{
int ret = -1;
- virJSONValuePtr cmd, reply = NULL;
+ virJSONValuePtr cmd;
+ virJSONValuePtr reply = NULL;
cmd = qemuMonitorJSONMakeCommand("add_client",
"s:protocol", protocol,
void virNetServerClientRemoveFilter(virNetServerClientPtr client,
int filterID)
{
- virNetServerClientFilterPtr tmp, prev;
+ virNetServerClientFilterPtr tmp;
+ virNetServerClientFilterPtr prev;
virObjectLock(client);
virSecurityStackClose(virSecurityManagerPtr mgr)
{
virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
- virSecurityStackItemPtr next, item = priv->itemsHead;
+ virSecurityStackItemPtr item = priv->itemsHead;
+ virSecurityStackItemPtr next;
while (item) {
next = item->next;
{
virNodeDeviceDefPtr def = NULL;
virNodeDevCapsDefPtr caps;
- virNodeDeviceObjPtr obj = NULL, objcopy = NULL;
+ virNodeDeviceObjPtr obj = NULL;
+ virNodeDeviceObjPtr objcopy = NULL;
virNodeDeviceDefPtr objdef;
virObjectEventPtr event = NULL;
g_autofree char *xml = NULL;
static virConfEntryPtr
virConfAddEntry(virConfPtr conf, char *name, virConfValuePtr value, char *comm)
{
- virConfEntryPtr ret, prev;
+ virConfEntryPtr ret;
+ virConfEntryPtr prev;
if (conf == NULL)
return NULL;
static virConfValuePtr
virConfParseValue(virConfParserCtxtPtr ctxt)
{
- virConfValuePtr ret, lst = NULL, tmp, prev;
+ virConfValuePtr ret;
+ virConfValuePtr lst = NULL;
+ virConfValuePtr tmp;
+ virConfValuePtr prev;
virConfType type = VIR_CONF_NONE;
char *str = NULL;
long long l = 0;
const char *setting,
virConfValuePtr value)
{
- virConfEntryPtr cur, prev = NULL;
+ virConfEntryPtr cur;
+ virConfEntryPtr prev = NULL;
if (value && value->type == VIR_CONF_STRING && value->str == NULL) {
virConfFreeValue(value);
bool swapped)
{
int ret = -1;
- virNetDevBandwidthRatePtr rx = NULL, tx = NULL; /* From domain POV */
+ virNetDevBandwidthRatePtr rx = NULL; /* From domain POV */
+ virNetDevBandwidthRatePtr tx = NULL; /* From domain POV */
virCommandPtr cmd = NULL;
char *average = NULL;
char *peak = NULL;
typedef struct _virNetDevBandwidth virNetDevBandwidth;
typedef virNetDevBandwidth *virNetDevBandwidthPtr;
struct _virNetDevBandwidth {
- virNetDevBandwidthRatePtr in, out;
+ virNetDevBandwidthRatePtr in;
+ virNetDevBandwidthRatePtr out;
};
void virNetDevBandwidthFree(virNetDevBandwidthPtr def);
static int
vzConnectClose(virConnectPtr conn)
{
- vzConnPtr curr, *prev = &vz_conn_list;
+ vzConnPtr curr;
+ vzConnPtr *prev = &vz_conn_list;
vzConnPtr privconn = conn->privateData;
if (!privconn)
char *maskstr = NULL;
int nbits;
virSocketAddr mask;
- virNetDevIPAddrPtr ip = NULL, ret = NULL;
+ virNetDevIPAddrPtr ip = NULL;
+ virNetDevIPAddrPtr ret = NULL;
if (!(maskstr = strchr(addr, '/')))
goto cleanup;
{
int ret = -1;
size_t i;
- virNetDevIPRoutePtr route4 = NULL, route6 = NULL;
+ virNetDevIPRoutePtr route4 = NULL;
+ virNetDevIPRoutePtr route6 = NULL;
char *gw4 = NULL, *gw6 = NULL;
PRL_RESULT pret;
for (i = 0; i < net->guestIP.nroutes; i++) {
- virSocketAddrPtr addrdst, gateway;
+ virSocketAddrPtr addrdst;
+ virSocketAddrPtr gateway;
virSocketAddr zero;
addrdst = virNetDevIPRouteGetAddress(net->guestIP.routes[i]);
testCreateServer(const char *server_name, const char *host, int family)
{
virNetServerPtr srv = NULL;
- virNetServerServicePtr svc1 = NULL, svc2 = NULL;
- virNetServerClientPtr cln1 = NULL, cln2 = NULL;
- virNetSocketPtr sk1 = NULL, sk2 = NULL;
+ virNetServerServicePtr svc1 = NULL;
+ virNetServerServicePtr svc2 = NULL;
+ virNetServerClientPtr cln1 = NULL;
+ virNetServerClientPtr cln2 = NULL;
+ virNetSocketPtr sk1 = NULL;
+ virNetSocketPtr sk2 = NULL;
int fdclient[2];
if (socketpair(PF_UNIX, SOCK_STREAM, 0, fdclient) < 0) {
const struct testExecRestartData *data = opaque;
char *infile = NULL, *outfile = NULL;
char *injsonstr = NULL, *outjsonstr = NULL;
- virJSONValuePtr injson = NULL, outjson = NULL;
+ virJSONValuePtr injson = NULL;
+ virJSONValuePtr outjson = NULL;
int fdclient[2] = { -1, -1 }, fdserver[2] = { -1, -1 };
if (socketpair(PF_UNIX, SOCK_STREAM, 0, fdclient) < 0) {
int ret = -1;
virPCIDevicePtr dev[] = {NULL, NULL, NULL};
size_t i, nDev = G_N_ELEMENTS(dev);
- virPCIDeviceListPtr activeDevs = NULL, inactiveDevs = NULL;
+ virPCIDeviceListPtr activeDevs = NULL;
+ virPCIDeviceListPtr inactiveDevs = NULL;
int count;
if (!(activeDevs = virPCIDeviceListNew()) ||
int ret = -1;
virPCIDevicePtr dev[] = {NULL, NULL, NULL};
size_t i, nDev = G_N_ELEMENTS(dev);
- virPCIDeviceListPtr activeDevs = NULL, inactiveDevs = NULL;
+ virPCIDeviceListPtr activeDevs = NULL;
+ virPCIDeviceListPtr inactiveDevs = NULL;
int count;
if (!(activeDevs = virPCIDeviceListNew()) ||
int ret = -1;
virPCIDevicePtr dev[] = {NULL, NULL, NULL};
size_t i, nDev = G_N_ELEMENTS(dev);
- virPCIDeviceListPtr activeDevs = NULL, inactiveDevs = NULL;
+ virPCIDeviceListPtr activeDevs = NULL;
+ virPCIDeviceListPtr inactiveDevs = NULL;
int count;
if (!(activeDevs = virPCIDeviceListNew()) ||