strlen(def->seclabels[0]->label),
&c_info->ssidref)) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("libxenlight failed to resolve security label '%s'"),
+ _("libxenlight failed to resolve security label '%1$s'"),
def->seclabels[0]->label);
}
}
virUUIDFormat(def->uuid, uuidstr);
if (libxl_uuid_from_string(&c_info->uuid, uuidstr)) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("libxenlight failed to parse UUID '%s'"), uuidstr);
+ _("libxenlight failed to parse UUID '%1$s'"), uuidstr);
goto error;
}
default:
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unsupported chardev '%s'"), type);
+ _("unsupported chardev '%1$s'"), type);
return -1;
}
case VIR_DOMAIN_CLOCK_OFFSET_TIMEZONE:
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unsupported clock offset '%s'"),
+ _("unsupported clock offset '%1$s'"),
virDomainClockOffsetTypeToString(clock.offset));
return -1;
case VIR_DOMAIN_CLOCK_OFFSET_LAST:
default:
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unexpected clock offset '%d'"), clock.offset);
+ _("unexpected clock offset '%1$d'"), clock.offset);
return -1;
}
case VIR_DOMAIN_TIMER_NAME_HPET:
if (!hvm) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unsupported timer type (name) '%s'"),
+ _("unsupported timer type (name) '%1$s'"),
virDomainTimerNameTypeToString(clock.timers[i]->name));
return -1;
}
case VIR_DOMAIN_TIMER_NAME_PIT:
case VIR_DOMAIN_TIMER_NAME_ARMVTIMER:
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unsupported timer type (name) '%s'"),
+ _("unsupported timer type (name) '%1$s'"),
virDomainTimerNameTypeToString(clock.timers[i]->name));
return -1;
false));
if (libxl_cpuid_parse_config(&b_info->cpuid, xlCPU)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unsupported cpu feature '%s'"),
+ _("unsupported cpu feature '%1$s'"),
def->cpu->features[i].name);
return -1;
}
def->cpu->features[i].name, false));
if (libxl_cpuid_parse_config(&b_info->cpuid, xlCPU)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unsupported cpu feature '%s'"),
+ _("unsupported cpu feature '%1$s'"),
def->cpu->features[i].name);
return -1;
}
libxl_defbool_set(&b_info->u.hvm.nested_hvm, hasHwVirt);
} else {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unsupported nested HVM setting for %s machine on this Xen version"),
+ _("unsupported nested HVM setting for %1$s machine on this Xen version"),
def->os.machine);
return -1;
}
if (def->os.loader && def->os.loader->format != VIR_STORAGE_FILE_RAW) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Unsupported loader format '%s'"),
+ _("Unsupported loader format '%1$s'"),
virStorageFileFormatTypeToString(def->os.loader->format));
return -1;
}
if (def->emulator) {
if (!virFileExists(def->emulator)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("emulator '%s' not found"),
+ _("emulator '%1$s' not found"),
def->emulator);
return -1;
}
if (!virFileIsExecutable(def->emulator)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("emulator '%s' is not executable"),
+ _("emulator '%1$s' is not executable"),
def->emulator);
return -1;
}
case VIR_DOMAIN_MEMBALLOON_MODEL_VIRTIO_TRANSITIONAL:
case VIR_DOMAIN_MEMBALLOON_MODEL_VIRTIO_NON_TRANSITIONAL:
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unsupported balloon device model '%s'"),
+ _("unsupported balloon device model '%1$s'"),
virDomainMemballoonModelTypeToString(def->memballoon->model));
return -1;
case VIR_DOMAIN_MEMBALLOON_MODEL_NONE:
bitmap = virDomainNumaGetNodeCpumask(numa, i);
if (bitmap == NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("vnuma sibling %zu missing vcpus set"), i);
+ _("vnuma sibling %1$zu missing vcpus set"), i);
goto cleanup;
}
case VIR_STORAGE_NET_PROTOCOL_LAST:
case VIR_STORAGE_NET_PROTOCOL_NONE:
virReportError(VIR_ERR_NO_SUPPORT,
- _("Unsupported network block protocol '%s'"),
+ _("Unsupported network block protocol '%1$s'"),
virStorageNetProtocolTypeToString(src->protocol));
return NULL;
case VIR_STORAGE_NET_PROTOCOL_RBD:
if (strchr(src->path, ':')) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("':' not allowed in RBD source volume name '%s'"),
+ _("':' not allowed in RBD source volume name '%1$s'"),
src->path);
return NULL;
}
break;
default:
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("libxenlight does not support disk format %s "
- "with disk driver %s"),
+ _("libxenlight does not support disk format %1$s with disk driver %2$s"),
virStorageFileFormatTypeToString(format),
driver);
return -1;
break;
default:
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("libxenlight does not support disk format %s "
- "with disk driver %s"),
+ _("libxenlight does not support disk format %1$s with disk driver %2$s"),
virStorageFileFormatTypeToString(format),
driver);
return -1;
} else if (STREQ(driver, "file")) {
if (format != VIR_STORAGE_FILE_RAW) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("libxenlight does not support disk format %s "
- "with disk driver %s"),
+ _("libxenlight does not support disk format %1$s with disk driver %2$s"),
virStorageFileFormatTypeToString(format),
driver);
return -1;
} else if (STREQ(driver, "phy")) {
if (format != VIR_STORAGE_FILE_RAW) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("libxenlight does not support disk format %s "
- "with disk driver %s"),
+ _("libxenlight does not support disk format %1$s with disk driver %2$s"),
virStorageFileFormatTypeToString(format),
driver);
return -1;
x_disk->backend = LIBXL_DISK_BACKEND_PHY;
} else {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("libxenlight does not support disk driver %s"),
+ _("libxenlight does not support disk driver %1$s"),
driver);
return -1;
}
case VIR_DOMAIN_NET_TYPE_VDS:
case VIR_DOMAIN_NET_TYPE_LAST:
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unsupported interface type %s"),
+ _("unsupported interface type %1$s"),
virDomainNetTypeToString(l_nic->type));
goto cleanup;
}
0, 0, &err);
if (!regex) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Failed to compile regex %s"), err->message);
+ _("Failed to compile regex %1$s"), err->message);
return -1;
}
if (g_mkdir_with_parents(cfg->logDir, 0777) < 0) {
virReportSystemError(errno,
- _("failed to create log dir '%s'"),
+ _("failed to create log dir '%1$s'"),
cfg->logDir);
return -1;
}
} else {
if (virHostdevFindUSBDevice(hostdev, true, &usb) < 0) {
virReportError(VIR_ERR_OPERATION_FAILED,
- _("failed to find USB device busnum:devnum "
- "for %x:%x"),
+ _("failed to find USB device busnum:devnum for %1$x:%2$x"),
usbsrc->vendor, usbsrc->product);
goto cleanup;
}
case VIR_DOMAIN_VIDEO_TYPE_LAST:
default:
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("video type %s is not supported by libxl"),
+ _("video type %1$s is not supported by libxl"),
virDomainVideoTypeToString(def->videos[0]->type));
return -1;
}
if (virStrcpyStatic(info->model, virArchToString(hostarch)) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("host arch %s is too big for destination"),
+ _("host arch %1$s is too big for destination"),
virArchToString(hostarch));
goto cleanup;
}
if (!vm) {
virUUIDFormat(dom->uuid, uuidstr);
virReportError(VIR_ERR_NO_DOMAIN,
- _("no domain with matching uuid '%s' (%s)"),
+ _("no domain with matching uuid '%1$s' (%2$s)"),
uuidstr, dom->name);
return NULL;
}
if (vm->autostart && !virDomainObjIsActive(vm) &&
libxlDomainStartNew(driver, vm, false) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Failed to autostart VM '%s': %s"),
+ _("Failed to autostart VM '%1$s': %2$s"),
vm->def->name, virGetLastErrorMessage());
goto endjob;
}
libxl_driver->config = cfg;
if (g_mkdir_with_parents(cfg->stateDir, 0777) < 0) {
virReportSystemError(errno,
- _("failed to create state dir '%s'"),
+ _("failed to create state dir '%1$s'"),
cfg->stateDir);
goto error;
}
if (g_mkdir_with_parents(cfg->libDir, 0777) < 0) {
virReportSystemError(errno,
- _("failed to create lib dir '%s'"),
+ _("failed to create lib dir '%1$s'"),
cfg->libDir);
goto error;
}
if (g_mkdir_with_parents(cfg->saveDir, 0777) < 0) {
virReportSystemError(errno,
- _("failed to create save dir '%s'"),
+ _("failed to create save dir '%1$s'"),
cfg->saveDir);
goto error;
}
if (g_mkdir_with_parents(cfg->autoDumpDir, 0777) < 0) {
virReportSystemError(errno,
- _("failed to create dump dir '%s'"),
+ _("failed to create dump dir '%1$s'"),
cfg->autoDumpDir);
goto error;
}
if (g_mkdir_with_parents(cfg->channelDir, 0777) < 0) {
virReportSystemError(errno,
- _("failed to create channel dir '%s'"),
+ _("failed to create channel dir '%1$s'"),
cfg->channelDir);
goto error;
}
STRNEQ(conn->uri->path, "/") &&
STRNEQ(conn->uri->path, "/system")) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected Xen URI path '%s', try xen:///system"),
+ _("unexpected Xen URI path '%1$s', try xen:///system"),
conn->uri->path);
return VIR_DRV_OPEN_ERROR;
}
if (virDomainObjGetState(vm, NULL) != VIR_DOMAIN_PAUSED) {
if (libxlDomainPauseWrapper(cfg->ctx, vm->def->id) != 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Failed to suspend domain '%d' with libxenlight"),
+ _("Failed to suspend domain '%1$d' with libxenlight"),
vm->def->id);
goto endjob;
}
if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_PAUSED) {
if (libxlDomainUnpauseWrapper(cfg->ctx, vm->def->id) != 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Failed to resume domain '%d' with libxenlight"),
+ _("Failed to resume domain '%1$d' with libxenlight"),
vm->def->id);
goto endjob;
}
if (ret != ERROR_NOPARAVIRT) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Failed to shutdown domain '%d' with libxenlight"),
+ _("Failed to shutdown domain '%1$d' with libxenlight"),
vm->def->id);
ret = -1;
goto cleanup;
goto cleanup;
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Failed to shutdown domain '%d' with libxenlight"),
+ _("Failed to shutdown domain '%1$d' with libxenlight"),
vm->def->id);
ret = -1;
}
goto cleanup;
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Failed to reboot domain '%d' with libxenlight"),
+ _("Failed to reboot domain '%1$d' with libxenlight"),
vm->def->id);
ret = -1;
}
if (libxlDomainDestroyInternal(driver, vm) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Failed to destroy domain '%d'"), vm->def->id);
+ _("Failed to destroy domain '%1$d'"), vm->def->id);
goto endjob;
}
virCheckFlags(0, -1);
if (target != VIR_NODE_SUSPEND_TARGET_MEM) {
virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED,
- _("PMSuspend type %d not supported by libxenlight driver"),
+ _("PMSuspend type %1$d not supported by libxenlight driver"),
target);
return -1;
}
if (ret < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Failed to suspend domain '%d'"), vm->def->id);
+ _("Failed to suspend domain '%1$d'"), vm->def->id);
goto endjob;
}
priv = vm->privateData;
if (libxl_domain_resume(cfg->ctx, vm->def->id, 1, NULL) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Failed to resume domain '%d'"), vm->def->id);
+ _("Failed to resume domain '%1$d'"), vm->def->id);
goto endjob;
}
virDomainObjSetState(vm, VIR_DOMAIN_RUNNING, VIR_DOMAIN_RUNNING_WAKEUP);
if (flags & VIR_DOMAIN_MEM_LIVE) {
if (libxl_domain_setmaxmem(cfg->ctx, vm->def->id, newmem) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Failed to set maximum memory for domain '%d'"
- " with libxenlight"), vm->def->id);
+ _("Failed to set maximum memory for domain '%1$d' with libxenlight"),
+ vm->def->id);
goto endjob;
}
}
virObjectLock(vm);
if (res < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Failed to set memory for domain '%d'"
- " with libxenlight"), vm->def->id);
+ _("Failed to set memory for domain '%1$d' with libxenlight"),
+ vm->def->id);
goto endjob;
}
vm->def->mem.cur_balloon = newmem;
if (libxl_domain_info(cfg->ctx, &d_info, vm->def->id) != 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("libxl_domain_info failed for domain '%d'"),
+ _("libxl_domain_info failed for domain '%1$d'"),
vm->def->id);
goto cleanup;
}
if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_PAUSED) {
virReportError(VIR_ERR_OPERATION_INVALID,
- _("Domain '%d' has to be running because libxenlight will"
- " suspend it"), vm->def->id);
+ _("Domain '%1$d' has to be running because libxenlight will suspend it"),
+ vm->def->id);
goto cleanup;
}
if ((fd = virFileOpenAs(to, O_CREAT|O_TRUNC|O_WRONLY, S_IRUSR|S_IWUSR,
-1, -1, 0)) < 0) {
virReportSystemError(-fd,
- _("Failed to create domain save file '%s'"), to);
+ _("Failed to create domain save file '%1$s'"), to);
goto cleanup;
}
if (ret != 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Failed to save domain '%d' with libxenlight"),
+ _("Failed to save domain '%1$d' with libxenlight"),
vm->def->id);
ret = -1;
goto cleanup;
if (libxlDomainDestroyInternal(driver, vm) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Failed to destroy domain '%d'"), vm->def->id);
+ _("Failed to destroy domain '%1$d'"), vm->def->id);
goto cleanup;
}
virDomainObjGetState(vm, NULL) == VIR_DOMAIN_RUNNING) {
if (libxlDomainPauseWrapper(cfg->ctx, vm->def->id) != 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Before dumping core, failed to suspend domain '%d'"
- " with libxenlight"),
+ _("Before dumping core, failed to suspend domain '%1$d' with libxenlight"),
vm->def->id);
goto endjob;
}
virObjectLock(vm);
if (ret != 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Failed to dump core of domain '%d' with libxenlight"),
+ _("Failed to dump core of domain '%1$d' with libxenlight"),
vm->def->id);
ret = -1;
goto unpause;
if (flags & VIR_DUMP_CRASH) {
if (libxlDomainDestroyInternal(driver, vm) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Failed to destroy domain '%d'"), vm->def->id);
+ _("Failed to destroy domain '%1$d'"), vm->def->id);
goto unpause;
}
if (virDomainObjIsActive(vm) && paused) {
if (libxlDomainUnpauseWrapper(cfg->ctx, vm->def->id) != 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("After dumping core, failed to resume domain '%d' with"
- " libxenlight"), vm->def->id);
+ _("After dumping core, failed to resume domain '%1$d' with libxenlight"),
+ vm->def->id);
} else {
virDomainObjSetState(vm, VIR_DOMAIN_RUNNING,
VIR_DOMAIN_RUNNING_UNPAUSED);
(flags & (VIR_DOMAIN_VCPU_MAXIMUM | VIR_DOMAIN_VCPU_LIVE)) ==
(VIR_DOMAIN_VCPU_MAXIMUM | VIR_DOMAIN_VCPU_LIVE)) {
virReportError(VIR_ERR_INVALID_ARG,
- _("invalid flag combination: (0x%x)"), flags);
+ _("invalid flag combination: (0x%1$x)"), flags);
return -1;
}
if (nvcpus > max) {
virReportError(VIR_ERR_INVALID_ARG,
- _("requested vcpus is greater than max allowable"
- " vcpus for the domain: %d > %d"), nvcpus, max);
+ _("requested vcpus is greater than max allowable vcpus for the domain: %1$d > %2$d"),
+ nvcpus, max);
goto endjob;
}
case VIR_DOMAIN_VCPU_LIVE:
if (libxlSetVcpuonlineWrapper(cfg->ctx, vm->def->id, &map) != 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Failed to set vcpus for domain '%d'"
- " with libxenlight"), vm->def->id);
+ _("Failed to set vcpus for domain '%1$d' with libxenlight"),
+ vm->def->id);
goto endjob;
}
if (virDomainDefSetVcpus(vm->def, nvcpus) < 0)
case VIR_DOMAIN_VCPU_LIVE | VIR_DOMAIN_VCPU_CONFIG:
if (libxlSetVcpuonlineWrapper(cfg->ctx, vm->def->id, &map) != 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Failed to set vcpus for domain '%d'"
- " with libxenlight"), vm->def->id);
+ _("Failed to set vcpus for domain '%1$d' with libxenlight"),
+ vm->def->id);
goto endjob;
}
if (virDomainDefSetVcpus(vm->def, nvcpus) < 0 ||
}
if ((flags & VIR_DOMAIN_VCPU_LIVE) && (flags & VIR_DOMAIN_VCPU_CONFIG)) {
virReportError(VIR_ERR_INVALID_ARG,
- _("invalid flag combination: (0x%x)"), flags);
+ _("invalid flag combination: (0x%1$x)"), flags);
return -1;
}
if (!(vcpuinfo = virDomainDefGetVcpu(targetDef, vcpu)) ||
!vcpuinfo->online) {
virReportError(VIR_ERR_INVALID_ARG,
- _("vcpu '%u' is not active"), vcpu);
+ _("vcpu '%1$u' is not active"), vcpu);
goto endjob;
}
libxl_bitmap map = { .size = maplen, .map = cpumap };
if (libxl_set_vcpuaffinity(cfg->ctx, vm->def->id, vcpu, &map, NULL) != 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Failed to pin vcpu '%d' with libxenlight"),
+ _("Failed to pin vcpu '%1$d' with libxenlight"),
vcpu);
goto endjob;
}
if ((vcpuinfo = libxl_list_vcpu(cfg->ctx, vm->def->id, &maxcpu,
&hostcpus)) == NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Failed to list vcpus for domain '%d' with libxenlight"),
+ _("Failed to list vcpus for domain '%1$d' with libxenlight"),
vm->def->id);
goto cleanup;
}
goto cleanup;
} else {
virReportError(VIR_ERR_INVALID_ARG,
- _("unsupported config type %s"), nativeFormat);
+ _("unsupported config type %1$s"), nativeFormat);
goto cleanup;
}
} else {
virReportError(VIR_ERR_INVALID_ARG,
- _("unsupported config type %s"), nativeFormat);
+ _("unsupported config type %1$s"), nativeFormat);
goto cleanup;
}
if (!origdisk) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("No device with bus '%s' and target '%s'"),
+ _("No device with bus '%1$s' and target '%2$s'"),
virDomainDiskBusTypeToString(disk->bus), disk->dst);
goto cleanup;
}
if (origdisk->device != VIR_DOMAIN_DISK_DEVICE_CDROM) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Removable media not supported for %s device"),
+ _("Removable media not supported for %1$s device"),
virDomainDiskDeviceTypeToString(disk->device));
goto cleanup;
}
if ((ret = libxl_cdrom_insert(cfg->ctx, vm->def->id, &x_disk, NULL)) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("libxenlight failed to change media for disk '%s'"),
+ _("libxenlight failed to change media for disk '%1$s'"),
disk->dst);
goto cleanup;
}
if (l_disk->bus == VIR_DOMAIN_DISK_BUS_XEN) {
if (virDomainDiskIndexByName(vm->def, l_disk->dst, true) >= 0) {
virReportError(VIR_ERR_OPERATION_FAILED,
- _("target %s already exists"), l_disk->dst);
+ _("target %1$s already exists"), l_disk->dst);
goto cleanup;
}
if ((ret = libxl_device_disk_add(cfg->ctx, vm->def->id,
&x_disk, NULL)) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("libxenlight failed to attach disk '%s'"),
+ _("libxenlight failed to attach disk '%1$s'"),
l_disk->dst);
if (virDomainLockImageDetach(libxl_driver->lockManager,
vm, l_disk->src) < 0) {
} else {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("disk bus '%s' cannot be hotplugged."),
+ _("disk bus '%1$s' cannot be hotplugged."),
virDomainDiskBusTypeToString(l_disk->bus));
}
break;
case VIR_DOMAIN_DISK_DEVICE_LAST:
default:
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("disk device type '%s' cannot be hotplugged"),
+ _("disk device type '%1$s' cannot be hotplugged"),
virDomainDiskDeviceTypeToString(l_disk->device));
break;
}
if (virDomainHostdevFind(vm->def, hostdev, &found) >= 0) {
virReportError(VIR_ERR_OPERATION_FAILED,
- _("target pci device %04x:%02x:%02x.%d already exists"),
+ _("target pci device %1$04x:%2$02x:%3$02x.%4$d already exists"),
pcisrc->addr.domain, pcisrc->addr.bus,
pcisrc->addr.slot, pcisrc->addr.function);
goto cleanup;
if (libxl_device_pci_add(cfg->ctx, vm->def->id, &pcidev, 0) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("libxenlight failed to attach pci device %04x:%02x:%02x.%d"),
+ _("libxenlight failed to attach pci device %1$04x:%2$02x:%3$02x.%4$d"),
pcisrc->addr.domain, pcisrc->addr.bus,
pcisrc->addr.slot, pcisrc->addr.function);
goto error;
if (controller->type != VIR_DOMAIN_CONTROLLER_TYPE_USB) {
virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
- _("'%s' controller cannot be hot plugged."),
+ _("'%1$s' controller cannot be hot plugged."),
type);
goto cleanup;
}
if (virDomainControllerFind(vm->def, controller->type, controller->idx) >= 0) {
virReportError(VIR_ERR_OPERATION_FAILED,
- _("target %s:%d already exists"),
+ _("target %1$s:%2$d already exists"),
type, controller->idx);
goto cleanup;
}
if (libxl_device_usbdev_add(cfg->ctx, vm->def->id, &usbdev, 0) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("libxenlight failed to attach usb device Busnum:%3x, Devnum:%3x"),
+ _("libxenlight failed to attach usb device Busnum:%1$3x, Devnum:%2$3x"),
hostdev->source.subsys.u.usb.bus,
hostdev->source.subsys.u.usb.device);
goto reattach;
{
if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("hostdev mode '%s' not supported"),
+ _("hostdev mode '%1$s' not supported"),
virDomainHostdevModeTypeToString(hostdev->mode));
return -1;
}
default:
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("hostdev subsys type '%s' not supported"),
+ _("hostdev subsys type '%1$s' not supported"),
virDomainHostdevSubsysTypeToString(hostdev->source.subsys.type));
return -1;
}
dev->data.disk->dst,
false)) < 0) {
virReportError(VIR_ERR_OPERATION_FAILED,
- _("disk %s not found"), dev->data.disk->dst);
+ _("disk %1$s not found"), dev->data.disk->dst);
goto cleanup;
}
if ((ret = libxl_device_disk_remove(cfg->ctx, vm->def->id,
&x_disk, NULL)) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("libxenlight failed to detach disk '%s'"),
+ _("libxenlight failed to detach disk '%1$s'"),
l_disk->dst);
goto cleanup;
}
} else {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("disk bus '%s' cannot be hot unplugged."),
+ _("disk bus '%1$s' cannot be hot unplugged."),
virDomainDiskBusTypeToString(dev->data.disk->bus));
}
break;
case VIR_DOMAIN_DISK_DEVICE_LAST:
default:
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("device type '%s' cannot hot unplugged"),
+ _("device type '%1$s' cannot hot unplugged"),
virDomainDiskDeviceTypeToString(dev->data.disk->device));
break;
}
if (virDomainHasNet(vm->def, net)) {
virReportError(VIR_ERR_INVALID_ARG,
- _("network device with mac %s already exists"),
+ _("network device with mac %1$s already exists"),
virMacAddrFormat(&net->mac, mac));
goto cleanup;
}
case VIR_DOMAIN_DEVICE_AUDIO:
case VIR_DOMAIN_DEVICE_CRYPTO:
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("device type '%s' cannot be attached"),
+ _("device type '%1$s' cannot be attached"),
virDomainDeviceTypeToString(dev->type));
break;
}
disk = dev->data.disk;
if (virDomainDiskIndexByName(vmdef, disk->dst, true) >= 0) {
virReportError(VIR_ERR_INVALID_ARG,
- _("target %s already exists."), disk->dst);
+ _("target %1$s already exists."), disk->dst);
return -1;
}
virDomainDiskInsert(vmdef, disk);
net = dev->data.net;
if (virDomainHasNet(vmdef, net)) {
virReportError(VIR_ERR_INVALID_ARG,
- _("network device with mac %s already exists"),
+ _("network device with mac %1$s already exists"),
virMacAddrFormat(&net->mac, mac));
return -1;
}
idx = virDomainHostdevFind(vm->def, hostdev, &detach);
if (idx < 0) {
virReportError(VIR_ERR_OPERATION_FAILED,
- _("host pci device %04x:%02x:%02x.%d not found"),
+ _("host pci device %1$04x:%2$02x:%3$02x.%4$d not found"),
pcisrc->addr.domain, pcisrc->addr.bus,
pcisrc->addr.slot, pcisrc->addr.function);
goto cleanup;
if (libxlIsMultiFunctionDevice(vm->def, detach->info)) {
virReportError(VIR_ERR_OPERATION_FAILED,
- _("cannot hot unplug multifunction PCI device: %04x:%02x:%02x.%d"),
+ _("cannot hot unplug multifunction PCI device: %1$04x:%2$02x:%3$02x.%4$d"),
pcisrc->addr.domain, pcisrc->addr.bus,
pcisrc->addr.slot, pcisrc->addr.function);
goto error;
if (libxl_device_pci_remove(cfg->ctx, vm->def->id, &pcidev, 0) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("libxenlight failed to detach pci device %04x:%02x:%02x.%d"),
+ _("libxenlight failed to detach pci device %1$04x:%2$02x:%3$02x.%4$d"),
pcisrc->addr.domain, pcisrc->addr.bus,
pcisrc->addr.slot, pcisrc->addr.function);
goto error;
if (controller->type != VIR_DOMAIN_CONTROLLER_TYPE_USB) {
virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
- _("'%s' controller cannot be hot plugged."),
+ _("'%1$s' controller cannot be hot plugged."),
type);
goto cleanup;
}
controller->type,
controller->idx)) < 0) {
virReportError(VIR_ERR_OPERATION_FAILED,
- _("controller %s:%d not found"),
+ _("controller %1$s:%2$d not found"),
type, controller->idx);
goto cleanup;
}
idx = virDomainHostdevFind(vm->def, hostdev, &detach);
if (idx < 0) {
virReportError(VIR_ERR_OPERATION_FAILED,
- _("host USB device Busnum: %3x, Devnum: %3x not found"),
+ _("host USB device Busnum: %1$3x, Devnum: %2$3x not found"),
usbsrc->bus, usbsrc->device);
goto cleanup;
}
if (!found) {
virReportError(VIR_ERR_OPERATION_FAILED,
- _("host USB device Busnum: %3x, Devnum: %3x not found"),
+ _("host USB device Busnum: %1$3x, Devnum: %2$3x not found"),
usbsrc->bus, usbsrc->device);
goto cleanup;
}
if (libxl_device_usbdev_remove(cfg->ctx, vm->def->id, &usbdev, 0) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("libxenlight failed to detach USB device "
- "Busnum: %3x, Devnum: %3x"),
+ _("libxenlight failed to detach USB device Busnum: %1$3x, Devnum: %2$3x"),
usbsrc->bus, usbsrc->device);
goto cleanup;
}
if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("hostdev mode '%s' not supported"),
+ _("hostdev mode '%1$s' not supported"),
virDomainHostdevModeTypeToString(hostdev->mode));
return -1;
}
default:
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected hostdev type %d"), subsys->type);
+ _("unexpected hostdev type %1$d"), subsys->type);
break;
}
case VIR_DOMAIN_DEVICE_AUDIO:
case VIR_DOMAIN_DEVICE_CRYPTO:
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("device type '%s' cannot be detached"),
+ _("device type '%1$s' cannot be detached"),
virDomainDeviceTypeToString(dev->type));
break;
}
disk = dev->data.disk;
if (!(detach = virDomainDiskRemoveByName(vmdef, disk->dst))) {
virReportError(VIR_ERR_INVALID_ARG,
- _("no target device %s"), disk->dst);
+ _("no target device %1$s"), disk->dst);
return -1;
}
virDomainDiskDefFree(detach);
case VIR_DOMAIN_DISK_DEVICE_LAST:
default:
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("disk bus '%s' cannot be updated."),
+ _("disk bus '%1$s' cannot be updated."),
virDomainDiskBusTypeToString(disk->bus));
break;
}
case VIR_DOMAIN_DEVICE_AUDIO:
case VIR_DOMAIN_DEVICE_CRYPTO:
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("device type '%s' cannot be updated"),
+ _("device type '%1$s' cannot be updated"),
virDomainDeviceTypeToString(dev->type));
break;
}
disk = dev->data.disk;
if (!(orig = virDomainDiskByTarget(vmdef, disk->dst))) {
virReportError(VIR_ERR_INVALID_ARG,
- _("target %s doesn't exist."), disk->dst);
+ _("target %1$s doesn't exist."), disk->dst);
return -1;
}
if (!(orig->device == VIR_DOMAIN_DISK_DEVICE_CDROM)) {
/* Check/sanitize the cell range */
if (startCell >= nr_nodes) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("start cell %d out of range (0-%d)"),
+ _("start cell %1$d out of range (0-%2$d)"),
startCell, nr_nodes - 1);
goto cleanup;
}
if (autostart) {
if (g_mkdir_with_parents(cfg->autostartDir, 0777) < 0) {
virReportSystemError(errno,
- _("cannot create autostart directory %s"),
+ _("cannot create autostart directory %1$s"),
cfg->autostartDir);
goto endjob;
}
if (symlink(configFile, autostartLink) < 0) {
virReportSystemError(errno,
- _("Failed to create symlink '%s' to '%s'"),
+ _("Failed to create symlink '%1$s' to '%2$s'"),
autostartLink, configFile);
goto endjob;
}
} else {
if (unlink(autostartLink) < 0 && errno != ENOENT && errno != ENOTDIR) {
virReportSystemError(errno,
- _("Failed to delete symlink '%s'"),
+ _("Failed to delete symlink '%1$s'"),
autostartLink);
goto endjob;
}
break;
default:
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Failed to get scheduler id for domain '%d'"
- " with libxenlight"), vm->def->id);
+ _("Failed to get scheduler id for domain '%1$d' with libxenlight"),
+ vm->def->id);
goto cleanup;
}
if (libxl_domain_sched_params_get(cfg->ctx, vm->def->id, &sc_info) != 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Failed to get scheduler parameters for domain '%d'"
- " with libxenlight"), vm->def->id);
+ _("Failed to get scheduler parameters for domain '%1$d' with libxenlight"),
+ vm->def->id);
goto cleanup;
}
if (libxl_domain_sched_params_get(cfg->ctx, vm->def->id, &sc_info) != 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Failed to get scheduler parameters for domain '%d'"
- " with libxenlight"), vm->def->id);
+ _("Failed to get scheduler parameters for domain '%1$d' with libxenlight"),
+ vm->def->id);
goto endjob;
}
if (libxl_domain_sched_params_set(cfg->ctx, vm->def->id, &sc_info) != 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Failed to set scheduler parameters for domain '%d'"
- " with libxenlight"), vm->def->id);
+ _("Failed to set scheduler parameters for domain '%1$d' with libxenlight"),
+ vm->def->id);
goto endjob;
}
if (!chr) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("cannot find character device %s"),
+ _("cannot find character device %1$s"),
NULLSTR(dev_name));
goto cleanup;
}
if (chr->source->type != VIR_DOMAIN_CHR_TYPE_PTY) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("character device %s is not using a PTY"),
+ _("character device %1$s is not using a PTY"),
dev_name ? dev_name : NULLSTR(chr->info.alias));
goto cleanup;
}
libxl_for_each_set_bit(j, nodemap) {
if (virBitmapSetBit(nodes, j)) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Node %zu out of range"), j);
+ _("Node %1$zu out of range"), j);
goto cleanup;
}
}
if (libxl_domain_info(cfg->ctx, &d_info, vm->def->id) != 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("libxl_domain_info failed for domain '%d'"),
+ _("libxl_domain_info failed for domain '%1$d'"),
vm->def->id);
goto cleanup;
}
if ((vcpuinfo = libxl_list_vcpu(cfg->ctx, vm->def->id, &maxcpu,
&hostcpus)) == NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Failed to list vcpus for domain '%d' with libxenlight"),
+ _("Failed to list vcpus for domain '%1$d' with libxenlight"),
vm->def->id);
goto cleanup;
}
if (libxl_domain_info(cfg->ctx, &d_info, vm->def->id) != 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("libxl_domain_info failed for domain '%d'"),
+ _("libxl_domain_info failed for domain '%1$d'"),
vm->def->id);
goto endjob;
}
if ((virFileReadAll(name, 256, &val) < 0) || \
(sscanf(val, "%llu", &status) != 1)) { \
virReportError(VIR_ERR_OPERATION_FAILED, \
- _("cannot read %s"), name); \
+ _("cannot read %1$s"), name); \
goto cleanup; \
} \
VAR += (status * MUL); \
if (!(disk = virDomainDiskByName(vm->def, path, false))) {
virReportError(VIR_ERR_OPERATION_INVALID,
- _("invalid path: %s"), path);
+ _("invalid path: %1$s"), path);
return ret;
}
if (STREQ(disk_drv, "phy")) {
if (disk_fmt != VIR_STORAGE_FILE_RAW) {
virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
- _("unsupported format %s"),
+ _("unsupported format %1$s"),
virStorageFileFormatTypeToString(disk_fmt));
return ret;
}
ret = libxlDomainBlockStatsVBD(vm, disk->dst, stats);
} else {
virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
- _("unsupported disk driver %s"),
+ _("unsupported disk driver %1$s"),
disk_drv);
}
return ret;
case VIR_DRV_FEATURE_NETWORK_UPDATE_HAS_CORRECT_ORDER:
case VIR_DRV_FEATURE_FD_PASSING:
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Global feature %d should have already been handled"),
+ _("Global feature %1$d should have already been handled"),
feature);
return -1;
case VIR_DRV_FEATURE_MIGRATION_V3:
if (STRNEQ(driverName, "xen")) {
virReportError(VIR_ERR_INVALID_ARG,
- _("unsupported driver name '%s'"), driverName);
+ _("unsupported driver name '%1$s'"), driverName);
return -1;
}
!(vm = virDomainObjListFindByName(driver->domains, dname))) {
/* Migration obviously failed if the domain doesn't exist */
virReportError(VIR_ERR_OPERATION_FAILED,
- _("Migration failed. No domain on destination host "
- "with matching name '%s'"),
+ _("Migration failed. No domain on destination host with matching name '%1$s'"),
NULLSTR(dname));
return NULL;
}
default:
virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED,
- _("Unsupported IP address data source %d"),
+ _("Unsupported IP address data source %1$d"),
source);
break;
}
if (virttype_str &&
(virttype = virDomainVirtTypeFromString(virttype_str)) < 0) {
virReportError(VIR_ERR_INVALID_ARG,
- _("unknown virttype: %s"),
+ _("unknown virttype: %1$s"),
virttype_str);
goto cleanup;
}
if (virttype != VIR_DOMAIN_VIRT_XEN) {
virReportError(VIR_ERR_INVALID_ARG,
- _("unknown virttype: %s"),
+ _("unknown virttype: %1$s"),
virttype_str);
goto cleanup;
}
if (arch_str && (arch = virArchFromString(arch_str)) == VIR_ARCH_NONE) {
virReportError(VIR_ERR_INVALID_ARG,
- _("unknown architecture: %s"),
+ _("unknown architecture: %1$s"),
arch_str);
goto cleanup;
}
*value = STREQ(val->str, "1") ? 1 : 0;
} else {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("config value %s was malformed"), name);
+ _("config value %1$s was malformed"), name);
return -1;
}
return 0;
} else if (val->type == VIR_CONF_STRING) {
if (virStrToLong_ul(val->str, NULL, 10, value) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("config value %s was malformed"), name);
+ _("config value %1$s was malformed"), name);
return -1;
}
} else {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("config value %s was malformed"), name);
+ _("config value %1$s was malformed"), name);
return -1;
}
return 0;
} else if (val->type == VIR_CONF_STRING) {
if (virStrToLong_ull(val->str, NULL, 10, value) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("config value %s was malformed"), name);
+ _("config value %1$s was malformed"), name);
return -1;
}
} else {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("config value %s was malformed"), name);
+ _("config value %1$s was malformed"), name);
return -1;
}
return 0;
if (allowMissing)
return 0;
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("config value %s was missing"), name);
+ _("config value %1$s was missing"), name);
return -1;
}
if (!string) {
virReportError(VIR_ERR_CONF_SYNTAX,
- _("%s can't be empty"), name);
+ _("%1$s can't be empty"), name);
return -1;
}
if (virUUIDParse(string, uuid) < 0) {
virReportError(VIR_ERR_CONF_SYNTAX,
- _("%s not parseable"), string);
+ _("%1$s not parseable"), string);
return -1;
}
virConfValue *value = NULL;
if ((long)l != l) {
- virReportError(VIR_ERR_OVERFLOW, _("failed to store %lld to %s"),
+ virReportError(VIR_ERR_OVERFLOW, _("failed to store %1$lld to %2$s"),
l, setting);
return -1;
}
if ((def->onPoweroff = virDomainLifecycleActionTypeFromString(on_poweroff)) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected value %s for on_poweroff"), on_poweroff);
+ _("unexpected value %1$s for on_poweroff"), on_poweroff);
return -1;
}
if ((def->onReboot = virDomainLifecycleActionTypeFromString(on_reboot)) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected value %s for on_reboot"), on_reboot);
+ _("unexpected value %1$s for on_reboot"), on_reboot);
return -1;
}
if ((def->onCrash = virDomainLifecycleActionTypeFromString(on_crash)) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected value %s for on_crash"), on_crash);
+ _("unexpected value %1$s for on_crash"), on_crash);
return -1;
}
str = tokens[nexttoken];
if (!(nextstr = strchr(str, '.'))) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Malformed PCI address %s"), str);
+ _("Malformed PCI address %1$s"), str);
return NULL;
}
*nextstr = '\0';
if (!(val = strchr(options[i], '='))) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Malformed PCI options %s"), str);
+ _("Malformed PCI options %1$s"), str);
return NULL;
}
*val = '\0';
def->xen_passthrough_mode = VIR_DOMAIN_XEN_PASSTHROUGH_MODE_SHARE_PT;
} else {
virReportError(VIR_ERR_CONF_SYNTAX,
- _("Invalid passthrough mode %s"), passthrough);
+ _("Invalid passthrough mode %1$s"), passthrough);
}
}
if (virStrcpyStatic(vfb, *vfbs) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("VFB %s too big for destination"),
+ _("VFB %1$s too big for destination"),
*vfbs);
goto cleanup;
}
if (virStrToLong_i(key + 11, NULL, 10,
&graphics->data.vnc.port) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("invalid vncdisplay value '%s'"),
+ _("invalid vncdisplay value '%1$s'"),
key + 11);
goto cleanup;
}
} else {
if ((def->source->type = virDomainChrTypeFromString(prefix)) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unknown chr device type '%s'"), prefix);
+ _("unknown chr device type '%1$s'"), prefix);
goto error;
}
}
regex = g_regex_new(vif_bytes_per_sec_re, 0, 0, &err);
if (!regex) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Failed to compile regex %s"), err->message);
+ _("Failed to compile regex %1$s"), err->message);
return -1;
}
if (!g_regex_match(regex, trate, 0, NULL)) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Invalid rate '%s' specified"), rate);
+ _("Invalid rate '%1$s' specified"), rate);
return -1;
}
if (virStrToLong_ull(rate, &suffix, 10, &tmp)) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Failed to parse rate '%s'"), rate);
+ _("Failed to parse rate '%1$s'"), rate);
return -1;
}
if (mac) {
if (virMacAddrParse(mac, &net->mac) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("malformed mac address '%s'"), mac);
+ _("malformed mac address '%1$s'"), mac);
goto cleanup;
}
}
def->os.type = VIR_DOMAIN_OSTYPE_HVM;
} else {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("type %s is not supported"), str);
+ _("type %1$s is not supported"), str);
return -1;
}
} else {
return -1;
} else {
virReportError(VIR_ERR_INVALID_ARG,
- _("unsupported config type %s"), nativeFormat);
+ _("unsupported config type %1$s"), nativeFormat);
return -1;
}
default:
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unsupported chr device type '%s'"), type);
+ _("unsupported chr device type '%1$s'"), type);
return -1;
}
virObjectUnref(network);
if (!bridge) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("network %s is not active"),
+ _("network %1$s is not active"),
net->data.network.name);
return -1;
}
case VIR_DOMAIN_NET_TYPE_VDPA:
case VIR_DOMAIN_NET_TYPE_NULL:
case VIR_DOMAIN_NET_TYPE_VDS:
- virReportError(VIR_ERR_CONFIG_UNSUPPORTED, _("Unsupported net type '%s'"),
+ virReportError(VIR_ERR_CONFIG_UNSUPPORTED, _("Unsupported net type '%1$s'"),
virDomainNetTypeToString(net->type));
return -1;
break;
default:
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unsupported clock offset='%s'"),
+ _("unsupported clock offset='%1$s'"),
virDomainClockOffsetTypeToString(def->clock.offset));
return -1;
}
break;
default:
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unsupported clock offset='%s'"),
+ _("unsupported clock offset='%1$s'"),
virDomainClockOffsetTypeToString(def->clock.offset));
return -1;
}
if (!(lifecycle = virDomainLifecycleActionTypeToString(def->onPoweroff))) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected lifecycle action %d"), def->onPoweroff);
+ _("unexpected lifecycle action %1$d"), def->onPoweroff);
return -1;
}
if (xenConfigSetString(conf, "on_poweroff", lifecycle) < 0)
if (!(lifecycle = virDomainLifecycleActionTypeToString(def->onReboot))) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected lifecycle action %d"), def->onReboot);
+ _("unexpected lifecycle action %1$d"), def->onReboot);
return -1;
}
if (xenConfigSetString(conf, "on_reboot", lifecycle) < 0)
if (!(lifecycle = virDomainLifecycleActionTypeToString(def->onCrash))) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected lifecycle action %d"), def->onCrash);
+ _("unexpected lifecycle action %1$d"), def->onCrash);
return -1;
}
if (xenConfigSetString(conf, "on_crash", lifecycle) < 0)
return -1;
} else {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unsupported timer type (name) '%s'"),
+ _("unsupported timer type (name) '%1$s'"),
virDomainTimerNameTypeToString(def->clock.timers[i]->name));
return -1;
}
case VIR_DOMAIN_TIMER_NAME_PIT:
case VIR_DOMAIN_TIMER_NAME_ARMVTIMER:
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unsupported timer type (name) '%s'"),
+ _("unsupported timer type (name) '%1$s'"),
virDomainTimerNameTypeToString(def->clock.timers[i]->name));
return -1;
for (i = 0; i < def->nsounds; i++) {
if (!(model = virDomainSoundModelTypeToString(def->sounds[i]->model))) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected sound model %d"),
+ _("unexpected sound model %1$d"),
def->sounds[i]->model);
return -1;
}
return -1;
} else {
virReportError(VIR_ERR_INVALID_ARG,
- _("unsupported config type %s"), nativeFormat);
+ _("unsupported config type %1$s"), nativeFormat);
return -1;
}
projects / libvirt.git / commitdiff