static char *
qemuAgentEscapeNonPrintable(const char *text)
{
- int i;
+ size_t i;
virBuffer buf = VIR_BUFFER_INITIALIZER;
for (i = 0; text[i] != '\0'; i++) {
if (text[i] == '\\')
struct sockaddr_un addr;
int monfd;
int timeout = 3; /* In seconds */
- int ret, i = 0;
+ int ret;
+ size_t i = 0;
*inProgress = false;
qemuAgentMessagePtr msg)
{
int used = 0;
- int i = 0;
+ size_t i = 0;
#if DEBUG_IO
# if DEBUG_RAW_IO
char *str1 = qemuAgentEscapeNonPrintable(data);
qemuAgentCPUInfoPtr *info)
{
int ret = -1;
- int i;
+ size_t i;
virJSONValuePtr cmd;
virJSONValuePtr reply = NULL;
virJSONValuePtr data = NULL;
virArch guestarch)
{
virCapsGuestPtr guest;
- int i;
+ size_t i;
bool haskvm = false;
bool haskqemu = false;
char *kvmbin = NULL;
virCapsPtr virQEMUCapsInit(virQEMUCapsCachePtr cache)
{
virCapsPtr caps;
- int i;
+ size_t i;
virArch hostarch = virArchFromHost();
if ((caps = virCapabilitiesNew(hostarch,
virQEMUCapsProbeQMPTPM(virQEMUCapsPtr qemuCaps,
qemuMonitorPtr mon)
{
- int nentries, i;
+ int nentries;
+ size_t i;
char **entries = NULL;
if ((nentries = qemuMonitorGetTPMModels(mon, &entries)) < 0)
{
qemuDomainObjPrivatePtr priv = vm->privateData;
int rc = -1;
- int i;
+ size_t i;
if (!virCgroupHasController(priv->cgroup,
VIR_CGROUP_CONTROLLER_BLKIO)) {
const char *const *deviceACL = NULL;
int rc = -1;
int ret = -1;
- int i;
+ size_t i;
if (!virCgroupHasController(priv->cgroup, VIR_CGROUP_CONTROLLER_DEVICES))
return 0;
int nvcpupin,
int vcpuid)
{
- int i;
+ size_t i;
for (i = 0; i < nvcpupin; i++) {
if (vcpuid == vcpupin[i]->vcpuid) {
qemuDomainObjPrivatePtr priv = vm->privateData;
virDomainDefPtr def = vm->def;
int rc;
- unsigned int i, j;
+ size_t i, j;
unsigned long long period = vm->def->cputune.period;
long long quota = vm->def->cputune.quota;
if (rc < 0) {
virReportSystemError(-rc,
_("Unable to create vcpu cgroup for %s(vcpu:"
- " %d)"),
+ " %zu)"),
vm->def->name, i);
goto cleanup;
}
rc = virCgroupAddTask(cgroup_vcpu, priv->vcpupids[i]);
if (rc < 0) {
virReportSystemError(-rc,
- _("unable to add vcpu %d task %d to cgroup"),
+ _("unable to add vcpu %zu task %d to cgroup"),
i, priv->vcpupids[i]);
goto cleanup;
}
cleanup:
if (ret < 0) {
- int i;
+ size_t i;
for (i = 0; i < *tapfdSize; i++)
VIR_FORCE_CLOSE(tapfd[i]);
if (template_ifname)
int *vhostfd,
int *vhostfdSize)
{
- int i;
+ size_t i;
/* If the config says explicitly to not use vhost, return now */
if (net->driver.virtio.name == VIR_DOMAIN_NET_BACKEND_TYPE_QEMU) {
"but is unavailable"));
goto error;
}
- VIR_WARN("Unable to open vhost-net. Opened so far %d, requested %d",
+ VIR_WARN("Unable to open vhost-net. Opened so far %zu, requested %d",
i, *vhostfdSize);
*vhostfdSize = i;
break;
qemuNetworkPrepareDevices(virDomainDefPtr def)
{
int ret = -1;
- int ii;
+ size_t i;
- for (ii = 0; ii < def->nnets; ii++) {
- virDomainNetDefPtr net = def->nets[ii];
+ for (i = 0; i < def->nnets; i++) {
+ virDomainNetDefPtr net = def->nets[i];
int actualType;
/* If appropriate, grab a physical device from the configured
qemuAssignDeviceNetAlias(virDomainDefPtr def, virDomainNetDefPtr net, int idx)
{
if (idx == -1) {
- int i;
+ size_t i;
idx = 0;
for (i = 0; i < def->nnets; i++) {
int thisidx;
qemuAssignDeviceHostdevAlias(virDomainDefPtr def, virDomainHostdevDefPtr hostdev, int idx)
{
if (idx == -1) {
- int i;
+ size_t i;
idx = 0;
for (i = 0; i < def->nhostdevs; i++) {
int thisidx;
qemuAssignDeviceRedirdevAlias(virDomainDefPtr def, virDomainRedirdevDefPtr redirdev, int idx)
{
if (idx == -1) {
- int i;
+ size_t i;
idx = 0;
for (i = 0; i < def->nredirdevs; i++) {
int thisidx;
int
qemuAssignDeviceAliases(virDomainDefPtr def, virQEMUCapsPtr qemuCaps)
{
- int i;
+ size_t i;
for (i = 0; i < def->ndisks; i++) {
if (qemuAssignDeviceDiskAlias(def, def->disks[i], qemuCaps) < 0)
return 0;
for (i = 0; i < def->nfss; i++) {
- if (virAsprintf(&def->fss[i]->info.alias, "fs%d", i) < 0)
+ if (virAsprintf(&def->fss[i]->info.alias, "fs%zu", i) < 0)
return -1;
}
for (i = 0; i < def->nsounds; i++) {
- if (virAsprintf(&def->sounds[i]->info.alias, "sound%d", i) < 0)
+ if (virAsprintf(&def->sounds[i]->info.alias, "sound%zu", i) < 0)
return -1;
}
for (i = 0; i < def->nhostdevs; i++) {
return -1;
}
for (i = 0; i < def->nvideos; i++) {
- if (virAsprintf(&def->videos[i]->info.alias, "video%d", i) < 0)
+ if (virAsprintf(&def->videos[i]->info.alias, "video%zu", i) < 0)
return -1;
}
for (i = 0; i < def->ncontrollers; i++) {
return -1;
}
for (i = 0; i < def->ninputs; i++) {
- if (virAsprintf(&def->inputs[i]->info.alias, "input%d", i) < 0)
+ if (virAsprintf(&def->inputs[i]->info.alias, "input%zu", i) < 0)
return -1;
}
for (i = 0; i < def->nparallels; i++) {
- if (virAsprintf(&def->parallels[i]->info.alias, "parallel%d", i) < 0)
+ if (virAsprintf(&def->parallels[i]->info.alias, "parallel%zu", i) < 0)
return -1;
}
for (i = 0; i < def->nserials; i++) {
- if (virAsprintf(&def->serials[i]->info.alias, "serial%d", i) < 0)
+ if (virAsprintf(&def->serials[i]->info.alias, "serial%zu", i) < 0)
return -1;
}
for (i = 0; i < def->nchannels; i++) {
- if (virAsprintf(&def->channels[i]->info.alias, "channel%d", i) < 0)
+ if (virAsprintf(&def->channels[i]->info.alias, "channel%zu", i) < 0)
return -1;
}
for (i = 0; i < def->nconsoles; i++) {
- if (virAsprintf(&def->consoles[i]->info.alias, "console%d", i) < 0)
+ if (virAsprintf(&def->consoles[i]->info.alias, "console%zu", i) < 0)
return -1;
}
for (i = 0; i < def->nhubs; i++) {
- if (virAsprintf(&def->hubs[i]->info.alias, "hub%d", i) < 0)
+ if (virAsprintf(&def->hubs[i]->info.alias, "hub%zu", i) < 0)
return -1;
}
for (i = 0; i < def->nsmartcards; i++) {
- if (virAsprintf(&def->smartcards[i]->info.alias, "smartcard%d", i) < 0)
+ if (virAsprintf(&def->smartcards[i]->info.alias, "smartcard%zu", i) < 0)
return -1;
}
if (def->watchdog) {
disks, networks, consoles, controllers, memballoon and rng in this
order
*/
- int i;
+ size_t i;
for (i = 0; i < def->ndisks; i++) {
if (def->disks[i]->bus == VIR_DOMAIN_DISK_BUS_VIRTIO &&
int qemuDomainAssignSpaprVIOAddresses(virDomainDefPtr def,
virQEMUCapsPtr qemuCaps)
{
- int i, ret = -1;
+ size_t i;
+ int ret = -1;
int model;
/* Default values match QEMU. See spapr_(llan|vscsi|vty).c */
qemuDomainPCIAddressSetGrow(qemuDomainPCIAddressSetPtr addrs,
virDevicePCIAddressPtr addr)
{
- int add, i;
+ int add;
+ size_t i;
add = addr->bus - addrs->nbuses + 1;
i = addrs->nbuses;
if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
int max_idx = -1;
int nbuses = 0;
- int i;
+ size_t i;
int rv;
for (i = 0; i < def->ncontrollers; i++) {
bool dryRun)
{
qemuDomainPCIAddressSetPtr addrs;
- int i;
+ size_t i;
if (VIR_ALLOC(addrs) < 0)
goto error;
virDomainDiskDefPtr disk,
virBufferPtr opt)
{
- int i, ret = 0;
+ size_t i;
+ int ret = 0;
virSecretPtr sec = NULL;
char *secret = NULL;
size_t secret_size;
virBuffer buf = VIR_BUFFER_INITIALIZER;
enum virDomainNetType netType = virDomainNetGetActualType(net);
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
- int i;
+ size_t i;
if (net->script && netType != VIR_DOMAIN_NET_TYPE_ETHERNET) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
}
/* Look for an 'rtc' timer element, and add in appropriate clock= and driftfix= */
- int i;
+ size_t i;
for (i = 0; i < def->ntimers; i++) {
if (def->timers[i]->name == VIR_DOMAIN_TIMER_NAME_RTC) {
switch (def->timers[i]->track) {
char *compare_msg = NULL;
int ret = -1;
virBuffer buf = VIR_BUFFER_INITIALIZER;
- int i;
+ size_t i;
virCapsPtr caps = NULL;
*hasHwVirt = false;
static int
qemuBuildNumaArgStr(const virDomainDefPtr def, virCommandPtr cmd)
{
- int i;
+ size_t i;
virBuffer buf = VIR_BUFFER_INITIALIZER;
char *cpumask = NULL;
int ret = -1;
int defaultMode = graphics->data.spice.defaultMode;
int port = graphics->data.spice.port;
int tlsPort = graphics->data.spice.tlsPort;
- int i;
+ size_t i;
if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_SPICE)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
char **tapfdName = NULL;
char **vhostfdName = NULL;
int actualType = virDomainNetGetActualType(net);
- int i;
+ size_t i;
if (actualType == VIR_DOMAIN_NET_TYPE_HOSTDEV) {
/* NET_TYPE_HOSTDEV devices are really hostdev devices, so
qemuBuildCommandLineCallbacksPtr callbacks)
{
virErrorPtr originalError = NULL;
- int i, j;
+ size_t i, j;
const char *emulator;
char uuid[VIR_UUID_STRING_BUFLEN];
char *cpu;
for (i = 0; i < def->nnets; i++) {
virDomainNetDefPtr net = def->nets[i];
- int vlan = i;
+ int vlan;
/* VLANs are not used with -netdev, so don't record them */
if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_NETDEV) &&
virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
vlan = -1;
+ else
+ vlan = i;
if (qemuBuildInterfaceCommandLine(cmd, driver, conn, def, net,
qemuCaps, vlan, bootNet, vmop) < 0)
smartcard->data.cert.file[j]);
goto error;
}
- virBufferAsprintf(&opt, ",cert%d=%s", j + 1,
+ virBufferAsprintf(&opt, ",cert%zu=%s", j + 1,
smartcard->data.cert.file[j]);
}
if (smartcard->data.cert.database) {
if (sound->model == VIR_DOMAIN_SOUND_MODEL_ICH6) {
char *codecstr = NULL;
- int ii;
- for (ii = 0; ii < sound->ncodecs; ii++) {
+ for (j = 0; j < sound->ncodecs; j++) {
virCommandAddArg(cmd, "-device");
- if (!(codecstr = qemuBuildSoundCodecStr(sound, sound->codecs[ii], qemuCaps))) {
+ if (!(codecstr = qemuBuildSoundCodecStr(sound, sound->codecs[j], qemuCaps))) {
goto error;
}
virCommandAddArg(cmd, codecstr);
VIR_FREE(codecstr);
}
- if (ii == 0) {
+ if (j == 0) {
virDomainSoundCodecDef codec = {
VIR_DOMAIN_SOUND_CODEC_TYPE_DUPLEX,
0
/* free up any resources in the network driver
* but don't overwrite the original error */
originalError = virSaveLastError();
- for (i = 0; i <= last_good_net; i++)
+ for (i = 0; last_good_net != -1 && i <= last_good_net; i++)
virDomainConfNWFilterTeardown(def->nets[i]);
virSetError(originalError);
virFreeError(originalError);
int argcount = 0;
int argalloc = 0;
int envend;
- int i;
+ size_t i;
const char *curr = args;
const char *start;
const char **progenv = NULL;
static const char *qemuFindEnv(const char **progenv,
const char *name)
{
- int i;
+ size_t i;
int len = strlen(name);
for (i = 0; progenv && progenv[i]; i++) {
char **values = NULL;
const char *start = str;
const char *end;
- int i;
+ size_t i;
*retkeywords = NULL;
*retvalues = NULL;
char **keywords;
char **values;
int nkeywords;
- int i;
+ size_t i;
int idx = -1;
int busid = -1;
int unitid = -1;
const char **nics,
int wantvlan)
{
- int i;
+ size_t i;
for (i = 0; i < nnics; i++) {
int gotvlan;
const char *tmp = strstr(nics[i], "vlan=");
int wantvlan = 0;
const char *tmp;
bool genmac = true;
- int i;
+ size_t i;
tmp = strchr(val, ',');
char **hv_tokens = NULL;
char *model = NULL;
int ret = -1;
- int i;
+ size_t i;
if (!(tokens = virStringSplit(val, ",", 0)))
goto cleanup;
if (STREQ(feature, "kvmclock")) {
bool present = (policy == VIR_CPU_FEATURE_REQUIRE);
- int j;
+ size_t j;
for (j = 0; j < dom->clock.ntimers; j++) {
if (dom->clock.timers[j]->name == VIR_DOMAIN_TIMER_NAME_KVMCLOCK)
unsigned int cores = 0;
unsigned int threads = 0;
unsigned int maxcpus = 0;
- int i;
+ size_t i;
int nkws;
char **kws;
char **vals;
bool *monJSON)
{
virDomainDefPtr def;
- int i;
+ size_t i;
bool nographics = false;
bool fullscreen = false;
char *path;
const char **progenv = NULL;
const char **progargv = NULL;
virDomainDefPtr def = NULL;
- int i;
+ size_t i;
if (qemuStringToArgvEnv(args, &progenv, &progargv) < 0)
goto cleanup;
char *tmp;
size_t nstr = 0;
char **str = NULL;
- int i;
+ size_t i;
if (virAsprintf(&path, "/proc/%d/%s", pid_value, name) < 0)
goto cleanup;
const char **progenv = NULL;
char *exepath = NULL;
char *emulator;
- int i;
+ size_t i;
/* The parser requires /proc/pid, which only exists on platforms
* like Linux where pid_t fits in int. */
virConfPtr conf = NULL;
virConfValuePtr p;
int ret = -1;
- int i;
+ size_t i;
/* Just check the file is readable before opening it, otherwise
* libvirt emits an error.
if (priv->nvcpupids) {
- int i;
+ size_t i;
virBufferAddLit(buf, " <vcpus>\n");
for (i = 0; i < priv->nvcpupids; i++) {
virBufferAsprintf(buf, " <vcpu pid='%d'/>\n", priv->vcpupids[i]);
}
if (priv->qemuCaps) {
- int i;
+ size_t i;
virBufferAddLit(buf, " <qemuCaps>\n");
for (i = 0; i < QEMU_CAPS_LAST; i++) {
if (virQEMUCapsGet(priv->qemuCaps, i)) {
qemuDomainObjPrivatePtr priv = data;
char *monitorpath;
char *tmp;
- int n, i;
+ int n;
+ size_t i;
xmlNodePtr *nodes = NULL;
virQEMUCapsPtr qemuCaps = NULL;
qemuDomainDefNamespaceFree(void *nsdata)
{
qemuDomainCmdlineDefPtr cmd = nsdata;
- unsigned int i;
+ size_t i;
if (!cmd)
return;
qemuDomainCmdlineDefPtr cmd = NULL;
bool uses_qemu_ns = false;
xmlNodePtr *nodes = NULL;
- int n, i;
+ int n;
+ size_t i;
if (xmlXPathRegisterNs(ctxt, BAD_CAST "qemu", BAD_CAST QEMU_NAMESPACE_HREF) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
void *nsdata)
{
qemuDomainCmdlineDefPtr cmd = nsdata;
- unsigned int i;
+ size_t i;
if (!cmd->num_args && !cmd->num_env)
return 0;
}
if ((flags & VIR_DOMAIN_XML_MIGRATABLE)) {
- int i;
+ size_t i;
int toremove = 0;
virDomainControllerDefPtr usb = NULL, pci = NULL;
virDomainObjPtr obj,
int logFD)
{
- int i;
+ size_t i;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
if (cfg->privileged &&
int ndisks)
{
const char *qemuimgarg[] = { NULL, "snapshot", NULL, NULL, NULL, NULL };
- int i;
+ size_t i;
bool skipped = false;
qemuimgarg[0] = qemuFindQemuImgBinary(driver);
bool cold_boot)
{
int ret = -1;
- int i;
+ size_t i;
virDomainDiskDefPtr disk;
char uuid[VIR_UUID_STRING_BUFLEN];
virDomainEventPtr event = NULL;
qemuDomainCleanupCallback cb)
{
qemuDomainObjPrivatePtr priv = vm->privateData;
- int i;
+ size_t i;
VIR_DEBUG("vm=%s, cb=%p", vm->def->name, cb);
qemuDomainCleanupCallback cb)
{
qemuDomainObjPrivatePtr priv = vm->privateData;
- int i;
+ size_t i;
VIR_DEBUG("vm=%s, cb=%p", vm->def->name, cb);
virDomainObjPtr vm)
{
qemuDomainObjPrivatePtr priv = vm->privateData;
- int i;
+ size_t i;
VIR_DEBUG("driver=%p, vm=%s", driver, vm->def->name);
/* run cleanup callbacks in reverse order */
- for (i = priv->ncleanupCallbacks - 1; i >= 0; i--) {
- if (priv->cleanupCallbacks[i])
+ for (i = 0; i < priv->ncleanupCallbacks; i++) {
+ if (priv->cleanupCallbacks[priv->ncleanupCallbacks - (i + 1)])
priv->cleanupCallbacks[i](driver, vm);
}
qemuDomainMemoryLimit(virDomainDefPtr def)
{
unsigned long long mem;
- int i;
+ size_t i;
if (def->mem.hard_limit) {
mem = def->mem.hard_limit;
qemuDomainNetsRestart(virDomainObjPtr vm,
void *data ATTRIBUTE_UNUSED)
{
- int i;
+ size_t i;
virDomainDefPtr def = vm->def;
virObjectLock(vm);
/* translate the keycode to RFB for qemu driver */
if (codeset != VIR_KEYCODE_SET_RFB) {
- int i;
+ size_t i;
int keycode;
for (i = 0; i < nkeycodes; i++) {
unsigned int nvcpus)
{
qemuDomainObjPrivatePtr priv = vm->privateData;
- int i, rc = 1;
+ size_t i;
+ int rc = 1;
int ret = -1;
int oldvcpus = vm->def->vcpus;
int vcpus = oldvcpus;
if (rv < 0) {
virReportSystemError(-rv,
_("Unable to create vcpu cgroup for %s(vcpu:"
- " %d)"),
+ " %zu)"),
vm->def->name, i);
goto cleanup;
}
rv = virCgroupAddTask(cgroup_vcpu, cpupids[i]);
if (rv < 0) {
virReportSystemError(-rv,
- _("unable to add vcpu %d task %d to cgroup"),
+ _("unable to add vcpu %zu task %d to cgroup"),
i, cpupids[i]);
virCgroupRemove(cgroup_vcpu);
goto cleanup;
vm->def->cputune.nvcpupin, i) < 0) {
virReportError(VIR_ERR_OPERATION_INVALID,
_("failed to set cpuset.cpus in cgroup"
- " for vcpu %d"), i);
+ " for vcpu %zu"), i);
ret = -1;
goto cleanup;
}
if (virProcessSetAffinity(cpupids[i],
vcpupin->cpumask) < 0) {
virReportError(VIR_ERR_SYSTEM_ERROR,
- _("failed to set cpu affinity for vcpu %d"),
+ _("failed to set cpu affinity for vcpu %zu"),
i);
ret = -1;
goto cleanup;
if (rv < 0) {
virReportSystemError(-rv,
_("Unable to access vcpu cgroup for %s(vcpu:"
- " %d)"),
+ " %zu)"),
vm->def->name, i);
goto cleanup;
}
qemuAgentCPUInfoPtr cpuinfo,
int ncpuinfo)
{
- int i;
+ size_t i;
int nonline = 0;
int nofflinable = 0;
unsigned char *cpumaps,
int maplen) {
virDomainObjPtr vm;
- int i, v, maxcpu, hostcpus;
+ size_t i;
+ int v, maxcpu, hostcpus;
int ret = -1;
qemuDomainObjPrivatePtr priv;
virCapsPtr caps = NULL;
qemuAgentCPUInfoPtr cpuinfo = NULL;
int ncpuinfo = -1;
- int i;
+ size_t i;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG |
{
virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
- int i, ret = -1;
+ size_t i;
+ int ret = -1;
if (!(vm = qemuDomObjFromDomain(dom)))
return -1;
bool monitor_json = false;
virCommandPtr cmd = NULL;
char *ret = NULL;
- int i;
+ size_t i;
virQEMUDriverConfigPtr cfg;
virCapsPtr caps = NULL;
!graphics->data.vnc.socket && graphics->data.vnc.autoport) {
graphics->data.vnc.port = 5900;
} else if (graphics->type == VIR_DOMAIN_GRAPHICS_TYPE_SPICE) {
- int j;
+ size_t j;
bool needTLSPort = false;
bool needPort = false;
int defaultMode = graphics->data.spice.defaultMode;
char *temp;
int ndevices = 0;
int nsep = 0;
- int i;
+ size_t i;
virBlkioDeviceWeightPtr result = NULL;
*dw = NULL;
virBlkioDeviceWeightPtr src_array,
size_t src_size)
{
- int i, j;
+ size_t i, j;
virBlkioDeviceWeightPtr dest, src;
for (i = 0; i < src_size; i++) {
unsigned int flags)
{
virQEMUDriverPtr driver = dom->conn->privateData;
- int i;
+ size_t i;
virDomainObjPtr vm = NULL;
virDomainDefPtr persistentDef = NULL;
int ret = -1;
} else if (STREQ(param->field, VIR_DOMAIN_BLKIO_DEVICE_WEIGHT)) {
size_t ndevices;
virBlkioDeviceWeightPtr devices = NULL;
- int j;
+ size_t j;
if (qemuDomainParseDeviceWeightStr(params[i].value.s,
&devices,
unsigned int flags)
{
virQEMUDriverPtr driver = dom->conn->privateData;
- int i, j;
+ size_t i, j;
virDomainObjPtr vm = NULL;
virDomainDefPtr persistentDef = NULL;
unsigned int val;
unsigned int flags)
{
virQEMUDriverPtr driver = dom->conn->privateData;
- int i;
+ size_t i;
virDomainObjPtr vm = NULL;
virDomainDefPtr persistentDef = NULL;
int ret = -1;
unsigned int flags)
{
virQEMUDriverPtr driver = dom->conn->privateData;
- int i;
+ size_t i;
virDomainDefPtr persistentDef = NULL;
virDomainObjPtr vm = NULL;
int ret = -1;
unsigned int flags)
{
virQEMUDriverPtr driver = dom->conn->privateData;
- int i;
+ size_t i;
virDomainObjPtr vm = NULL;
virDomainDefPtr persistentDef = NULL;
char *nodeset = NULL;
qemuSetVcpusBWLive(virDomainObjPtr vm, virCgroupPtr cgroup,
unsigned long long period, long long quota)
{
- int i;
+ size_t i;
qemuDomainObjPrivatePtr priv = vm->privateData;
virCgroupPtr cgroup_vcpu = NULL;
int rc;
if (rc < 0) {
virReportSystemError(-rc,
_("Unable to find vcpu cgroup for %s(vcpu:"
- " %d)"),
+ " %zu)"),
vm->def->name, i);
goto cleanup;
}
unsigned int flags)
{
virQEMUDriverPtr driver = dom->conn->privateData;
- int i;
+ size_t i;
virDomainObjPtr vm = NULL;
virDomainDefPtr vmdef = NULL;
unsigned long long value_ul;
virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
qemuDomainObjPrivatePtr priv;
- int ret = -1, i;
+ int ret = -1, idx;
char *device = NULL;
virDomainDiskDefPtr disk = NULL;
goto endjob;
}
- if ((i = virDomainDiskIndexByName(vm->def, path, false)) < 0) {
+ if ((idx = virDomainDiskIndexByName(vm->def, path, false)) < 0) {
virReportError(VIR_ERR_INVALID_ARG,
_("invalid path: %s"), path);
goto endjob;
}
- disk = vm->def->disks[i];
+ disk = vm->def->disks[idx];
if (virAsprintf(&device, "%s%s", QEMU_DRIVE_HOST_PREFIX,
disk->info.alias) < 0)
struct _virDomainBlockStats *stats)
{
virQEMUDriverPtr driver = dom->conn->privateData;
- int i, ret = -1;
+ int idx;
+ int ret = -1;
virDomainObjPtr vm;
virDomainDiskDefPtr disk = NULL;
qemuDomainObjPrivatePtr priv;
goto cleanup;
}
- if ((i = virDomainDiskIndexByName(vm->def, path, false)) < 0) {
+ if ((idx = virDomainDiskIndexByName(vm->def, path, false)) < 0) {
virReportError(VIR_ERR_INVALID_ARG,
_("invalid path: %s"), path);
goto cleanup;
}
- disk = vm->def->disks[i];
+ disk = vm->def->disks[idx];
if (!disk->info.alias) {
virReportError(VIR_ERR_INTERNAL_ERROR,
unsigned int flags)
{
virQEMUDriverPtr driver = dom->conn->privateData;
- int i, tmp, ret = -1;
+ int idx;
+ int tmp, ret = -1;
virDomainObjPtr vm;
virDomainDiskDefPtr disk = NULL;
qemuDomainObjPrivatePtr priv;
}
if (*nparams != 0) {
- if ((i = virDomainDiskIndexByName(vm->def, path, false)) < 0) {
+ if ((idx = virDomainDiskIndexByName(vm->def, path, false)) < 0) {
virReportError(VIR_ERR_INVALID_ARG,
_("invalid path: %s"), path);
goto endjob;
}
- disk = vm->def->disks[i];
+ disk = vm->def->disks[idx];
if (!disk->info.alias) {
virReportError(VIR_ERR_INTERNAL_ERROR,
struct _virDomainInterfaceStats *stats)
{
virDomainObjPtr vm;
- int i;
+ size_t i;
int ret = -1;
if (!(vm = qemuDomObjFromDomain(dom)))
unsigned int flags)
{
virQEMUDriverPtr driver = dom->conn->privateData;
- int i;
+ size_t i;
virDomainObjPtr vm = NULL;
virDomainDefPtr persistentDef = NULL;
int ret = -1;
unsigned int flags)
{
virQEMUDriverPtr driver = dom->conn->privateData;
- int i;
+ size_t i;
virDomainObjPtr vm = NULL;
virDomainDefPtr def = NULL;
virDomainDefPtr persistentDef = NULL;
virStorageFileMetadata *meta = NULL;
virDomainDiskDefPtr disk = NULL;
struct stat sb;
- int i;
+ int idx;
int format;
virQEMUDriverConfigPtr cfg = NULL;
}
/* Check the path belongs to this domain. */
- if ((i = virDomainDiskIndexByName(vm->def, path, false)) < 0) {
+ if ((idx = virDomainDiskIndexByName(vm->def, path, false)) < 0) {
virReportError(VIR_ERR_INVALID_ARG,
_("invalid path %s not assigned to domain"), path);
goto cleanup;
}
- disk = vm->def->disks[i];
+ disk = vm->def->disks[idx];
if (!disk->src) {
virReportError(VIR_ERR_INVALID_ARG,
_("disk %s does not currently have a source assigned"),
virDomainSnapshotObjPtr snap,
bool reuse)
{
- int i;
+ size_t i;
virDomainSnapshotDiskDefPtr snapdisk;
virDomainDiskDefPtr defdisk;
virCommandPtr cmd = NULL;
unsigned int *flags)
{
int ret = -1;
- int i;
+ size_t i;
bool active = virDomainObjIsActive(vm);
struct stat st;
bool reuse = (*flags & VIR_DOMAIN_SNAPSHOT_CREATE_REUSE_EXT) != 0;
qemuDomainObjPrivatePtr priv = vm->privateData;
virJSONValuePtr actions = NULL;
int ret = -1;
- int i;
+ size_t i;
bool persist = false;
bool reuse = (flags & VIR_DOMAIN_SNAPSHOT_CREATE_REUSE_EXT) != 0;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
if (ret < 0) {
/* Transaction failed; undo the changes to vm. */
bool need_unlink = !(flags & VIR_DOMAIN_SNAPSHOT_CREATE_REUSE_EXT);
- while (--i >= 0) {
+ while (i-- > 0) {
virDomainDiskDefPtr persistDisk = NULL;
if (snap->def->disks[i].snapshot ==
{
virDomainObjPtr vm = NULL;
int ret = -1;
- int i;
+ size_t i;
virDomainChrDefPtr chr = NULL;
qemuDomainObjPrivatePtr priv;
{
virDomainObjPtr vm = NULL;
int ret = -1;
- int i;
+ size_t i;
virDomainChrDefPtr chr = NULL;
qemuDomainObjPrivatePtr priv;
}
static char *
-qemuDiskPathToAlias(virDomainObjPtr vm, const char *path, int *idx)
+qemuDiskPathToAlias(virDomainObjPtr vm, const char *path, int *idxret)
{
- int i;
+ int idx;
char *ret = NULL;
virDomainDiskDefPtr disk;
- i = virDomainDiskIndexByName(vm->def, path, true);
- if (i < 0)
+ idx = virDomainDiskIndexByName(vm->def, path, true);
+ if (idx < 0)
goto cleanup;
- disk = vm->def->disks[i];
- if (idx)
- *idx = i;
+ disk = vm->def->disks[idx];
+ if (idxret)
+ *idxret = idx;
if (disk->src) {
if (virAsprintf(&ret, "drive-%s", disk->info.alias) < 0)
virDomainBlockIoTuneInfo *oldinfo;
const char *device = NULL;
int ret = -1;
- int i;
+ size_t i;
int idx = -1;
bool set_bytes = false;
bool set_iops = false;
virDomainBlockIoTuneInfo reply;
const char *device = NULL;
int ret = -1;
- int i;
+ size_t i;
virCapsPtr caps = NULL;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
qemuDomainObjPrivatePtr priv;
virHashTablePtr table = NULL;
int ret = -1;
- int i;
+ size_t i;
int n = 0;
virCheckFlags(0, -1);
unsigned int num)
{
int ret = -1;
- int i;
+ size_t i;
char *buf = NULL;
qemuDomainObjPrivatePtr priv = vm->privateData;
virCgroupPtr group_vcpu = NULL;
for (i = 0; i < priv->nvcpupids; i++) {
char *pos;
unsigned long long tmp;
- int j;
+ size_t j;
if (virCgroupNewVcpu(priv->cgroup, i, false, &group_vcpu) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
unsigned int ncpus)
{
int rv = -1;
- int i, id, max_id;
+ size_t i;
+ int id, max_id;
char *pos;
char *buf = NULL;
unsigned long long *sum_cpu_time = NULL;
qemuGetPciHostDeviceList(virDomainHostdevDefPtr *hostdevs, int nhostdevs)
{
virPCIDeviceListPtr list;
- int i;
+ size_t i;
if (!(list = virPCIDeviceListNew()))
return NULL;
int nhostdevs)
{
virPCIDeviceListPtr list;
- int i;
+ size_t i;
if (!(list = virPCIDeviceListNew()))
return NULL;
{
virDomainHostdevDefPtr hostdev = NULL;
virPCIDevicePtr dev = NULL;
- int i;
+ size_t i;
int ret = -1;
if (!def->nhostdevs)
virDomainDefPtr def)
{
virDomainHostdevDefPtr hostdev = NULL;
- int i;
+ size_t i;
int ret = -1;
if (!def->nhostdevs)
virDomainDefPtr def)
{
virDomainHostdevDefPtr hostdev = NULL;
- int i;
+ size_t i;
int ret = -1;
if (!def->nhostdevs)
{
virPCIDeviceListPtr pcidevs;
int last_processed_hostdev_vf = -1;
- int i;
+ size_t i;
int ret = -1;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
const char *name,
virUSBDeviceListPtr list)
{
- int i, j;
+ size_t i, j;
unsigned int count;
virUSBDevicePtr tmp;
virDomainDefPtr def,
bool coldBoot)
{
- int i, ret = -1;
+ size_t i;
+ int ret = -1;
virUSBDeviceListPtr list;
virUSBDevicePtr tmp;
virDomainHostdevDefPtr *hostdevs = def->hostdevs;
virDomainHostdevDefPtr *hostdevs,
int nhostdevs)
{
- int i, j, count;
+ size_t i, j;
+ int count;
virSCSIDeviceListPtr list;
virSCSIDevicePtr tmp;
int nhostdevs)
{
virPCIDeviceListPtr pcidevs;
- int i;
+ size_t i;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
virObjectLock(driver->activePciHostdevs);
virDomainHostdevDefPtr *hostdevs,
int nhostdevs)
{
- int i;
+ size_t i;
virObjectLock(driver->activeUsbHostdevs);
for (i = 0; i < nhostdevs; i++) {
virDomainHostdevDefPtr *hostdevs,
int nhostdevs)
{
- int i;
+ size_t i;
virObjectLock(driver->activeScsiHostdevs);
for (i = 0; i < nhostdevs; i++) {
qemuDomainObjPrivatePtr priv = vm->privateData;
virHashTablePtr table = NULL;
int ret = -1;
- int i;
+ size_t i;
if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) == 0) {
table = qemuMonitorGetBlockInfo(priv->mon);
virDomainObjPtr vm,
virDomainDiskDefPtr disk)
{
- int i, ret = -1;
+ size_t i;
+ int ret = -1;
const char* type = virDomainDiskBusTypeToString(disk->bus);
qemuDomainObjPrivatePtr priv = vm->privateData;
char *devstr = NULL;
virDomainObjPtr vm,
int controller)
{
- int i;
+ size_t i;
virDomainControllerDefPtr cont;
for (i = 0; i < vm->def->ncontrollers; i++) {
virDomainObjPtr vm,
virDomainDiskDefPtr disk)
{
- int i;
+ size_t i;
qemuDomainObjPrivatePtr priv = vm->privateData;
virDomainControllerDefPtr cont = NULL;
char *drivestr = NULL;
virDomainDiskDefPtr disk)
{
qemuDomainObjPrivatePtr priv = vm->privateData;
- int i, ret = -1;
+ size_t i;
+ int ret = -1;
char *drivestr = NULL;
char *devstr = NULL;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
bool iface_connected = false;
int actualType;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
- int i;
+ size_t i;
/* preallocate new slot for device */
if (VIR_REALLOC_N(vm->def->nets, vm->def->nnets+1) < 0)
goto cleanup;
for (i = 0; i < tapfdSize; i++) {
- if (virAsprintf(&tapfdName[i], "fd-%s%d", net->info.alias, i) < 0)
+ if (virAsprintf(&tapfdName[i], "fd-%s%zu", net->info.alias, i) < 0)
goto cleanup;
}
for (i = 0; i < vhostfdSize; i++) {
- if (virAsprintf(&vhostfdName[i], "vhostfd-%s%d", net->info.alias, i) < 0)
+ if (virAsprintf(&vhostfdName[i], "vhostfd-%s%zu", net->info.alias, i) < 0)
goto cleanup;
}
static virDomainNetDefPtr *qemuDomainFindNet(virDomainObjPtr vm,
virDomainNetDefPtr dev)
{
- int i;
+ size_t i;
for (i = 0; i < vm->def->nnets; i++) {
if (virMacAddrCmp(&vm->def->nets[i]->mac, &dev->mac) == 0)
static virDomainGraphicsDefPtr qemuDomainFindGraphics(virDomainObjPtr vm,
virDomainGraphicsDefPtr dev)
{
- int i;
+ size_t i;
for (i = 0; i < vm->def->ngraphics; i++) {
if (vm->def->graphics[i]->type == dev->type)
static inline int qemuFindDisk(virDomainDefPtr def, const char *dst)
{
- int i;
+ size_t i;
for (i = 0; i < def->ndisks; i++) {
if (STREQ(def->disks[i]->dst, dst)) {
virDomainObjPtr vm,
virDomainDeviceDefPtr dev)
{
- int i, ret = -1;
+ int idx;
+ int ret = -1;
virDomainDiskDefPtr detach = NULL;
qemuDomainObjPrivatePtr priv = vm->privateData;
char *drivestr = NULL;
- i = qemuFindDisk(vm->def, dev->data.disk->dst);
+ idx = qemuFindDisk(vm->def, dev->data.disk->dst);
- if (i < 0) {
+ if (idx < 0) {
virReportError(VIR_ERR_OPERATION_FAILED,
_("disk %s not found"), dev->data.disk->dst);
goto cleanup;
}
- detach = vm->def->disks[i];
+ detach = vm->def->disks[idx];
if (qemuIsMultiFunctionDevice(vm->def, &detach->info)) {
virReportError(VIR_ERR_OPERATION_FAILED,
&detach->info.addr.pci) < 0)
VIR_WARN("Unable to release PCI address on %s", dev->data.disk->src);
- virDomainDiskRemove(vm->def, i);
+ virDomainDiskRemove(vm->def, idx);
dev->data.disk->backingChain = detach->backingChain;
detach->backingChain = NULL;
virDomainObjPtr vm,
virDomainDeviceDefPtr dev)
{
- int i, ret = -1;
+ int idx;
+ int ret = -1;
virDomainDiskDefPtr detach = NULL;
qemuDomainObjPrivatePtr priv = vm->privateData;
char *drivestr = NULL;
- i = qemuFindDisk(vm->def, dev->data.disk->dst);
+ idx = qemuFindDisk(vm->def, dev->data.disk->dst);
- if (i < 0) {
+ if (idx < 0) {
virReportError(VIR_ERR_OPERATION_FAILED,
_("disk %s not found"), dev->data.disk->dst);
goto cleanup;
goto cleanup;
}
- detach = vm->def->disks[i];
+ detach = vm->def->disks[idx];
if (detach->mirror) {
virReportError(VIR_ERR_BLOCK_COPY_ACTIVE,
virDomainAuditDisk(vm, detach->src, NULL, "detach", true);
- virDomainDiskRemove(vm->def, i);
+ virDomainDiskRemove(vm->def, idx);
dev->data.disk->backingChain = detach->backingChain;
detach->backingChain = NULL;
static bool qemuDomainDiskControllerIsBusy(virDomainObjPtr vm,
virDomainControllerDefPtr detach)
{
- int i;
+ size_t i;
virDomainDiskDefPtr disk;
for (i = 0; i < vm->def->ndisks; i++) {
virDomainLeaseDefPtr lease)
{
virDomainLeaseDefPtr det_lease;
- int i;
+ int idx;
- if ((i = virDomainLeaseIndex(vm->def, lease)) < 0) {
+ if ((idx = virDomainLeaseIndex(vm->def, lease)) < 0) {
virReportError(VIR_ERR_INVALID_ARG,
_("Lease %s in lockspace %s does not exist"),
lease->key, NULLSTR(lease->lockspace));
if (virDomainLockLeaseDetach(driver->lockManager, vm, lease) < 0)
return -1;
- det_lease = virDomainLeaseRemoveAt(vm->def, i);
+ det_lease = virDomainLeaseRemoveAt(vm->def, idx);
virDomainLeaseDefFree(det_lease);
return 0;
}
static void
qemuMigrationCookieNetworkFree(qemuMigrationCookieNetworkPtr network)
{
- int i;
+ size_t i;
if (!network)
return;
virDomainDefPtr def)
{
qemuMigrationCookieNetworkPtr mig;
- int i;
+ size_t i;
if (VIR_ALLOC(mig) < 0)
goto error;
qemuMigrationCookieNetworkXMLFormat(virBufferPtr buf,
qemuMigrationCookieNetworkPtr optr)
{
- int i;
+ size_t i;
bool empty = true;
for (i = 0; i < optr->nnets; i++) {
virBufferAddLit(buf, " <network>\n");
empty = false;
}
- virBufferAsprintf(buf, " <interface index='%d' vporttype='%s'",
+ virBufferAsprintf(buf, " <interface index='%zu' vporttype='%s'",
i, virNetDevVPortTypeToString(optr->net[i].vporttype));
if (optr->net[i].portdata) {
virBufferAddLit(buf, ">\n");
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
char hostuuidstr[VIR_UUID_STRING_BUFLEN];
- int i;
+ size_t i;
virUUIDFormat(mig->uuid, uuidstr);
virUUIDFormat(mig->localHostuuid, hostuuidstr);
qemuMigrationCookieNetworkXMLParse(xmlXPathContextPtr ctxt)
{
qemuMigrationCookieNetworkPtr optr;
- int i;
+ size_t i;
int n;
xmlNodePtr *interfaces = NULL;
char *vporttype;
char uuidstr[VIR_UUID_STRING_BUFLEN];
char *tmp = NULL;
xmlNodePtr *nodes = NULL;
- int i, n;
+ size_t i;
+ int n;
virCapsPtr caps = NULL;
if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
int nsnapshots;
int pauseReason;
bool forbid;
- int i;
+ size_t i;
if (vm) {
if (qemuProcessAutoDestroyActive(driver, vm)) {
static bool
qemuMigrationIsSafe(virDomainDefPtr def)
{
- int i;
+ size_t i;
for (i = 0; i < def->ndisks; i++) {
virDomainDiskDefPtr disk = def->disks[i];
}
if (uri) {
- int i;
+ size_t i;
if ((type = virDomainGraphicsTypeFromString(uri->scheme)) < 0) {
virReportError(VIR_ERR_INVALID_ARG,
{
virDomainNetDefPtr netptr;
int ret = -1;
- int i;
+ size_t i;
for (i = 0; i < cookie->network->nnets; i++) {
netptr = vm->def->nets[i];
static int
qemuMigrationVPAssociatePortProfiles(virDomainDefPtr def) {
- int i;
+ size_t i;
int last_good_net = -1;
virDomainNetDefPtr net;
return 0;
err_exit:
- for (i = 0; i < last_good_net; i++) {
+ for (i = 0; last_good_net != -1 && i < last_good_net; i++) {
net = def->nets[i];
if (virDomainNetGetActualType(net) == VIR_DOMAIN_NET_TYPE_DIRECT) {
ignore_value(virNetDevVPortProfileDisassociate(net->ifname,
char *qemuMonitorEscapeArg(const char *in)
{
int len = 0;
- int i, j;
+ size_t i, j;
char *out;
/* To pass through the QEMU monitor, we need to use escape
char *qemuMonitorUnescapeArg(const char *in)
{
- int i, j;
+ size_t i, j;
char *out;
int len = strlen(in);
char next;
# include <c-ctype.h>
static char * qemuMonitorEscapeNonPrintable(const char *text)
{
- int i;
+ size_t i;
virBuffer buf = VIR_BUFFER_INITIALIZER;
for (i = 0; text[i] != '\0'; i++) {
if (c_isprint(text[i]) ||
struct sockaddr_un addr;
int monfd;
int timeout = 3; /* In seconds */
- int ret, i = 0;
+ int ret;
+ size_t i = 0;
if ((monfd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
virReportSystemError(errno,
int *vhostfd, char **vhostfdName, int vhostfdSize)
{
int ret = -1;
- int i = 0, j = 0;
+ size_t i = 0, j = 0;
VIR_DEBUG("mon=%p netstr=%s tapfd=%p tapfdName=%p tapfdSize=%d "
"vhostfd=%p vhostfdName=%p vhostfdSize=%d",
int *vhostfd, char **vhostfdName, int vhostfdSize)
{
int ret = -1;
- int i = 0, j = 0;
+ size_t i = 0, j = 0;
VIR_DEBUG("mon=%p netdevstr=%s tapfd=%p tapfdName=%p tapfdSize=%d"
"vhostfd=%p vhostfdName=%p vhostfdSize=%d",
static void
qemuFreeKeywords(int nkeywords, char **keywords, char **values)
{
- int i;
+ size_t i;
for (i = 0; i < nkeywords; i++) {
VIR_FREE(keywords[i]);
VIR_FREE(values[i]);
char **keywords = NULL;
char **values = NULL;
int nkeywords = 0;
- int i;
+ size_t i;
if (!(ret = virJSONValueNewObject()))
goto error;
int ret;
virJSONValuePtr cmd = qemuMonitorJSONMakeCommand("cont", NULL);
virJSONValuePtr reply = NULL;
- int i = 0, timeout = 3;
+ size_t i = 0;
+ int timeout = 3;
if (!cmd)
return -1;
{
virJSONValuePtr data;
int ret = -1;
- int i;
+ size_t i;
int *threads = NULL;
int ncpus;
virHashTablePtr table)
{
int ret;
- int i;
+ size_t i;
virJSONValuePtr cmd = qemuMonitorJSONMakeCommand("query-block",
NULL);
long long *errs)
{
int ret;
- int i;
+ size_t i;
bool found = false;
virJSONValuePtr cmd = qemuMonitorJSONMakeCommand("query-blockstats",
NULL);
int qemuMonitorJSONGetBlockStatsParamsNumber(qemuMonitorPtr mon,
int *nparams)
{
- int ret, i, num = 0;
+ int ret, num = 0;
+ size_t i;
virJSONValuePtr cmd = qemuMonitorJSONMakeCommand("query-blockstats",
NULL);
virJSONValuePtr reply = NULL;
unsigned long long *extent)
{
int ret = -1;
- int i;
+ size_t i;
bool found = false;
virJSONValuePtr cmd = qemuMonitorJSONMakeCommand("query-blockstats",
NULL);
{
virJSONValuePtr data;
int ret = -1;
- int i;
+ size_t i;
if (!(data = virJSONValueObjectGet(reply, "return"))) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
virJSONValuePtr reply = NULL;
virJSONValuePtr keys = NULL;
virJSONValuePtr key = NULL;
- unsigned int i;
+ size_t i;
/* create the key data array */
if (!(keys = virJSONValueNewArray()))
for (i = 0; i < nkeycodes; i++) {
if (keycodes[i] > 0xffff) {
virReportError(VIR_ERR_OPERATION_FAILED,
- _("keycode %d is invalid: 0x%X"), i, keycodes[i]);
+ _("keycode %zu is invalid: 0x%X"), i, keycodes[i]);
goto cleanup;
}
virDomainBlockJobInfoPtr info)
{
virJSONValuePtr data;
- int nr_results, i;
+ int nr_results;
+ size_t i;
if (!info)
return -1;
{
virJSONValuePtr io_throttle;
int ret = -1;
- int i;
+ size_t i;
bool found = false;
io_throttle = virJSONValueObjectGet(result, "return");
virJSONValuePtr cmd;
virJSONValuePtr reply = NULL;
virJSONValuePtr caps;
- int i;
+ size_t i;
if (!(cmd = qemuMonitorJSONMakeCommand("query-migrate-capabilities",
NULL)))
VIR_DEBUG("Seen a password prompt [%s]", data + used);
#endif
if (msg->passwordHandler) {
- int i;
+ size_t i;
/* Try and handle the prompt. The handler is required
* to report a normal libvirt error */
if (msg->passwordHandler(mon, msg,
unsigned int *keycodes,
unsigned int nkeycodes)
{
- int i;
+ size_t i;
virBuffer buf = VIR_BUFFER_INITIALIZER;
char *cmd, *reply = NULL;
int ret = -1;
for (i = 0; i < nkeycodes; i++) {
if (keycodes[i] > 0xffff) {
virReportError(VIR_ERR_OPERATION_FAILED,
- _("keycode %d is invalid: 0x%X"),
+ _("keycode %zu is invalid: 0x%X"),
i, keycodes[i]);
virBufferFreeAndReset(&buf);
return -1;
qemuFindAgentConfig(virDomainDefPtr def)
{
virDomainChrSourceDefPtr config = NULL;
- int i;
+ size_t i;
for (i = 0; i < def->nchannels; i++) {
virDomainChrDefPtr channel = def->channels[i];
qemuProcessFindDomainDiskByPath(virDomainObjPtr vm,
const char *path)
{
- int i = virDomainDiskIndexByName(vm->def, path, true);
+ int idx = virDomainDiskIndexByName(vm->def, path, true);
- if (i >= 0)
- return vm->def->disks[i];
+ if (idx >= 0)
+ return vm->def->disks[idx];
virReportError(VIR_ERR_INTERNAL_ERROR,
_("no disk found with path %s"),
qemuProcessFindDomainDiskByAlias(virDomainObjPtr vm,
const char *alias)
{
- int i;
+ size_t i;
if (STRPREFIX(alias, QEMU_DRIVE_HOST_PREFIX))
alias += strlen(QEMU_DRIVE_HOST_PREFIX);
virDomainEventGraphicsAddressPtr localAddr = NULL;
virDomainEventGraphicsAddressPtr remoteAddr = NULL;
virDomainEventGraphicsSubjectPtr subject = NULL;
- int i;
+ size_t i;
if (VIR_ALLOC(localAddr) < 0)
goto error;
virHashTablePtr paths,
bool chardevfmt)
{
- int i;
+ size_t i;
const char *prefix = chardevfmt ? "char" : "";
for (i = 0; i < count; i++) {
virHashTablePtr paths)
{
bool chardevfmt = virQEMUCapsGet(qemuCaps, QEMU_CAPS_CHARDEV);
- int i = 0;
+ size_t i = 0;
if (qemuProcessLookupPTYs(vm->def->serials, vm->def->nserials,
paths, chardevfmt) < 0)
int fd ATTRIBUTE_UNUSED)
{
size_t offset = 0;
- int ret, i;
+ int ret;
+ size_t i;
/* The order in which QEMU prints out the PTY paths is
the order in which it procsses its serial and parallel
qemuPrepareCpumap(virQEMUDriverPtr driver,
virBitmapPtr nodemask)
{
- int i, hostcpus, maxcpu = QEMUD_CPUMASK_LEN;
+ size_t i;
+ int hostcpus, maxcpu = QEMUD_CPUMASK_LEN;
virBitmapPtr cpumap = NULL;
virCapsPtr caps = NULL;
}
for (i = 0; i < caps->host.nnumaCell; i++) {
- int j;
+ size_t j;
int cur_ncpus = caps->host.numaCell[i]->ncpus;
bool result;
if (virBitmapGetBit(nodemask, i, &result) < 0) {
{
qemuDomainObjPrivatePtr priv = vm->privateData;
virDomainDefPtr def = vm->def;
- int i;
+ size_t i;
int ret = 0;
for (i = 0; i < def->nnets; i++) {
int ret = 0;
qemuDomainObjPrivatePtr priv = vm->privateData;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
- int i;
+ size_t i;
for (i = 0; i < vm->def->ngraphics; ++i) {
virDomainGraphicsDefPtr graphics = vm->def->graphics[i];
int naddrs)
{
bool found = false;
- int i;
+ size_t i;
VIR_DEBUG("Look for %x:%x out of %d", vendor, product, naddrs);
VIR_DEBUG("Maybe %x:%x", addrs[i].vendor, addrs[i].product);
if (addrs[i].vendor == vendor &&
addrs[i].product == product) {
- VIR_DEBUG("Match %d", i);
+ VIR_DEBUG("Match %zu", i);
found = true;
break;
}
int naddrs)
{
unsigned int vendor = 0, product = 0;
- int i;
+ size_t i;
/* XXX should all these vendor/product IDs be kept in the
* actual device data structure instead ?
static int
qemuProcessNotifyNets(virDomainDefPtr def)
{
- int ii;
+ size_t i;
- for (ii = 0; ii < def->nnets; ii++) {
- virDomainNetDefPtr net = def->nets[ii];
+ for (i = 0; i < def->nnets; i++) {
+ virDomainNetDefPtr net = def->nets[i];
if (networkNotifyActualDevice(net) < 0)
return -1;
}
qemuProcessFiltersInstantiate(virConnectPtr conn,
virDomainDefPtr def)
{
- int i;
+ size_t i;
if (!conn)
return 1;
{
unsigned short port = 0;
unsigned short tlsPort;
- int i;
+ size_t i;
int defaultMode = graphics->data.spice.defaultMode;
bool needTLSPort = false;
virCommandPtr cmd = NULL;
struct qemuProcessHookData hookData;
unsigned long cur_balloon;
- int i;
+ size_t i;
char *nodeset = NULL;
virBitmapPtr nodemask = NULL;
unsigned int stop_flags;
virErrorPtr orig_err;
virDomainDefPtr def;
virNetDevVPortProfilePtr vport = NULL;
- int i;
+ size_t i;
int logfile = -1;
char *timestamp;
char ebuf[1024];
projects / people / liuw / libxenctrl-split / libvirt.git / commitdiff