case VIR_DOMAIN_KEY_WRAP_CIPHER_NAME_AES:
if (keywrap->aes != VIR_TRISTATE_SWITCH_ABSENT) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("A domain definition can have no more than "
- "one cipher node with name %s"),
+ _("A domain definition can have no more than one cipher node with name %1$s"),
virDomainKeyWrapCipherNameTypeToString(name));
return -1;
case VIR_DOMAIN_KEY_WRAP_CIPHER_NAME_DEA:
if (keywrap->dea != VIR_TRISTATE_SWITCH_ABSENT) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("A domain definition can have no more than "
- "one cipher node with name %s"),
+ _("A domain definition can have no more than one cipher node with name %1$s"),
virDomainKeyWrapCipherNameTypeToString(name));
return -1;
if ((weight = virXPathString("string(./weight)", ctxt)) &&
(virStrToLong_ui(weight, NULL, 10, &dev->weight) < 0)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("could not parse weight %s"), weight);
+ _("could not parse weight %1$s"), weight);
return -1;
}
if ((read_bytes_sec = virXPathString("string(./read_bytes_sec)", ctxt)) &&
(virStrToLong_ull(read_bytes_sec, NULL, 10, &dev->rbps) < 0)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("could not parse read bytes sec %s"),
+ _("could not parse read bytes sec %1$s"),
read_bytes_sec);
return -1;
}
if ((write_bytes_sec = virXPathString("string(./write_bytes_sec)", ctxt)) &&
(virStrToLong_ull(write_bytes_sec, NULL, 10, &dev->wbps) < 0)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("could not parse write bytes sec %s"),
+ _("could not parse write bytes sec %1$s"),
write_bytes_sec);
return -1;
}
if ((read_iops_sec = virXPathString("string(./read_iops_sec)", ctxt)) &&
(virStrToLong_ui(read_iops_sec, NULL, 10, &dev->riops) < 0)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("could not parse read iops sec %s"),
+ _("could not parse read iops sec %1$s"),
read_iops_sec);
return -1;
}
if ((write_iops_sec = virXPathString("string(./write_iops_sec)", ctxt)) &&
(virStrToLong_ui(write_iops_sec, NULL, 10, &dev->wiops) < 0)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("could not parse write iops sec %s"),
+ _("could not parse write iops sec %1$s"),
write_iops_sec);
return -1;
}
if (!(vcpuinfo = virDomainDefGetVcpu(def, vcpu))) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("vCPU '%u' is not present in domain definition"),
+ _("vCPU '%1$u' is not present in domain definition"),
vcpu);
return NULL;
}
(tmp *= def->cpu->cores) > UINT_MAX ||
(tmp *= def->cpu->threads) > UINT_MAX) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("cpu topology results in more than %u cpus"), UINT_MAX);
+ _("cpu topology results in more than %1$u cpus"), UINT_MAX);
return -1;
}
}
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Lifecycle event '%s' doesn't support '%s' action"),
+ _("Lifecycle event '%1$s' doesn't support '%2$s' action"),
virDomainLifecycleTypeToString(type),
virDomainLifecycleActionTypeToString(action));
return false;
{
if (virStringIsEmpty(loadparm) || !STRLIM(loadparm, 8)) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("loadparm value '%s' must be between 1 and 8 characters"),
+ _("loadparm value '%1$s' must be between 1 and 8 characters"),
loadparm);
return false;
}
if (strspn(loadparm, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789. ") != strlen(loadparm)) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("invalid loadparm value '%s', expecting chars in set of [a-zA-Z0-9.] and blank spaces"),
+ _("invalid loadparm value '%1$s', expecting chars in set of [a-zA-Z0-9.] and blank spaces"),
loadparm);
return false;
}
if (loadparm) {
if (virStringToUpper(&info->loadparm, loadparm) != 1) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Failed to convert loadparm '%s' to upper case"),
+ _("Failed to convert loadparm '%1$s' to upper case"),
loadparm);
return -1;
}
if ((info->type = virDomainDeviceAddressTypeFromString(type)) <= 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unknown address type '%s'"), type);
+ _("unknown address type '%1$s'"), type);
return -1;
}
if ((state = virDomainHostdevPCIOrigstateTypeFromString((const char *) nodes[i]->name)) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unsupported element '%s' of 'origstates'"),
+ _("unsupported element '%1$s' of 'origstates'"),
(const char *) nodes[i]->name);
return -1;
}
host->transport = virStorageNetHostTransportTypeFromString(transport);
if (host->transport < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unknown protocol transport type '%s'"),
+ _("unknown protocol transport type '%1$s'"),
transport);
goto cleanup;
}
if (host->transport != VIR_STORAGE_NET_HOST_TRANS_UNIX &&
host->socket != NULL) {
virReportError(VIR_ERR_XML_ERROR,
- _("transport '%s' does not support "
- "socket attribute"),
+ _("transport '%1$s' does not support socket attribute"),
transport);
goto cleanup;
}
return -1;
if ((auth_secret_usage = virSecretUsageTypeFromString(authdef->secrettype)) < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("invalid secret type %s"),
+ _("invalid secret type %1$s"),
authdef->secrettype);
return -1;
}
if (auth_secret_usage != VIR_SECRET_USAGE_TYPE_ISCSI) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("hostdev invalid secret type '%s'"),
+ _("hostdev invalid secret type '%1$s'"),
authdef->secrettype);
return -1;
}
virDomainHostdevSubsysSCSIProtocolTypeFromString(protocol);
if (scsisrc->protocol < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Unknown SCSI subsystem protocol '%s'"),
+ _("Unknown SCSI subsystem protocol '%1$s'"),
protocol);
return -1;
}
if ((hostsrc->protocol =
virDomainHostdevSubsysSCSIHostProtocolTypeFromString(protocol)) <= 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Unknown scsi_host subsystem protocol '%s'"),
+ _("Unknown scsi_host subsystem protocol '%1$s'"),
protocol);
return -1;
}
case VIR_DOMAIN_HOSTDEV_SUBSYS_SCSI_HOST_PROTOCOL_TYPE_NONE:
case VIR_DOMAIN_HOSTDEV_SUBSYS_SCSI_HOST_PROTOCOL_TYPE_LAST:
virReportError(VIR_ERR_XML_ERROR,
- _("Invalid hostdev protocol '%s'"),
+ _("Invalid hostdev protocol '%1$s'"),
virDomainHostdevSubsysSCSIHostProtocolTypeToString(hostsrc->protocol));
return -1;
}
if ((def->source.subsys.type = virDomainHostdevSubsysTypeFromString(type)) < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unknown host device source address type '%s'"),
+ _("unknown host device source address type '%1$s'"),
type);
return -1;
}
def->source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_SCSI_HOST) {
if (model) {
virReportError(VIR_ERR_XML_ERROR,
- _("'model' attribute in <hostdev> is only supported "
- "when type='%s'"),
+ _("'model' attribute in <hostdev> is only supported when type='%1$s'"),
virDomainHostdevSubsysTypeToString(def->source.subsys.type));
return -1;
}
default:
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("address type='%s' not supported in hostdev interfaces"),
+ _("address type='%1$s' not supported in hostdev interfaces"),
virDomainHostdevSubsysTypeToString(def->source.subsys.type));
return -1;
}
if (virSocketAddrParse(&ip->address, address, family) < 0) {
virReportError(VIR_ERR_XML_ERROR,
- _("Invalid address '%s' in <ip>"),
+ _("Invalid address '%1$s' in <ip>"),
address);
return NULL;
}
(family == AF_INET6 && prefixValue > 128) ||
(family == AF_INET && prefixValue > 32))) {
virReportError(VIR_ERR_XML_ERROR,
- _("Invalid prefix value '%s' in <ip>"),
+ _("Invalid prefix value '%1$s' in <ip>"),
prefixStr);
return NULL;
}
if ((peer = virXMLPropString(node, "peer")) != NULL &&
virSocketAddrParse(&ip->peer, peer, family) < 0) {
virReportError(VIR_ERR_INVALID_ARG,
- _("Invalid peer '%s' in <ip>"), peer);
+ _("Invalid peer '%1$s' in <ip>"), peer);
return NULL;
}
if (virStrToLong_ullp(str, NULL, 10, &tmp) < 0) {
virReportError(VIR_ERR_XML_DETAIL,
- _("cannot parse value '%s' for coalesce parameter"),
+ _("cannot parse value '%1$s' for coalesce parameter"),
str);
return -1;
}
if (tmp > UINT32_MAX) {
virReportError(VIR_ERR_OVERFLOW,
- _("value '%llu' is too big for coalesce "
- "parameter, maximum is '%lu'"),
+ _("value '%1$llu' is too big for coalesce parameter, maximum is '%2$lu'"),
tmp, (unsigned long) UINT32_MAX);
return -1;
}
if ((def->source.caps.type = virDomainHostdevCapsTypeFromString(type)) < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unknown host device source address type '%s'"),
+ _("unknown host device source address type '%1$s'"),
type);
return -1;
}
break;
default:
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("address type='%s' not supported in hostdev interfaces"),
+ _("address type='%1$s' not supported in hostdev interfaces"),
virDomainHostdevCapsTypeToString(def->source.caps.type));
return -1;
}
int idx = virDiskNameToIndex(def->dst);
if (idx < 0) {
virReportError(VIR_ERR_XML_ERROR,
- _("Unknown disk name '%s' and no address specified"),
+ _("Unknown disk name '%1$s' and no address specified"),
def->dst);
return -1;
}
VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_SCSI,
&addr)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("using disk target name '%s' conflicts with "
- "SCSI host device address controller='%u' "
- "bus='%u' target='%u' unit='%u"),
+ _("using disk target name '%1$s' conflicts with SCSI host device address controller='%2$u' bus='%3$u' target='%4$u' unit='%5$u"),
def->dst, controller, 0, 0, unit);
return -1;
}
} else {
if (seclabel->type != VIR_DOMAIN_SECLABEL_NONE) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unsupported type='%s' to model 'none'"),
+ _("unsupported type='%1$s' to model 'none'"),
virDomainSeclabelTypeToString(seclabel->type));
return NULL;
}
for (j = 0; j < i; j++) {
if (STREQ_NULLABLE(seclabel->model, def->seclabels[j]->model)) {
virReportError(VIR_ERR_XML_DETAIL,
- _("seclabel for model %s is already provided"),
+ _("seclabel for model %1$s is already provided"),
seclabel->model);
virSecurityLabelDefFree(seclabel);
goto error;
for (j = 0; j < i; j++) {
if (STREQ_NULLABLE(model, seclabels[j]->model)) {
virReportError(VIR_ERR_XML_DETAIL,
- _("seclabel for model %s is already provided"), model);
+ _("seclabel for model %1$s is already provided"), model);
goto error;
}
}
if (seclabels[i]->label && !seclabels[i]->relabel) {
virReportError(VIR_ERR_XML_ERROR,
- _("Cannot specify a label if relabelling is "
- "turned off. model=%s"),
- NULLSTR(seclabels[i]->model));
+ _("Cannot specify a label if relabelling is turned off. model=%1$s"),
+ NULLSTR(seclabels[i]->model));
goto error;
}
}
if (mode &&
(source->mode = virStorageSourcePoolModeTypeFromString(mode)) <= 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unknown source mode '%s' for volume type disk"),
+ _("unknown source mode '%1$s' for volume type disk"),
mode);
goto cleanup;
}
}
if (!(cookie->value = virXPathString("string(.)", ctxt))) {
- virReportError(VIR_ERR_XML_ERROR, _("missing value for cookie '%s'"),
+ virReportError(VIR_ERR_XML_ERROR, _("missing value for cookie '%1$s'"),
cookie->name);
return NULL;
}
if (!(tmp = strchr(src->path, '/')) ||
tmp == src->path) {
virReportError(VIR_ERR_XML_ERROR,
- _("can't split path '%s' into pool name and image "
- "name"), src->path);
+ _("can't split path '%1$s' into pool name and image name"),
+ src->path);
return -1;
}
if (STRNEQ(type, "pci")) {
virReportError(VIR_ERR_XML_ERROR,
- _("unsupported source type '%s'"),
+ _("unsupported source type '%1$s'"),
type);
return -1;
}
if (virStrToLong_ull(namespc, NULL, 10, &nvme->namespc) < 0) {
virReportError(VIR_ERR_XML_ERROR,
- _("malformed namespace '%s'"),
+ _("malformed namespace '%1$s'"),
namespc);
return -1;
}
int tmp;
if ((tmp = virStorageTypeFromString(type)) <= 0) {
virReportError(VIR_ERR_XML_ERROR,
- _("unknown storage source type '%s'"), type);
+ _("unknown storage source type '%1$s'"), type);
return NULL;
}
if (format &&
(src->format = virStorageFileFormatTypeFromString(format)) <= 0) {
virReportError(VIR_ERR_XML_ERROR,
- _("unknown storage source format '%s'"), format);
+ _("unknown storage source format '%1$s'"), format);
return NULL;
}
if (index &&
virStrToLong_uip(index, NULL, 10, &src->id) < 0) {
virReportError(VIR_ERR_XML_ERROR,
- _("invalid storage source index '%s'"), index);
+ _("invalid storage source index '%1$s'"), index);
return NULL;
}
if (virStrToLong_ullp(offset, NULL, 10, &ret->offset) < 0) {
virReportError(VIR_ERR_XML_ERROR,
- _("malformed value '%s' of 'offset' attribute of slice"),
+ _("malformed value '%1$s' of 'offset' attribute of slice"),
offset);
return NULL;
}
if (virStrToLong_ullp(size, NULL, 10, &ret->size) < 0) {
virReportError(VIR_ERR_XML_ERROR,
- _("malformed value '%s' of 'size' attribute of slice"),
+ _("malformed value '%1$s' of 'size' attribute of slice"),
size);
return NULL;
}
case VIR_STORAGE_TYPE_NONE:
case VIR_STORAGE_TYPE_LAST:
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected disk type %s"),
+ _("unexpected disk type %1$s"),
virStorageTypeToString(src->type));
return -1;
}
if (virXPathULongLong("string(./iotune/" #val ")", \
ctxt, &def->blkdeviotune.val) == -2) { \
virReportError(VIR_ERR_XML_ERROR, \
- _("disk iotune field '%s' must be an integer"), #val); \
+ _("disk iotune field '%1$s' must be an integer"), #val); \
return -1; \
}
if ((blockJob = virXMLPropString(cur, "job"))) {
if ((def->mirrorJob = virDomainBlockJobTypeFromString(blockJob)) <= 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unknown mirror job type '%s'"), blockJob);
+ _("unknown mirror job type '%1$s'"), blockJob);
return -1;
}
} else {
if ((ready = virXMLPropString(cur, "ready")) &&
(def->mirrorState = virDomainDiskMirrorStateTypeFromString(ready)) < 0) {
virReportError(VIR_ERR_XML_ERROR,
- _("unknown mirror ready state %s"), ready);
+ _("unknown mirror ready state %1$s"), ready);
return -1;
}
if (def->rerror_policy == VIR_DOMAIN_DISK_ERROR_POLICY_ENOSPACE) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Invalid disk read error policy: '%s'"),
+ _("Invalid disk read error policy: '%1$s'"),
virDomainDiskErrorPolicyTypeToString(def->rerror_policy));
return -1;
}
} else {
if ((src->format = virStorageFileFormatTypeFromString(tmp)) <= 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unknown driver format value '%s'"), tmp);
+ _("unknown driver format value '%1$s'"), tmp);
return -1;
}
}
if ((sourceindex = virXMLPropString(tmp, "index")) &&
virStrToLong_uip(sourceindex, NULL, 10, &src->id) < 0) {
virReportError(VIR_ERR_XML_ERROR,
- _("invalid disk index '%s'"), sourceindex);
+ _("invalid disk index '%1$s'"), sourceindex);
return NULL;
}
}
if ((model = virXMLPropString(node, "model"))) {
if ((def->model = virDomainControllerModelTypeFromString(def, model)) < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Unknown model type '%s'"), model);
+ _("Unknown model type '%1$s'"), model);
return NULL;
}
}
} else if (rv > 0) {
if (def->fmode > 0777) {
virReportError(VIR_ERR_XML_ERROR,
- _("invalid fmode: '0%o'"), def->fmode);
+ _("invalid fmode: '0%1$o'"), def->fmode);
goto error;
}
}
} else if (rv > 0) {
if (def->dmode > 0777) {
virReportError(VIR_ERR_XML_ERROR,
- _("invalid dmode: '0%o'"), def->dmode);
+ _("invalid dmode: '0%1$o'"), def->dmode);
goto error;
}
}
if ((format = virXMLPropString(driver_node, "format")) &&
((def->format = virStorageFileFormatTypeFromString(format)) <= 0)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unknown driver format value '%s'"), format);
+ _("unknown driver format value '%1$s'"), format);
goto error;
}
if (queue_size && virStrToLong_ull(queue_size, NULL, 10, &def->queue_size) < 0) {
virReportError(VIR_ERR_XML_ERROR,
- _("cannot parse queue size '%s' for virtiofs"),
+ _("cannot parse queue size '%1$s' for virtiofs"),
queue_size);
goto error;
}
if (thread_pool_size &&
virStrToLong_i(thread_pool_size, NULL, 10, &def->thread_pool_size) < 0) {
virReportError(VIR_ERR_XML_ERROR,
- _("cannot parse thread pool size '%s' for virtiofs"),
+ _("cannot parse thread pool size '%1$s' for virtiofs"),
thread_pool_size);
goto error;
}
}
if (virStrToLong_ull(usage, NULL, 10, &def->usage) < 0) {
virReportError(VIR_ERR_XML_ERROR,
- _("cannot parse usage '%s' for RAM filesystem"),
+ _("cannot parse usage '%1$s' for RAM filesystem"),
usage);
goto error;
}
actual->type != VIR_DOMAIN_NET_TYPE_HOSTDEV &&
actual->type != VIR_DOMAIN_NET_TYPE_NETWORK) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unsupported type '%s' in interface's <actual> element"),
+ _("unsupported type '%
1$s' in interface's <actual> element"),
virDomainNetTypeToString(actual->type));
goto error;
}
}
} else {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("<virtualport> element unsupported for type='%s'"
- " in interface's <actual> element"),
+ _("<virtualport> element unsupported for type='%1$s' in interface's <actual> element"),
virDomainNetTypeToString(actual->type));
goto error;
}
if (class_id &&
virStrToLong_ui(class_id, NULL, 10, &actual->class_id) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Unable to parse class id '%s'"),
+ _("Unable to parse class id '%1$s'"),
class_id);
goto error;
}
(actual->data.bridge.macTableManager
= virNetworkBridgeMACTableManagerTypeFromString(macTableManager)) <= 0) {
virReportError(VIR_ERR_XML_ERROR,
- _("Invalid macTableManager setting '%s' "
- "in domain interface's <actual> element"),
+ _("Invalid macTableManager setting '%1$s' in domain interface's <actual> element"),
macTableManager);
goto error;
}
if ((tmpType = virDomainNetTeamingTypeFromString(typeStr)) <= 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unknown teaming type '%s'"),
+ _("unknown teaming type '%1$s'"),
typeStr);
return -1;
}
address = virXMLPropString(node, "address");
if (address && virSocketAddrParse(&def->address, address, AF_UNSPEC) < 0) {
virReportError(VIR_ERR_XML_ERROR,
- _("Invalid address '%s' in <portForward>"), address);
+ _("Invalid address '%
1$s' in <portForward>"), address);
return NULL;
}
{
if (!source_node) {
virReportError(VIR_ERR_XML_ERROR,
- _("interface type='%s' requires a 'source' element"),
+ _("interface type='%1$s' requires a 'source' element"),
virDomainNetTypeToString(def->type));
return -1;
}
if (STRNEQ_NULLABLE(vhostuser_type, "unix")) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Type='%s' unsupported for <interface type='vhostuser'>"),
+ _("Type='%1$s' unsupported for <interface type='vhostuser'>"),
vhostuser_type);
return NULL;
}
if ((virtualport_node = virXPathNode("./virtualport", ctxt))) {
if (virtualport_flags == 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("<virtualport> element unsupported for <interface type='%s'>"),
+ _("<virtualport> element unsupported for <interface type='%1$s'>"),
virDomainNetTypeToString(def->type));
return NULL;
}
if ((macaddr = virXMLPropString(mac_node, "address"))) {
if (virMacAddrParse((const char *)macaddr, &def->mac) < 0) {
virReportError(VIR_ERR_XML_ERROR,
- _("unable to parse mac address '%s'"),
+ _("unable to parse mac address '%1$s'"),
(const char *)macaddr);
return NULL;
}
if (virMacAddrIsMulticast(&def->mac)) {
virReportError(VIR_ERR_XML_ERROR,
- _("expected unicast mac address, found multicast '%s'"),
+ _("expected unicast mac address, found multicast '%1$s'"),
(const char *)macaddr);
return NULL;
}
if (linkstate != NULL) {
if ((def->linkstate = virDomainNetInterfaceLinkStateTypeFromString(linkstate)) <= 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unknown interface link state '%s'"),
+ _("unknown interface link state '%1$s'"),
linkstate);
return NULL;
}
switch ((virDomainChrDeviceType) devtype) {
case VIR_DOMAIN_CHR_DEVICE_TYPE_CHANNEL:
virReportError(VIR_ERR_XML_ERROR,
- _("target type must be specified for %s device"),
+ _("target type must be specified for %1$s device"),
virDomainChrDeviceTypeToString(devtype));
return -1;
virDomainChrTargetTypeFromString(def->deviceType,
targetType)) < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unknown target type '%s' specified for character device"),
+ _("unknown target type '%1$s' specified for character device"),
targetType);
return -1;
}
virDomainChrTargetModelFromString(def->deviceType,
targetModel)) < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unknown target model '%s' specified for character device"),
+ _("unknown target model '%1$s' specified for character device"),
targetModel);
return -1;
}
if (virStrToLong_ui(portStr, NULL, 10, &port) < 0) {
virReportError(VIR_ERR_XML_ERROR,
- _("Invalid port number: %s"),
+ _("Invalid port number: %1$s"),
portStr);
return -1;
}
(def->data.tcp.protocol =
virDomainChrTcpProtocolTypeFromString(prot)) < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Unknown protocol '%s'"), prot);
+ _("Unknown protocol '%1$s'"), prot);
return -1;
}
def->source->type = VIR_DOMAIN_CHR_TYPE_PTY;
} else if ((def->source->type = virDomainChrTypeFromString(type)) < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unknown type presented to host for character device: %s"),
+ _("unknown type presented to host for character device: %1$s"),
type);
goto error;
}
nodeName = (const char *) node->name;
if ((def->deviceType = virDomainChrDeviceTypeFromString(nodeName)) < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unknown character device type: %s"),
+ _("unknown character device type: %1$s"),
nodeName);
goto error;
}
if (*def->data.cert.database != '/') {
virReportError(VIR_ERR_XML_ERROR,
- _("expecting absolute path: %s"),
+ _("expecting absolute path: %1$s"),
def->data.cert.database);
return NULL;
}
if ((def->data.passthru->type = virDomainChrTypeFromString(type)) < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unknown type presented to host for "
- "character device: %s"), type);
+ _("unknown type presented to host for character device: %1$s"),
+ type);
return NULL;
}
if (secretuuid) {
if (virUUIDParse(secretuuid, def->data.emulator.secretuuid) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Unable to parse secret uuid '%s'"), secretuuid);
+ _("Unable to parse secret uuid '%1$s'"), secretuuid);
goto error;
}
def->data.emulator.hassecretuuid = true;
for (i = 0; i < nnodes; i++) {
if ((bank = virDomainTPMPcrBankTypeFromString((const char *)nodes[i]->name)) < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Unsupported PCR banks '%s'"),
+ _("Unsupported PCR banks '%1$s'"),
nodes[i]->name);
goto error;
}
def->data.external.source->type = virDomainChrTypeFromString(type);
if (def->data.external.source->type < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unknown backend source type '%s' for external TPM"),
+ _("unknown backend source type '%1$s' for external TPM"),
type);
goto error;
}
if (model != NULL &&
(panic->model = virDomainPanicModelTypeFromString(model)) < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unknown panic model '%s'"), model);
+ _("unknown panic model '%1$s'"), model);
goto error;
}
if ((def->type = virDomainInputTypeFromString(type)) < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unknown input device type '%s'"), type);
+ _("unknown input device type '%1$s'"), type);
goto error;
}
((def->model = virDomainInputModelTypeFromString(model)) < 0 ||
def->model == VIR_DOMAIN_INPUT_MODEL_DEFAULT)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unknown input model '%s'"), model);
+ _("unknown input model '%1$s'"), model);
goto error;
}
if (bus) {
if ((def->bus = virDomainInputBusTypeFromString(bus)) < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unknown input bus type '%s'"), bus);
+ _("unknown input bus type '%1$s'"), bus);
goto error;
}
if ((def->type = virDomainHubTypeFromString(type)) < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unknown hub device type '%s'"), type);
+ _("unknown hub device type '%1$s'"), type);
goto error;
}
/* second */
virStrToLong_i(tmp+1, &tmp, 10, &sec) < 0 || *tmp != '\0') {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("cannot parse password validity time '%s', expect YYYY-MM-DDTHH:MM:SS"),
+ _("cannot parse password validity time '%1$s', expect YYYY-MM-DDTHH:MM:SS"),
validTo);
VIR_FREE(def->passwd);
return -1;
int action = virDomainGraphicsAuthConnectedTypeFromString(connected);
if (action <= 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unknown connected value %s"),
+ _("unknown connected value %1$s"),
connected);
return -1;
}
if (graphics->type != VIR_DOMAIN_GRAPHICS_TYPE_VNC &&
graphics->type != VIR_DOMAIN_GRAPHICS_TYPE_SPICE) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("listen type 'socket' is not available for "
- "graphics type '%s'"), graphicsType);
+ _("listen type 'socket' is not available for graphics type '%1$s'"),
+ graphicsType);
goto error;
}
break;
if (graphics->type != VIR_DOMAIN_GRAPHICS_TYPE_SPICE &&
graphics->type != VIR_DOMAIN_GRAPHICS_TYPE_VNC) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("listen type 'none' is not available for "
- "graphics type '%s'"), graphicsType);
+ _("listen type 'none' is not available for graphics type '%1$s'"),
+ graphicsType);
goto error;
}
break;
if (def->type == VIR_DOMAIN_GRAPHICS_LISTEN_TYPE_ADDRESS) {
if (address && addressCompat && STRNEQ(address, addressCompat)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("graphics 'listen' attribute '%s' must match "
- "'address' attribute of first listen element "
- "(found '%s')"), addressCompat, address);
+ _("graphics 'listen' attribute '%1$s' must match 'address' attribute of first listen element (found '%2$s')"),
+ addressCompat, address);
goto error;
}
if (def->type == VIR_DOMAIN_GRAPHICS_LISTEN_TYPE_SOCKET) {
if (socketPath && socketCompat && STRNEQ(socketPath, socketCompat)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("graphics 'socket' attribute '%s' must match "
- "'socket' attribute of first listen element "
- "(found '%s')"), socketCompat, socketPath);
+ _("graphics 'socket' attribute '%1$s' must match 'socket' attribute of first listen element (found '%2$s')"),
+ socketCompat, socketPath);
goto error;
}
flags & VIR_DOMAIN_DEF_PARSE_STATUS) {
if (virStringParseYesNo(autoGenerated, &def->autoGenerated) < 0) {
virReportError(VIR_ERR_XML_ERROR,
- _("Invalid autoGenerated value: %s"),
+ _("Invalid autoGenerated value: %1$s"),
autoGenerated);
goto error;
}
if (port) {
if (virStrToLong_i(port, NULL, 10, &def->data.vnc.port) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("cannot parse vnc port %s"), port);
+ _("cannot parse vnc port %1$s"), port);
return -1;
}
/* Legacy compat syntax, used -1 for auto-port */
if (port) {
if (virStrToLong_i(port, NULL, 10, &def->data.rdp.port) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("cannot parse rdp port %s"), port);
+ _("cannot parse rdp port %1$s"), port);
return -1;
}
/* Legacy compat syntax, used -1 for auto-port */
type = virXMLPropString(node, "type");
if ((def->type = virDomainSoundCodecTypeFromString(type)) < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unknown codec type '%s'"), type);
+ _("unknown codec type '%1$s'"), type);
goto error;
}
if (dspPolicySet != 0) {
if (def->backend.oss.dspPolicy < 0) {
virReportError(VIR_ERR_XML_ERROR,
- _("cannot parse 'dspPolicy' value '%i'"),
+ _("cannot parse 'dspPolicy' value '%1$i'"),
def->backend.oss.dspPolicy);
goto error;
}
def->model = virDomainWatchdogModelTypeFromString(model);
if (def->model < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unknown watchdog model '%s'"), model);
+ _("unknown watchdog model '%1$s'"), model);
goto error;
}
def->action = virDomainWatchdogActionTypeFromString(action);
if (def->action < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unknown watchdog action '%s'"), action);
+ _("unknown watchdog action '%1$s'"), action);
goto error;
}
}
}
if ((def->model = virDomainRNGModelTypeFromString(model)) < 0) {
- virReportError(VIR_ERR_CONFIG_UNSUPPORTED, _("unknown RNG model '%s'"), model);
+ virReportError(VIR_ERR_CONFIG_UNSUPPORTED, _("unknown RNG model '%1$s'"), model);
goto error;
}
if ((def->backend = virDomainRNGBackendTypeFromString(backend)) < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unknown RNG backend model '%s'"), backend);
+ _("unknown RNG backend model '%1$s'"), backend);
goto error;
}
def->source.chardev->type = virDomainChrTypeFromString(type);
if (def->source.chardev->type < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unknown backend type '%s' for egd"),
+ _("unknown backend type '%1$s' for egd"),
type);
goto error;
}
if (mode) {
if ((def->mode = virDomainHostdevModeTypeFromString(mode)) < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unknown hostdev mode '%s'"), mode);
+ _("unknown hostdev mode '%1$s'"), mode);
goto error;
}
} else {
break;
default:
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Unexpected hostdev mode %d"), def->mode);
+ _("Unexpected hostdev mode %1$d"), def->mode);
goto error;
}
if (bus) {
if ((def->bus = virDomainRedirdevBusTypeFromString(bus)) < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unknown redirdev bus '%s'"), bus);
+ _("unknown redirdev bus '%1$s'"), bus);
goto error;
}
} else {
if (type) {
if ((def->source->type = virDomainChrTypeFromString(type)) < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unknown redirdev character device type '%s'"), type);
+ _("unknown redirdev character device type '%1$s'"), type);
goto error;
}
} else {
error:
virReportError(VIR_ERR_XML_ERROR,
- _("Cannot parse USB device version %s"), version);
+ _("Cannot parse USB device version %1$s"), version);
return -1;
}
if (def->usbClass != -1 && def->usbClass &~ 0xFF) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Invalid USB Class code 0x%x"), def->usbClass);
+ _("Invalid USB Class code 0x%1$x"), def->usbClass);
return NULL;
}
*val = convFunc(tmp);
if (*val < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unknown %s action: %s"), name, tmp);
+ _("unknown %1$s action: %2$s"), name, tmp);
return -1;
}
}
if (perf->events[name] != VIR_TRISTATE_BOOL_ABSENT) {
virReportError(VIR_ERR_XML_ERROR,
- _("perf event '%s' was already specified"),
+ _("perf event '%1$s' was already specified"),
virPerfEventTypeToString(name));
return -1;
}
if (virBitmapIsAllClear(def->sourceNodes)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Invalid value of 'nodemask': %s"), nodemask);
+ _("Invalid value of 'nodemask': %1$s"), nodemask);
return -1;
}
}
if (virBitmapIsAllClear(def->sourceNodes)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Invalid value of 'nodemask': %s"), nodemask);
+ _("Invalid value of 'nodemask': %1$s"), nodemask);
return -1;
}
}
case VIR_DOMAIN_LAUNCH_SECURITY_LAST:
default:
virReportError(VIR_ERR_XML_ERROR,
- _("unsupported launch security type '%s'"),
+ _("unsupported launch security type '%1$s'"),
virDomainLaunchSecurityTypeToString(sec->sectype));
return NULL;
}
if ((tmp = virDomainDeviceTypeFromString(typestr)) < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unknown device type '%s'"), typestr);
+ _("unknown device type '%1$s'"), typestr);
return -1;
}
*/
if (MACAddrSpecified) {
virReportError(VIR_ERR_OPERATION_FAILED,
- _("multiple devices matching MAC address %s found"),
+ _("multiple devices matching MAC address %1$s found"),
macAddr);
} else {
virReportError(VIR_ERR_OPERATION_FAILED, "%s",
addr = g_strdup(_("(<null>)"));
virReportError(VIR_ERR_DEVICE_MISSING,
- _("no device found at address '%s' matching MAC address"
- " '%s' and alias '%s'"),
+ _("no device found at address '%1$s' matching MAC address '%2$s' and alias '%3$s'"),
addr, macAddr, alias);
return -1;
}
if (!contTypeStr) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Unknown controller type %d"),
+ _("Unknown controller type %1$d"),
type);
return NULL;
}
contIndex = virDomainControllerFind(def, type, idx);
if (contIndex < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Could not find %s controller with index %d "
- "required for device"),
+ _("Could not find %1$s controller with index %2$d required for device"),
contTypeStr, idx);
return NULL;
}
if (!def->controllers[contIndex]->info.alias) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Device alias was not set for %s controller with index %d"),
+ _("Device alias was not set for %1$s controller with index %2$d"),
contTypeStr, idx);
return NULL;
}
}
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Unknown char device type: %d"), type);
+ _("Unknown char device type: %1$d"), type);
return -1;
}
tmp = virXPathString("string(./iothreads[1])", ctxt);
if (tmp && virStrToLong_uip(tmp, NULL, 10, &iothreads) < 0) {
virReportError(VIR_ERR_XML_ERROR,
- _("invalid iothreads count '%s'"), tmp);
+ _("invalid iothreads count '%1$s'"), tmp);
return -1;
}
if (virDomainIOThreadIDFind(def, iothrid->iothread_id)) {
virReportError(VIR_ERR_XML_ERROR,
- _("duplicate iothread id '%u' found"),
+ _("duplicate iothread id '%1$u' found"),
iothrid->iothread_id);
return -1;
}
if (vcpu->cpumask) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("duplicate vcpupin for vcpu '%d'"), vcpuid);
+ _("duplicate vcpupin for vcpu '%1$d'"), vcpuid);
return -1;
}
if (virBitmapIsAllClear(vcpu->cpumask)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Invalid value of 'cpuset': %s"), tmp);
+ _("Invalid value of 'cpuset': %1$s"), tmp);
return -1;
}
if (!(iothrid = virDomainIOThreadIDFind(def, iothreadid))) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Cannot find 'iothread' : %u"),
+ _("Cannot find 'iothread' : %1$u"),
iothreadid);
return -1;
}
if (virBitmapIsAllClear(cpumask)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Invalid value of 'cpuset': %s"),
+ _("Invalid value of 'cpuset': %1$s"),
tmp);
return -1;
}
if (iothrid->cpumask) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("duplicate iothreadpin for same iothread '%u'"),
+ _("duplicate iothreadpin for same iothread '%1$u'"),
iothreadid);
return -1;
}
if (virBitmapIsAllClear(def)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Invalid value of 'cpuset': %s"), tmp);
+ _("Invalid value of 'cpuset': %1$s"), tmp);
return NULL;
}
if (virBitmapIsAllClear(hugepage->nodemask)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Invalid value of 'nodeset': %s"), nodeset);
+ _("Invalid value of 'nodeset': %1$s"), nodeset);
return -1;
}
}
feature = virDomainHypervTypeFromString((const char *)node->name);
if (feature < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unsupported HyperV Enlightenment feature: %s"),
+ _("unsupported HyperV Enlightenment feature: %1$s"),
node->name);
return -1;
}
while (child) {
if (STRNEQ((const char *)child->name, "direct")) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unsupported Hyper-V stimer feature: %s"),
+ _("unsupported Hyper-V stimer feature: %1$s"),
child->name);
return -1;
}
if (!STRLIM(def->hyperv_vendor_id, VIR_DOMAIN_HYPERV_VENDOR_ID_MAX)) {
virReportError(VIR_ERR_XML_ERROR,
- _("HyperV vendor_id value must not be more than %d characters."),
+ _("HyperV vendor_id value must not be more than %1$d characters."),
VIR_DOMAIN_HYPERV_VENDOR_ID_MAX);
return -1;
}
feature = virDomainKVMTypeFromString((const char *)node->name);
if (feature < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unsupported KVM feature: %s"),
+ _("unsupported KVM feature: %1$s"),
node->name);
return -1;
}
feature = virDomainXenTypeFromString((const char *)node->name);
if (feature < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unsupported Xen feature: %s"),
+ _("unsupported Xen feature: %1$s"),
node->name);
return -1;
}
int val = virDomainProcessCapsFeatureTypeFromString((const char *)node->name);
if (val < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unexpected capability feature '%s'"), node->name);
+ _("unexpected capability feature '%1$s'"), node->name);
return -1;
}
int val = virDomainFeatureTypeFromString((const char *)nodes[i]->name);
if (val < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unexpected feature '%s'"), nodes[i]->name);
+ _("unexpected feature '%1$s'"), nodes[i]->name);
return -1;
}
if (format != VIR_STORAGE_FILE_RAW &&
format != VIR_STORAGE_FILE_QCOW2) {
virReportError(VIR_ERR_XML_ERROR,
- _("Unsupported nvram format '%s'"),
+ _("Unsupported nvram format '%1$s'"),
virStorageFileFormatTypeToString(format));
return -1;
}
if (format != VIR_STORAGE_FILE_RAW &&
format != VIR_STORAGE_FILE_QCOW2) {
virReportError(VIR_ERR_XML_ERROR,
- _("Unsupported loader format '%s'"),
+ _("Unsupported loader format '%1$s'"),
virStorageFileFormatTypeToString(format));
return -1;
}
if (loader->nvram && loader->format != loader->nvram->format) {
virReportError(VIR_ERR_XML_ERROR,
- _("Format mismatch: loader.format='%s' nvram.format='%s'"),
+ _("Format mismatch: loader.format='%1$s' nvram.format='%2$s'"),
virStorageFileFormatTypeToString(loader->format),
virStorageFileFormatTypeToString(loader->nvram->format));
return -1;
if (!(tmp = virXMLPropString(node, attributeName))) {
virReportError(VIR_ERR_XML_ERROR,
- _("Missing attribute '%s' in element '%s'"),
+ _("Missing attribute '%1$s' in element '%2$s'"),
attributeName, elementName);
return NULL;
}
if (virBitmapIsAllClear(ret)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("'%s' scheduler bitmap '%s' is empty"),
+ _("'%1$s' scheduler bitmap '%2$s' is empty"),
attributeName, tmp);
return NULL;
}
if (sched->policy != VIR_PROC_POLICY_NONE) {
virReportError(VIR_ERR_XML_DETAIL,
- _("'%s' attributes '%s' must not overlap"),
+ _("'%1$s' attributes '%2$s' must not overlap"),
elementName, attributeName);
return -1;
}
if (!(iothrinfo = virDomainIOThreadIDFind(def, iothread))) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Cannot find 'iothread' : %u"),
+ _("Cannot find 'iothread' : %1$u"),
iothread);
return NULL;
}
if (virBitmapIsAllClear(def->cpumask)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Invalid value of 'cpuset': %s"), tmp);
+ _("Invalid value of 'cpuset': %1$s"), tmp);
return -1;
}
if (id >= def->maxvcpus) {
virReportError(VIR_ERR_XML_ERROR,
- _("vcpu id '%u' is out of range of maximum "
- "vcpu count"), id);
+ _("vcpu id '%1$u' is out of range of maximum vcpu count"),
+ id);
return -1;
}
if (!nodes[i]->children ||
!nodes[i]->children->content) {
virReportError(VIR_ERR_XML_ERROR,
- _("No value supplied for <initenv name='%s'> element"),
+ _("No value supplied for <initenv name='%1$s'> element"),
name);
return -1;
}
if (fw <= 0) {
virReportError(VIR_ERR_XML_ERROR,
- _("unknown firmware value %s"),
+ _("unknown firmware value %1$s"),
firmware);
return -1;
}
def->os.slic_table = virFileSanitizePath(tmp);
} else {
virReportError(VIR_ERR_XML_ERROR,
- _("Unknown acpi table type: %s"),
+ _("Unknown acpi table type: %1$s"),
tmp);
return -1;
}
vcpus_str = virXMLPropString(node, "vcpus");
if (!vcpus_str) {
- virReportError(VIR_ERR_XML_ERROR, _("Missing %s attribute 'vcpus'"),
+ virReportError(VIR_ERR_XML_ERROR, _("Missing %1$s attribute 'vcpus'"),
node->name);
return -1;
}
if (virBitmapParse(vcpus_str, vcpus, VIR_DOMAIN_CPUMASK_LEN) < 0) {
virReportError(VIR_ERR_XML_ERROR,
- _("Invalid %s attribute 'vcpus' value '%s'"),
+ _("Invalid %1$s attribute 'vcpus' value '%2$s'"),
node->name, vcpus_str);
return -1;
}
if (level != VIR_DOMAIN_RESCTRL_MONITOR_CACHELEVEL) {
virReportError(VIR_ERR_XML_ERROR,
- _("Invalid monitor cache level '%d'"),
+ _("Invalid monitor cache level '%1$d'"),
level);
goto cleanup;
}
}
if ((def->virtType = virDomainVirtTypeFromString(virttype)) < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("invalid domain type %s"), virttype);
+ _("invalid domain type %1$s"), virttype);
return -1;
}
} else {
if ((def->os.type = virDomainOSTypeFromString(ostype)) < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unknown OS type '%s'"), ostype);
+ _("unknown OS type '%1$s'"), ostype);
return -1;
}
}
if (arch && !(def->os.arch = virArchFromString(arch))) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Unknown architecture %s"), arch);
+ _("Unknown architecture %1$s"), arch);
return -1;
}
if (tmp) {
if ((def->mem.source = virDomainMemorySourceTypeFromString(tmp)) <= 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unknown memoryBacking/source/type '%s'"), tmp);
+ _("unknown memoryBacking/source/type '%1$s'"), tmp);
return -1;
}
VIR_FREE(tmp);
if (tmp) {
if ((def->mem.access = virDomainMemoryAccessTypeFromString(tmp)) <= 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unknown memoryBacking/access/mode '%s'"), tmp);
+ _("unknown memoryBacking/access/mode '%1$s'"), tmp);
return -1;
}
VIR_FREE(tmp);
if (tmp) {
if ((def->mem.allocation = virDomainMemoryAllocationTypeFromString(tmp)) <= 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unknown memoryBacking/allocation/mode '%s'"), tmp);
+ _("unknown memoryBacking/allocation/mode '%1$s'"), tmp);
return -1;
}
VIR_FREE(tmp);
if ((tmp = virXPathString("string(./clock/@offset)", ctxt)) &&
(def->clock.offset = virDomainClockOffsetTypeFromString(tmp)) < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unknown clock offset '%s'"), tmp);
+ _("unknown clock offset '%1$s'"), tmp);
return -1;
}
VIR_FREE(tmp);
if (virStrToLong_ll(tmp, NULL, 10,
&def->clock.data.variable.adjustment) < 0) {
virReportError(VIR_ERR_XML_ERROR,
- _("unknown clock adjustment '%s'"),
+ _("unknown clock adjustment '%1$s'"),
tmp);
return -1;
}
if (tmp) {
if ((def->clock.data.variable.basis = virDomainClockBasisTypeFromString(tmp)) < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unknown clock basis '%s'"), tmp);
+ _("unknown clock basis '%1$s'"), tmp);
return -1;
}
VIR_FREE(tmp);
if ((mode = virDomainSmbiosModeTypeFromString(tmp)) < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("unknown smbios mode '%s'"), tmp);
+ _("unknown smbios mode '%1$s'"), tmp);
return NULL;
}
def->os.smbios_mode = mode;
if ((tmp = virXMLPropString(ctxt->node, "reason"))) {
if ((reason = virDomainStateReasonFromString(state, tmp)) < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("invalid domain state reason '%s'"), tmp);
+ _("invalid domain state reason '%1$s'"), tmp);
return NULL;
}
}
{
if (src->name != dst->name) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target timer %s does not match source %s"),
+ _("Target timer %1$s does not match source %2$s"),
virDomainTimerNameTypeToString(dst->name),
virDomainTimerNameTypeToString(src->name));
return false;
if (src->present != dst->present) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target timer presence '%s' does not match source '%s'"),
+ _("Target timer presence '%1$s' does not match source '%2$s'"),
virTristateBoolTypeToString(dst->present),
virTristateBoolTypeToString(src->present));
return false;
if (src->name == VIR_DOMAIN_TIMER_NAME_TSC) {
if (src->frequency != dst->frequency) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target TSC frequency %llu does not match source %llu"),
+ _("Target TSC frequency %1$llu does not match source %2$llu"),
dst->frequency, src->frequency);
return false;
}
if (src->mode != dst->mode) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target TSC mode %s does not match source %s"),
+ _("Target TSC mode %1$s does not match source %2$s"),
virDomainTimerModeTypeToString(dst->mode),
virDomainTimerModeTypeToString(src->mode));
return false;
{
if (src->type != dst->type) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target device address type %s does not match source %s"),
+ _("Target device address type %1$s does not match source %2$s"),
virDomainDeviceAddressTypeToString(dst->type),
virDomainDeviceAddressTypeToString(src->type));
return false;
src->addr.pci.slot != dst->addr.pci.slot ||
src->addr.pci.function != dst->addr.pci.function) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target device PCI address %04x:%02x:%02x.%d does not match source %04x:%02x:%02x.%d"),
+ _("Target device PCI address %1$04x:%2$02x:%3$02x.%4$d does not match source %5$04x:%6$02x:%7$02x.%8$d"),
dst->addr.pci.domain, dst->addr.pci.bus,
dst->addr.pci.slot, dst->addr.pci.function,
src->addr.pci.domain, src->addr.pci.bus,
src->addr.drive.bus != dst->addr.drive.bus ||
src->addr.drive.unit != dst->addr.drive.unit) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target device drive address %d:%d:%d "
- "does not match source %d:%d:%d"),
+ _("Target device drive address %1$d:%2$d:%3$d does not match source %4$d:%5$d:%6$d"),
dst->addr.drive.controller, dst->addr.drive.bus,
dst->addr.drive.unit,
src->addr.drive.controller, src->addr.drive.bus,
src->addr.vioserial.bus != dst->addr.vioserial.bus ||
src->addr.vioserial.port != dst->addr.vioserial.port) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target device virtio serial address %d:%d:%d "
- "does not match source %d:%d:%d"),
+ _("Target device virtio serial address %1$d:%2$d:%3$d does not match source %4$d:%5$d:%6$d"),
dst->addr.vioserial.controller, dst->addr.vioserial.bus,
dst->addr.vioserial.port,
src->addr.vioserial.controller, src->addr.vioserial.bus,
if (src->addr.ccid.controller != dst->addr.ccid.controller ||
src->addr.ccid.slot != dst->addr.ccid.slot) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target device ccid address %d:%d "
- "does not match source %d:%d"),
+ _("Target device ccid address %1$d:%2$d does not match source %3$d:%4$d"),
dst->addr.ccid.controller,
dst->addr.ccid.slot,
src->addr.ccid.controller,
if (src->addr.isa.iobase != dst->addr.isa.iobase ||
src->addr.isa.irq != dst->addr.isa.irq) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target device isa address %d:%d "
- "does not match source %d:%d"),
+ _("Target device isa address %1$d:%2$d does not match source %3$d:%4$d"),
dst->addr.isa.iobase,
dst->addr.isa.irq,
src->addr.isa.iobase,
case VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DIMM:
if (src->addr.dimm.slot != dst->addr.dimm.slot) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target device dimm slot %u does not match "
- "source %u"),
+ _("Target device dimm slot %1$u does not match source %2$u"),
dst->addr.dimm.slot,
src->addr.dimm.slot);
return false;
if (src->addr.dimm.base != dst->addr.dimm.base) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target device dimm base address '%llx' does "
- "not match source '%llx'"),
+ _("Target device dimm base address '%1$llx' does not match source '%2$llx'"),
dst->addr.dimm.base,
src->addr.dimm.base);
return false;
if (src->acpiIndex != dst->acpiIndex) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target ACPI index '%u' does not match source '%u'"),
+ _("Target ACPI index '%1$u' does not match source '%2$u'"),
dst->acpiIndex, src->acpiIndex);
return false;
}
if (src->iommu != dst->iommu) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target device iommu option '%s' does not "
- "match source '%s'"),
+ _("Target device iommu option '%1$s' does not match source '%2$s'"),
virTristateSwitchTypeToString(dst->iommu),
virTristateSwitchTypeToString(src->iommu));
return false;
}
if (src->ats != dst->ats) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target device ats option '%s' does not "
- "match source '%s'"),
+ _("Target device ats option '%1$s' does not match source '%2$s'"),
virTristateSwitchTypeToString(dst->ats),
virTristateSwitchTypeToString(src->ats));
return false;
}
if (src->packed != dst->packed) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target device packed option '%s' does not "
- "match source '%s'"),
+ _("Target device packed option '%1$s' does not match source '%2$s'"),
virTristateSwitchTypeToString(dst->packed),
virTristateSwitchTypeToString(src->packed));
return false;
}
if (src->page_per_vq != dst->page_per_vq) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target device page_per_vq option '%s' does not "
- "match source '%s'"),
+ _("Target device page_per_vq option '%1$s' does not match source '%2$s'"),
virTristateSwitchTypeToString(dst->page_per_vq),
virTristateSwitchTypeToString(src->page_per_vq));
return false;
{
if (src->device != dst->device) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target disk device %s does not match source %s"),
+ _("Target disk device %1$s does not match source %2$s"),
virDomainDiskDeviceTypeToString(dst->device),
virDomainDiskDeviceTypeToString(src->device));
return false;
if (src->bus != dst->bus) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target disk bus %s does not match source %s"),
+ _("Target disk bus %1$s does not match source %2$s"),
virDomainDiskBusTypeToString(dst->bus),
virDomainDiskBusTypeToString(src->bus));
return false;
if (STRNEQ(src->dst, dst->dst)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target disk %s does not match source %s"),
+ _("Target disk %1$s does not match source %2$s"),
dst->dst, src->dst);
return false;
}
if (STRNEQ_NULLABLE(src->serial, dst->serial)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target disk serial %s does not match source %s"),
+ _("Target disk serial %1$s does not match source %2$s"),
NULLSTR(dst->serial), NULLSTR(src->serial));
return false;
}
if (STRNEQ_NULLABLE(src->wwn, dst->wwn)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target disk wwn '%s' does not match source '%s'"),
+ _("Target disk wwn '%1$s' does not match source '%2$s'"),
NULLSTR(dst->wwn), NULLSTR(src->wwn));
return false;
if (src->model != dst->model) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target disk model %s does not match source %s"),
+ _("Target disk model %1$s does not match source %2$s"),
virDomainDiskModelTypeToString(dst->model),
virDomainDiskModelTypeToString(src->model));
return false;
if (src->rotation_rate != dst->rotation_rate) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target disk rotation rate %u RPM does not match source %u RPM"),
+ _("Target disk rotation rate %1$u RPM does not match source %2$u RPM"),
dst->rotation_rate, src->rotation_rate);
return false;
}
if (src->queues != dst->queues) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target disk queue count %u does not match source %u"),
+ _("Target disk queue count %1$u does not match source %2$u"),
dst->queues, src->queues);
return false;
}
if (src->queue_size != dst->queue_size) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target disk queue size %u does not match source %u"),
+ _("Target disk queue size %1$u does not match source %2$u"),
dst->queues, src->queues);
return false;
}
{
if (src->type != dst->type) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target controller type %s does not match source %s"),
+ _("Target controller type %1$s does not match source %2$s"),
virDomainControllerTypeToString(dst->type),
virDomainControllerTypeToString(src->type));
return false;
if (src->idx != dst->idx) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target controller index %d does not match source %d"),
+ _("Target controller index %1$d does not match source %2$d"),
dst->idx, src->idx);
return false;
}
if (src->model != dst->model) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target controller model %d does not match source %d"),
+ _("Target controller model %1$d does not match source %2$d"),
dst->model, src->model);
return false;
}
if (src->type == VIR_DOMAIN_CONTROLLER_TYPE_VIRTIO_SERIAL) {
if (src->opts.vioserial.ports != dst->opts.vioserial.ports) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target controller ports %d does not match source %d"),
+ _("Target controller ports %1$d does not match source %2$d"),
dst->opts.vioserial.ports, src->opts.vioserial.ports);
return false;
}
if (src->opts.vioserial.vectors != dst->opts.vioserial.vectors) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target controller vectors %d does not match source %d"),
+ _("Target controller vectors %1$d does not match source %2$d"),
dst->opts.vioserial.vectors, src->opts.vioserial.vectors);
return false;
}
} else if (src->type == VIR_DOMAIN_CONTROLLER_TYPE_USB) {
if (src->opts.usbopts.ports != dst->opts.usbopts.ports) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target controller ports %d does not match source %d"),
+ _("Target controller ports %1$d does not match source %2$d"),
dst->opts.usbopts.ports, src->opts.usbopts.ports);
return false;
}
{
if (STRNEQ_NULLABLE(src->dst, dst->dst)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target filesystem guest target %s does not match source %s"),
+ _("Target filesystem guest target %1$s does not match source %2$s"),
dst->dst, src->dst);
return false;
}
if (virMacAddrCmp(&src->mac, &dst->mac) != 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target network card mac %s"
- " does not match source %s"),
+ _("Target network card mac %1$s does not match source %2$s"),
virMacAddrFormat(&dst->mac, dstmac),
virMacAddrFormat(&src->mac, srcmac));
return false;
if (STRNEQ_NULLABLE(src->modelstr, dst->modelstr)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target network card model %s does not match source %s"),
+ _("Target network card model %1$s does not match source %2$s"),
NULLSTR(dst->modelstr), NULLSTR(src->modelstr));
return false;
}
if (src->model != dst->model) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target network card model %s does not match source %s"),
+ _("Target network card model %1$s does not match source %2$s"),
virDomainNetModelTypeToString(dst->model),
virDomainNetModelTypeToString(src->model));
return false;
if (src->mtu != dst->mtu) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target network card MTU %d does not match source %d"),
+ _("Target network card MTU %1$d does not match source %2$d"),
dst->mtu, src->mtu);
return false;
}
{
if (src->type != dst->type) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target input device type %s does not match source %s"),
+ _("Target input device type %1$s does not match source %2$s"),
virDomainInputTypeToString(dst->type),
virDomainInputTypeToString(src->type));
return false;
if (src->bus != dst->bus) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target input device bus %s does not match source %s"),
+ _("Target input device bus %1$s does not match source %2$s"),
virDomainInputBusTypeToString(dst->bus),
virDomainInputBusTypeToString(src->bus));
return false;
if (src->model != dst->model) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target input model %s does not match source %s"),
+ _("Target input model %1$s does not match source %2$s"),
virDomainInputBusTypeToString(dst->model),
virDomainInputBusTypeToString(src->model));
return false;
{
if (src->model != dst->model) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target sound card model %s does not match source %s"),
+ _("Target sound card model %1$s does not match source %2$s"),
virDomainSoundModelTypeToString(dst->model),
virDomainSoundModelTypeToString(src->model));
return false;
{
if (src->type != dst->type) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target video card model %s does not match source %s"),
+ _("Target video card model %1$s does not match source %2$s"),
virDomainVideoTypeToString(dst->type),
virDomainVideoTypeToString(src->type));
return false;
if (src->ram != dst->ram) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target video card ram %u does not match source %u"),
+ _("Target video card ram %1$u does not match source %2$u"),
dst->ram, src->ram);
return false;
}
if (src->vram != dst->vram) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target video card vram %u does not match source %u"),
+ _("Target video card vram %1$u does not match source %2$u"),
dst->vram, src->vram);
return false;
}
if (src->vram64 != dst->vram64) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target video card vram64 %u does not match source %u"),
+ _("Target video card vram64 %1$u does not match source %2$u"),
dst->vram64, src->vram64);
return false;
}
if (src->vgamem != dst->vgamem) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target video card vgamem %u does not match source %u"),
+ _("Target video card vgamem %1$u does not match source %2$u"),
dst->vgamem, src->vgamem);
return false;
}
if (src->heads != dst->heads) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target video card heads %u does not match source %u"),
+ _("Target video card heads %1$u does not match source %2$u"),
dst->heads, src->heads);
return false;
}
if (src->accel) {
if (src->accel->accel2d != dst->accel->accel2d) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target video card 2d accel %u does not match source %u"),
+ _("Target video card 2d accel %1$u does not match source %2$u"),
dst->accel->accel2d, src->accel->accel2d);
return false;
}
if (src->accel->accel3d != dst->accel->accel3d) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target video card 3d accel %u does not match source %u"),
+ _("Target video card 3d accel %1$u does not match source %2$u"),
dst->accel->accel3d, src->accel->accel3d);
return false;
}
{
if (src->mode != dst->mode) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target host device mode %s does not match source %s"),
+ _("Target host device mode %1$s does not match source %2$s"),
virDomainHostdevModeTypeToString(dst->mode),
virDomainHostdevModeTypeToString(src->mode));
return false;
if (src->mode == VIR_DOMAIN_HOSTDEV_MODE_SUBSYS &&
src->source.subsys.type != dst->source.subsys.type) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target host device subsystem %s does not match source %s"),
+ _("Target host device subsystem %1$s does not match source %2$s"),
virDomainHostdevSubsysTypeToString(dst->source.subsys.type),
virDomainHostdevSubsysTypeToString(src->source.subsys.type));
return false;
{
if (src->targetType != dst->targetType) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target serial type %s does not match source %s"),
+ _("Target serial type %1$s does not match source %2$s"),
virDomainChrSerialTargetTypeToString(dst->targetType),
virDomainChrSerialTargetTypeToString(src->targetType));
return false;
if (src->targetModel != dst->targetModel) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target serial model %s does not match source %s"),
+ _("Target serial model %1$s does not match source %2$s"),
virDomainChrSerialTargetModelTypeToString(dst->targetModel),
virDomainChrSerialTargetModelTypeToString(src->targetModel));
return false;
if (src->target.port != dst->target.port) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target serial port %d does not match source %d"),
+ _("Target serial port %1$d does not match source %2$d"),
dst->target.port, src->target.port);
return false;
}
{
if (src->target.port != dst->target.port) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target parallel port %d does not match source %d"),
+ _("Target parallel port %1$d does not match source %2$d"),
dst->target.port, src->target.port);
return false;
}
{
if (src->targetType != dst->targetType) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target channel type %s does not match source %s"),
+ _("Target channel type %1$s does not match source %2$s"),
virDomainChrChannelTargetTypeToString(dst->targetType),
virDomainChrChannelTargetTypeToString(src->targetType));
return false;
case VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_VIRTIO:
if (STRNEQ_NULLABLE(src->target.name, dst->target.name)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target channel name %s does not match source %s"),
+ _("Target channel name %1$s does not match source %2$s"),
NULLSTR(dst->target.name), NULLSTR(src->target.name));
return false;
}
g_autofree char *saddr = virSocketAddrFormatFull(src->target.addr, true, ":");
g_autofree char *daddr = virSocketAddrFormatFull(dst->target.addr, true, ":");
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target channel addr %s does not match source %s"),
+ _("Target channel addr %1$s does not match source %2$s"),
NULLSTR(daddr), NULLSTR(saddr));
return false;
}
{
if (src->targetType != dst->targetType) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target console type %s does not match source %s"),
+ _("Target console type %1$s does not match source %2$s"),
virDomainChrConsoleTargetTypeToString(dst->targetType),
virDomainChrConsoleTargetTypeToString(src->targetType));
return false;
{
if (src->model != dst->model) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target watchdog model %s does not match source %s"),
+ _("Target watchdog model %1$s does not match source %2$s"),
virDomainWatchdogModelTypeToString(dst->model),
virDomainWatchdogModelTypeToString(src->model));
return false;
{
if (src->model != dst->model) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target balloon model %s does not match source %s"),
+ _("Target balloon model %1$s does not match source %2$s"),
virDomainMemballoonModelTypeToString(dst->model),
virDomainMemballoonModelTypeToString(src->model));
return false;
if (src->autodeflate != dst->autodeflate) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target balloon autodeflate attribute value "
- "'%s' does not match source '%s'"),
+ _("Target balloon autodeflate attribute value '%1$s' does not match source '%2$s'"),
virTristateSwitchTypeToString(dst->autodeflate),
virTristateSwitchTypeToString(src->autodeflate));
return false;
if (src->free_page_reporting != dst->free_page_reporting) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target balloon freePageReporting attribute value "
- "'%s' does not match source '%s'"),
+ _("Target balloon freePageReporting attribute value '%1$s' does not match source '%2$s'"),
virTristateSwitchTypeToString(dst->free_page_reporting),
virTristateSwitchTypeToString(src->free_page_reporting));
return false;
{
if (src->model != dst->model) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target RNG model '%s' does not match source '%s'"),
+ _("Target RNG model '%1$s' does not match source '%2$s'"),
virDomainRNGModelTypeToString(dst->model),
virDomainRNGModelTypeToString(src->model));
return false;
{
if (src->type != dst->type) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target hub device type %s does not match source %s"),
+ _("Target hub device type %1$s does not match source %2$s"),
virDomainHubTypeToString(dst->type),
virDomainHubTypeToString(src->type));
return false;
{
if (src->bus != dst->bus) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target redirected device bus %s does not match "
- "source %s"),
+ _("Target redirected device bus %1$s does not match source %2$s"),
virDomainRedirdevBusTypeToString(dst->bus),
virDomainRedirdevBusTypeToString(src->bus));
return false;
case VIR_DOMAIN_REDIRDEV_BUS_USB:
if (src->source->type != dst->source->type) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target redirected device source type %s does "
- "not match source device source type %s"),
+ _("Target redirected device source type %1$s does not match source device source type %2$s"),
virDomainChrTypeToString(dst->source->type),
virDomainChrTypeToString(src->source->type));
return false;
if (src->nusbdevs != dst->nusbdevs) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target USB redirection filter rule "
- "count %zu does not match source %zu"),
+ _("Target USB redirection filter rule count %1$zu does not match source %2$zu"),
dst->nusbdevs, src->nusbdevs);
return false;
}
if (srcUSBDev->allow != dstUSBDev->allow) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target USB allow '%s' does not match source '%s'"),
+ _("Target USB allow '%1$s' does not match source '%2$s'"),
dstUSBDev->allow ? "yes" : "no",
srcUSBDev->allow ? "yes" : "no");
return false;
case VIR_DOMAIN_FEATURE_CCF_ASSIST:
if (src->features[i] != dst->features[i]) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("State of feature '%s' differs: "
- "source: '%s', destination: '%s'"),
+ _("State of feature '%1$s' differs: source: '%2$s', destination: '%3$s'"),
featureName,
virTristateSwitchTypeToString(src->features[i]),
virTristateSwitchTypeToString(dst->features[i]));
case VIR_DOMAIN_FEATURE_CAPABILITIES:
if (src->features[i] != dst->features[i]) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("State of feature '%s' differs: "
- "source: '%s=%s', destination: '%s=%s'"),
+ _("State of feature '%1$s' differs: source: '%2$s=%3$s', destination: '%4$s=%5$s'"),
featureName,
"policy",
virDomainCapabilitiesPolicyTypeToString(src->features[i]),
if (src->features[i] != dst->features[i] ||
src->gic_version != dst->gic_version) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("State of feature '%s' differs: "
- "source: '%s,%s=%s', destination: '%s,%s=%s'"),
+ _("State of feature '%1$s' differs: source: '%2$s,%3$s=%4$s', destination: '%5$s,%6$s=%7$s'"),
featureName,
virTristateSwitchTypeToString(src->features[i]),
"version", virGICVersionTypeToString(src->gic_version),
src->hpt_resizing != dst->hpt_resizing ||
src->hpt_maxpagesize != dst->hpt_maxpagesize) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("State of feature '%s' differs: "
- "source: '%s,%s=%s,%s=%llu', destination: '%s,%s=%s,%s=%llu'"),
+ _("State of feature '%1$s' differs: source: '%2$s,%3$s=%4$s,%5$s=%6$llu', destination: '%7$s,%8$s=%9$s,%10$s=%11$llu'"),
featureName,
virTristateSwitchTypeToString(src->features[i]),
"resizing", virDomainHPTResizingTypeToString(src->hpt_resizing),
if (src->features[i] != dst->features[i] ||
src->apic_eoi != dst->apic_eoi) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("State of feature '%s' differs: "
- "source: '%s,%s=%s', destination: '%s,%s=%s'"),
+ _("State of feature '%1$s' differs: source: '%2$s,%3$s=%4$s', destination: '%5$s,%6$s=%7$s'"),
featureName,
virTristateSwitchTypeToString(src->features[i]),
"eoi", virTristateSwitchTypeToString(src->apic_eoi),
case VIR_DOMAIN_FEATURE_IOAPIC:
if (src->features[i] != dst->features[i]) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("State of feature '%s' differs: "
- "source: '%s=%s', destination: '%s=%s'"),
+ _("State of feature '%1$s' differs: source: '%2$s=%3$s', destination: '%4$s=%5$s'"),
featureName,
"driver", virDomainIOAPICTypeToString(src->features[i]),
"driver", virDomainIOAPICTypeToString(dst->features[i]));
case VIR_DOMAIN_FEATURE_CFPC:
if (src->features[i] != dst->features[i]) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("State of feature '%s' differs: "
- "source: '%s=%s', destination: '%s=%s'"),
+ _("State of feature '%1$s' differs: source: '%2$s=%3$s', destination: '%4$s=%5$s'"),
featureName,
"value", virDomainCFPCTypeToString(src->features[i]),
"value", virDomainCFPCTypeToString(dst->features[i]));
case VIR_DOMAIN_FEATURE_SBBC:
if (src->features[i] != dst->features[i]) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("State of feature '%s' differs: "
- "source: '%s=%s', destination: '%s=%s'"),
+ _("State of feature '%1$s' differs: source: '%2$s=%3$s', destination: '%4$s=%5$s'"),
featureName,
"value", virDomainSBBCTypeToString(src->features[i]),
"value", virDomainSBBCTypeToString(dst->features[i]));
case VIR_DOMAIN_FEATURE_IBS:
if (src->features[i] != dst->features[i]) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("State of feature '%s' differs: "
- "source: '%s=%s', destination: '%s=%s'"),
+ _("State of feature '%1$s' differs: source: '%2$s=%3$s', destination: '%4$s=%5$s'"),
featureName,
"value", virDomainIBSTypeToString(src->features[i]),
"value", virDomainIBSTypeToString(dst->features[i]));
case VIR_DOMAIN_HYPERV_AVIC:
if (src->hyperv_features[i] != dst->hyperv_features[i]) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("State of HyperV enlightenment "
- "feature '%s' differs: "
- "source: '%s', destination: '%s'"),
+ _("State of HyperV enlightenment feature '%1$s' differs: source: '%2$s', destination: '%3$s'"),
virDomainHypervTypeToString(i),
virTristateSwitchTypeToString(src->hyperv_features[i]),
virTristateSwitchTypeToString(dst->hyperv_features[i]));
/* spinlock count matters! */
if (src->hyperv_spinlocks != dst->hyperv_spinlocks) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("HyperV spinlock retry count differs: "
- "source: '%u', destination: '%u'"),
+ _("HyperV spinlock retry count differs: source: '%1$u', destination: '%2$u'"),
src->hyperv_spinlocks,
dst->hyperv_spinlocks);
return false;
case VIR_DOMAIN_HYPERV_VENDOR_ID:
if (STRNEQ_NULLABLE(src->hyperv_vendor_id, dst->hyperv_vendor_id)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("HyperV vendor_id differs: "
- "source: '%s', destination: '%s'"),
+ _("HyperV vendor_id differs: source: '%1$s', destination: '%2$s'"),
src->hyperv_vendor_id,
dst->hyperv_vendor_id);
return false;
if (src->hyperv_features[VIR_DOMAIN_HYPERV_STIMER] == VIR_TRISTATE_SWITCH_ON) {
if (src->hyperv_stimer_direct != dst->hyperv_stimer_direct) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("State of HyperV stimer direct feature differs: "
- "source: '%s', destination: '%s'"),
+ _("State of HyperV stimer direct feature differs: source: '%1$s', destination: '%2$s'"),
virTristateSwitchTypeToString(src->hyperv_stimer_direct),
virTristateSwitchTypeToString(dst->hyperv_stimer_direct));
return false;
for (i = 0; i < VIR_DOMAIN_XEN_LAST; i++) {
if (src->xen_features[i] != dst->xen_features[i]) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("State of Xen feature '%s' differs: "
- "source: '%s', destination: '%s'"),
+ _("State of Xen feature '%1$s' differs: source: '%2$s', destination: '%3$s'"),
virDomainXenTypeToString(i),
virTristateSwitchTypeToString(src->xen_features[i]),
virTristateSwitchTypeToString(dst->xen_features[i]));
case VIR_DOMAIN_XEN_PASSTHROUGH:
if (src->xen_passthrough_mode != dst->xen_passthrough_mode) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("'mode' of Xen passthrough feature differs: "
- "source: '%s', destination: '%s'"),
+ _("'mode' of Xen passthrough feature differs: source: '%1$s', destination: '%2$s'"),
virDomainXenPassthroughModeTypeToString(src->xen_passthrough_mode),
virDomainXenPassthroughModeTypeToString(dst->xen_passthrough_mode));
return false;
case VIR_DOMAIN_KVM_DIRTY_RING:
if (src->kvm_features->features[i] != dst->kvm_features->features[i]) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("State of KVM feature '%s' differs: "
- "source: '%s', destination: '%s'"),
+ _("State of KVM feature '%1$s' differs: source: '%2$s', destination: '%3$s'"),
virDomainKVMTypeToString(i),
virTristateSwitchTypeToString(src->kvm_features->features[i]),
virTristateSwitchTypeToString(dst->kvm_features->features[i]));
if (src->kvm_features->dirty_ring_size != dst->kvm_features->dirty_ring_size) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("dirty ring size of KVM feature '%s' differs: "
- "source: '%d', destination: '%d'"),
+ _("dirty ring size of KVM feature '%1$s' differs: source: '%2$d', destination: '%3$d'"),
virDomainKVMTypeToString(i),
src->kvm_features->dirty_ring_size,
dst->kvm_features->dirty_ring_size);
if (src->features[VIR_DOMAIN_FEATURE_SMM] == VIR_TRISTATE_SWITCH_ON) {
if (src->tseg_specified != dst->tseg_specified) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("SMM TSEG differs: source: %s, destination: '%s'"),
+ _("SMM TSEG differs: source: %1$s, destination: '%2$s'"),
src->tseg_specified ? _("specified") : _("not specified"),
dst->tseg_specified ? _("specified") : _("not specified"));
return false;
&unit_dst);
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Size of SMM TSEG size differs: "
- "source: '%llu %s', destination: '%llu %s'"),
+ _("Size of SMM TSEG size differs: source: '%1$llu %2$s', destination: '%3$llu %4$s'"),
short_size_src, unit_src,
short_size_dst, unit_dst);
return false;
{
if (src->model != dst->model) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target panic model '%s' does not match source '%s'"),
+ _("Target panic model '%1$s' does not match source '%2$s'"),
virDomainPanicModelTypeToString(dst->model),
virDomainPanicModelTypeToString(src->model));
return false;
{
if (src->role != dst->role) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target shared memory role '%s' does not match "
- "source role '%s'"),
+ _("Target shared memory role '%1$s' does not match source role '%2$s'"),
virDomainShmemRoleTypeToString(dst->role),
virDomainShmemRoleTypeToString(src->role));
return false;
if (src->model != dst->model) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target shared memory model '%s' does not match "
- "source model '%s'"),
+ _("Target shared memory model '%1$s' does not match source model '%2$s'"),
virDomainShmemModelTypeToString(dst->model),
virDomainShmemModelTypeToString(src->model));
return false;
if (src->size != dst->size) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target shared memory size '%llu' does not match "
- "source size '%llu'"), dst->size, src->size);
+ _("Target shared memory size '%1$llu' does not match source size '%2$llu'"),
+ dst->size, src->size);
return false;
}
{
if (virDomainDefGetMemoryInitial(src) != virDomainDefGetMemoryInitial(dst)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain max memory %lld "
- "does not match source %lld"),
+ _("Target domain max memory %1$lld does not match source %2$lld"),
virDomainDefGetMemoryInitial(dst),
virDomainDefGetMemoryInitial(src));
return false;
if (!(flags & VIR_DOMAIN_DEF_ABI_CHECK_SKIP_VOLATILE) &&
src->mem.cur_balloon != dst->mem.cur_balloon) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain current memory %lld "
- "does not match source %lld"),
+ _("Target domain current memory %1$lld does not match source %2$lld"),
dst->mem.cur_balloon,
src->mem.cur_balloon);
return false;
if (src->mem.max_memory != dst->mem.max_memory) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target maximum memory size '%llu' "
- "doesn't match source '%llu'"),
+ _("Target maximum memory size '%1$llu' doesn't match source '%2$llu'"),
dst->mem.max_memory,
src->mem.max_memory);
return false;
if (src->mem.memory_slots != dst->mem.memory_slots) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain memory slots "
- "count '%u' doesn't match source '%u'"),
+ _("Target domain memory slots count '%1$u' doesn't match source '%2$u'"),
dst->mem.memory_slots,
src->mem.memory_slots);
return false;
{
if (src->model != dst->model) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target memory device model '%s' "
- "doesn't match source model '%s'"),
+ _("Target memory device model '%1$s' doesn't match source model '%2$s'"),
virDomainMemoryModelTypeToString(dst->model),
virDomainMemoryModelTypeToString(src->model));
return false;
if (src->targetNode != dst->targetNode) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target memory device targetNode '%d' "
- "doesn't match source targetNode '%d'"),
+ _("Target memory device targetNode '%1$d' doesn't match source targetNode '%2$d'"),
dst->targetNode, src->targetNode);
return false;
}
if (src->size != dst->size) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target memory device size '%llu' doesn't match "
- "source memory device size '%llu'"),
+ _("Target memory device size '%1$llu' doesn't match source memory device size '%2$llu'"),
dst->size, src->size);
return false;
}
if (src->blocksize != dst->blocksize) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target memory device block size '%llu' doesn't match "
- "source memory device block size '%llu'"),
+ _("Target memory device block size '%1$llu' doesn't match source memory device block size '%2$llu'"),
dst->blocksize, src->blocksize);
return false;
}
if (src->requestedsize != dst->requestedsize) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target memory device requested size '%llu' doesn't match "
- "source memory device requested size '%llu'"),
+ _("Target memory device requested size '%1$llu' doesn't match source memory device requested size '%2$llu'"),
dst->requestedsize, src->requestedsize);
return false;
}
if (src->model == VIR_DOMAIN_MEMORY_MODEL_NVDIMM) {
if (src->labelsize != dst->labelsize) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target NVDIMM label size '%llu' doesn't match "
- "source NVDIMM label size '%llu'"),
+ _("Target NVDIMM label size '%1$llu' doesn't match source NVDIMM label size '%2$llu'"),
src->labelsize, dst->labelsize);
return false;
}
if (src->alignsize != dst->alignsize) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target NVDIMM alignment '%llu' doesn't match "
- "source NVDIMM alignment '%llu'"),
+ _("Target NVDIMM alignment '%1$llu' doesn't match source NVDIMM alignment '%2$llu'"),
src->alignsize, dst->alignsize);
return false;
}
{
if (src->model != dst->model) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain IOMMU device model '%s' "
- "does not match source '%s'"),
+ _("Target domain IOMMU device model '%1$s' does not match source '%2$s'"),
virDomainIOMMUModelTypeToString(dst->model),
virDomainIOMMUModelTypeToString(src->model));
return false;
}
if (src->intremap != dst->intremap) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain IOMMU device intremap value '%s' "
- "does not match source '%s'"),
+ _("Target domain IOMMU device intremap value '%1$s' does not match source '%2$s'"),
virTristateSwitchTypeToString(dst->intremap),
virTristateSwitchTypeToString(src->intremap));
return false;
}
if (src->caching_mode != dst->caching_mode) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain IOMMU device caching mode '%s' "
- "does not match source '%s'"),
+ _("Target domain IOMMU device caching mode '%1$s' does not match source '%2$s'"),
virTristateSwitchTypeToString(dst->caching_mode),
virTristateSwitchTypeToString(src->caching_mode));
return false;
}
if (src->eim != dst->eim) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain IOMMU device eim value '%s' "
- "does not match source '%s'"),
+ _("Target domain IOMMU device eim value '%1$s' does not match source '%2$s'"),
virTristateSwitchTypeToString(dst->eim),
virTristateSwitchTypeToString(src->eim));
return false;
}
if (src->iotlb != dst->iotlb) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain IOMMU device iotlb value '%s' "
- "does not match source '%s'"),
+ _("Target domain IOMMU device iotlb value '%1$s' does not match source '%2$s'"),
virTristateSwitchTypeToString(dst->iotlb),
virTristateSwitchTypeToString(src->iotlb));
return false;
}
if (src->aw_bits != dst->aw_bits) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain IOMMU device aw_bits value '%d' "
- "does not match source '%d'"),
+ _("Target domain IOMMU device aw_bits value '%1$d' does not match source '%2$d'"),
dst->aw_bits, src->aw_bits);
return false;
}
{
if (src->model != dst->model) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain vsock device model '%s' "
- "does not match source '%s'"),
+ _("Target domain vsock device model '%1$s' does not match source '%2$s'"),
virDomainVsockModelTypeToString(dst->model),
virDomainVsockModelTypeToString(src->model));
return false;
if (src->maxvcpus != dst->maxvcpus) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain vCPU max %zu does not match source %zu"),
+ _("Target domain vCPU max %1$zu does not match source %2$zu"),
dst->maxvcpus, src->maxvcpus);
return false;
}
if (svcpu->online != dvcpu->online) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("State of vCPU '%zu' differs between source and "
- "destination definitions"), i);
+ _("State of vCPU '%1$zu' differs between source and destination definitions"),
+ i);
return false;
}
if (svcpu->order != dvcpu->order) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("vcpu enable order of vCPU '%zu' differs between "
- "source and destination definitions"), i);
+ _("vcpu enable order of vCPU '%1$zu' differs between source and destination definitions"),
+ i);
return false;
}
}
if (src->virtType != dst->virtType) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain virt type %s does not match source %s"),
+ _("Target domain virt type %1$s does not match source %2$s"),
virDomainVirtTypeToString(dst->virtType),
virDomainVirtTypeToString(src->virtType));
goto error;
virUUIDFormat(src->uuid, uuidsrc);
virUUIDFormat(dst->uuid, uuiddst);
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain uuid %s does not match source %s"),
+ _("Target domain uuid %1$s does not match source %2$s"),
uuiddst, uuidsrc);
goto error;
}
virUUIDFormat(src->genid, guidsrc);
virUUIDFormat(dst->genid, guiddst);
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain genid %s does not match source %s"),
+ _("Target domain genid %1$s does not match source %2$s"),
guiddst, guidsrc);
goto error;
}
*/
if (STRNEQ_NULLABLE(src->name, dst->name)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain name '%s' does not match source '%s'"),
+ _("Target domain name '%1$s' does not match source '%2$s'"),
dst->name, src->name);
goto error;
}
if (src->os.type != dst->os.type) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain OS type %s does not match source %s"),
+ _("Target domain OS type %1$s does not match source %2$s"),
virDomainOSTypeToString(dst->os.type),
virDomainOSTypeToString(src->os.type));
goto error;
}
if (src->os.arch != dst->os.arch) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain architecture %s does not match source %s"),
+ _("Target domain architecture %1$s does not match source %2$s"),
virArchToString(dst->os.arch),
virArchToString(src->os.arch));
goto error;
}
if (STRNEQ_NULLABLE(src->os.machine, dst->os.machine)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain machine type %s does not match source %s"),
+ _("Target domain machine type %1$s does not match source %2$s"),
dst->os.machine, src->os.machine);
goto error;
}
if (src->os.smbios_mode != dst->os.smbios_mode) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain SMBIOS mode %s does not match source %s"),
+ _("Target domain SMBIOS mode %1$s does not match source %2$s"),
virDomainSmbiosModeTypeToString(dst->os.smbios_mode),
virDomainSmbiosModeTypeToString(src->os.smbios_mode));
goto error;
if (src->ndisks != dst->ndisks) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain disk count %zu does not match source %zu"),
+ _("Target domain disk count %1$zu does not match source %2$zu"),
dst->ndisks, src->ndisks);
goto error;
}
if (src->ncontrollers != dst->ncontrollers) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain controller count %zu "
- "does not match source %zu"),
+ _("Target domain controller count %1$zu does not match source %2$zu"),
dst->ncontrollers, src->ncontrollers);
goto error;
}
if (src->nfss != dst->nfss) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain filesystem count %zu "
- "does not match source %zu"),
+ _("Target domain filesystem count %1$zu does not match source %2$zu"),
dst->nfss, src->nfss);
goto error;
}
if (src->nnets != dst->nnets) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain net card count %zu "
- "does not match source %zu"),
+ _("Target domain net card count %1$zu does not match source %2$zu"),
dst->nnets, src->nnets);
goto error;
}
if (src->ninputs != dst->ninputs) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain input device count %zu "
- "does not match source %zu"),
+ _("Target domain input device count %1$zu does not match source %2$zu"),
dst->ninputs, src->ninputs);
goto error;
}
if (src->nsounds != dst->nsounds) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain sound card count %zu "
- "does not match source %zu"),
+ _("Target domain sound card count %1$zu does not match source %2$zu"),
dst->nsounds, src->nsounds);
goto error;
}
if (src->nvideos != dst->nvideos) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain video card count %zu "
- "does not match source %zu"),
+ _("Target domain video card count %1$zu does not match source %2$zu"),
dst->nvideos, src->nvideos);
goto error;
}
if (src->nhostdevs != dst->nhostdevs) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain host device count %zu "
- "does not match source %zu"),
+ _("Target domain host device count %1$zu does not match source %2$zu"),
dst->nhostdevs, src->nhostdevs);
goto error;
}
if (src->nsmartcards != dst->nsmartcards) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain smartcard count %zu "
- "does not match source %zu"),
+ _("Target domain smartcard count %1$zu does not match source %2$zu"),
dst->nsmartcards, src->nsmartcards);
goto error;
}
if (src->nserials != dst->nserials) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain serial port count %zu "
- "does not match source %zu"),
+ _("Target domain serial port count %1$zu does not match source %2$zu"),
dst->nserials, src->nserials);
goto error;
}
if (src->nparallels != dst->nparallels) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain parallel port count %zu "
- "does not match source %zu"),
+ _("Target domain parallel port count %1$zu does not match source %2$zu"),
dst->nparallels, src->nparallels);
goto error;
}
if (src->nchannels != dst->nchannels) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain channel count %zu "
- "does not match source %zu"),
+ _("Target domain channel count %1$zu does not match source %2$zu"),
dst->nchannels, src->nchannels);
goto error;
}
if (src->nconsoles != dst->nconsoles) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain console count %zu "
- "does not match source %zu"),
+ _("Target domain console count %1$zu does not match source %2$zu"),
dst->nconsoles, src->nconsoles);
goto error;
}
if (src->nhubs != dst->nhubs) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain hub device count %zu "
- "does not match source %zu"),
+ _("Target domain hub device count %1$zu does not match source %2$zu"),
dst->nhubs, src->nhubs);
goto error;
}
if (src->nredirdevs != dst->nredirdevs) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain redirected devices count %zu "
- "does not match source %zu"),
+ _("Target domain redirected devices count %1$zu does not match source %2$zu"),
dst->nredirdevs, src->nredirdevs);
goto error;
}
if ((!src->redirfilter && dst->redirfilter) ||
(src->redirfilter && !dst->redirfilter)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain USB redirection filter count %d "
- "does not match source %d"),
+ _("Target domain USB redirection filter count %1$d does not match source %2$d"),
dst->redirfilter ? 1 : 0, src->redirfilter ? 1 : 0);
goto error;
}
if (src->nwatchdogs != dst->nwatchdogs) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain watchdog device count %zu does not match source %zu"),
+ _("Target domain watchdog device count %1$zu does not match source %2$zu"),
dst->nwatchdogs, src->nwatchdogs);
goto error;
}
if ((!src->memballoon && dst->memballoon) ||
(src->memballoon && !dst->memballoon)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain memory balloon count %d "
- "does not match source %d"),
+ _("Target domain memory balloon count %1$d does not match source %2$d"),
dst->memballoon ? 1 : 0, src->memballoon ? 1 : 0);
goto error;
}
if (src->nrngs != dst->nrngs) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain RNG device count %zu "
- "does not match source %zu"), dst->nrngs, src->nrngs);
+ _("Target domain RNG device count %1$zu does not match source %2$zu"),
+ dst->nrngs, src->nrngs);
goto error;
}
if (src->npanics != dst->npanics) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain panic device count %zu "
- "does not match source %zu"), dst->npanics, src->npanics);
+ _("Target domain panic device count %1$zu does not match source %2$zu"),
+ dst->npanics, src->npanics);
goto error;
}
if (src->nshmems != dst->nshmems) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain shared memory device count %zu "
- "does not match source %zu"), dst->nshmems, src->nshmems);
+ _("Target domain shared memory device count %1$zu does not match source %2$zu"),
+ dst->nshmems, src->nshmems);
goto error;
}
if (src->ntpms != dst->ntpms) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain TPM device count %zu "
- "does not match source %zu"),
+ _("Target domain TPM device count %1$zu does not match source %2$zu"),
dst->ntpms, src->ntpms);
goto error;
}
if (src->nmems != dst->nmems) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Target domain memory device count %zu "
- "does not match source %zu"), dst->nmems, src->nmems);
+ _("Target domain memory device count %1$zu does not match source %2$zu"),
+ dst->nmems, src->nmems);
goto error;
}
const char *typeStr = convFunc(type);
if (!typeStr) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected %s action: %d"), name, type);
+ _("unexpected %1$s action: %2$d"), name, type);
return -1;
}
case VIR_STORAGE_TYPE_NONE:
case VIR_STORAGE_TYPE_LAST:
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected disk type %d"), src->type);
+ _("unexpected disk type %1$d"), src->type);
return -1;
}
if (backingStore->format <= 0 || backingStore->format >= VIR_STORAGE_FILE_LAST) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected disk backing store format %d"),
+ _("unexpected disk backing store format %1$d"),
backingStore->format);
return -1;
}
if (!type || !def->src->type) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected disk type %d"), def->src->type);
+ _("unexpected disk type %1$d"), def->src->type);
return -1;
}
if (!device) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected disk device %d"), def->device);
+ _("unexpected disk device %1$d"), def->device);
return -1;
}
if (!bus) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected disk bus %d"), def->bus);
+ _("unexpected disk bus %1$d"), def->bus);
return -1;
}
if (!sgio) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Unexpected disk sgio mode '%d'"), def->sgio);
+ _("Unexpected disk sgio mode '%1$d'"), def->sgio);
return -1;
}
const char *modelName = virDomainControllerPCIModelNameTypeToString(def->opts.pciopts.modelName);
if (!modelName) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected model name value %d"),
+ _("unexpected model name value %1$d"),
def->opts.pciopts.modelName);
return -1;
}
if (!type) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected controller type %d"), def->type);
+ _("unexpected controller type %1$d"), def->type);
return -1;
}
if (!model) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected model type %d"), def->model);
+ _("unexpected model type %1$d"), def->model);
return -1;
}
}
if (!type) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected filesystem type %d"), def->type);
+ _("unexpected filesystem type %1$d"), def->type);
return -1;
}
if (!accessmode) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected accessmode %d"), def->accessmode);
+ _("unexpected accessmode %1$d"), def->accessmode);
return -1;
}
if (!multidevs) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected multidevs %d"), def->multidevs);
+ _("unexpected multidevs %1$d"), def->multidevs);
return -1;
}
if (!backend) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected pci hostdev driver name type %d"),
+ _("unexpected pci hostdev driver name type %1$d"),
pcisrc->backend);
return -1;
}
break;
default:
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected hostdev type %d"),
+ _("unexpected hostdev type %1$d"),
def->source.caps.type);
return -1;
}
mode = virNetDevMacVLanModeTypeToString(virDomainNetGetActualDirectMode(def));
if (!mode) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected source mode %d"),
+ _("unexpected source mode %1$d"),
virDomainNetGetActualDirectMode(def));
return -1;
}
if (!typeStr) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected net type %d"), def->type);
+ _("unexpected net type %1$d"), def->type);
return -1;
}
if (publicActual) {
if (!(typeStr = virDomainNetTypeToString(actualType))) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected actual net type %d"), actualType);
+ _("unexpected actual net type %1$d"), actualType);
return -1;
}
if (actualType == VIR_DOMAIN_NET_TYPE_HOSTDEV)
} else {
if (!(typeStr = virDomainNetTypeToString(def->type))) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected net type %d"), def->type);
+ _("unexpected net type %1$d"), def->type);
return -1;
}
if (def->type == VIR_DOMAIN_NET_TYPE_HOSTDEV)
if (!type) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected char type %d"), def->type);
+ _("unexpected char type %1$d"), def->type);
return -1;
}
case VIR_DOMAIN_CHR_DEVICE_TYPE_LAST:
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected char device type %d"),
+ _("unexpected char device type %1$d"),
def->deviceType);
return -1;
}
if (!elementName) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected char device type %d"),
+ _("unexpected char device type %1$d"),
def->deviceType);
return -1;
}
if (!mode) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected smartcard type %d"), def->type);
+ _("unexpected smartcard type %1$d"), def->type);
return -1;
}
if (!type) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected codec type %d"), def->type);
+ _("unexpected codec type %1$d"), def->type);
return -1;
}
if (!model) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected sound model %d"), def->model);
+ _("unexpected sound model %1$d"), def->model);
return -1;
}
if (!type) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected audio type %d"), def->type);
+ _("unexpected audio type %1$d"), def->type);
return -1;
}
if (!model) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected memballoon model %d"), def->model);
+ _("unexpected memballoon model %1$d"), def->model);
return -1;
}
if (!model) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected watchdog model %d"), def->model);
+ _("unexpected watchdog model %1$d"), def->model);
return -1;
}
if (!action) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected watchdog action %d"), def->action);
+ _("unexpected watchdog action %1$d"), def->action);
return -1;
}
if (!model) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected video model %d"), def->type);
+ _("unexpected video model %1$d"), def->type);
return -1;
}
if (!type) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected input type %d"), def->type);
+ _("unexpected input type %1$d"), def->type);
return -1;
}
if (!bus) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected input bus type %d"), def->bus);
+ _("unexpected input bus type %1$d"), def->bus);
return -1;
}
if (!model) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected input model %d"), def->model);
+ _("unexpected input model %1$d"), def->model);
return -1;
}
if (!type) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected net type %d"), def->type);
+ _("unexpected net type %1$d"), def->type);
return -1;
}
if (!mode) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected hostdev mode %d"), def->mode);
+ _("unexpected hostdev mode %1$d"), def->mode);
return -1;
}
type = virDomainHostdevSubsysTypeToString(def->source.subsys.type);
if (!type) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected hostdev type %d"),
+ _("unexpected hostdev type %1$d"),
def->source.subsys.type);
return -1;
}
type = virDomainHostdevCapsTypeToString(def->source.caps.type);
if (!type) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected hostdev type %d"),
+ _("unexpected hostdev type %1$d"),
def->source.caps.type);
return -1;
}
break;
default:
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected hostdev mode %d"), def->mode);
+ _("unexpected hostdev mode %1$d"), def->mode);
return -1;
}
if (!type) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected hub type %d"), def->type);
+ _("unexpected hub type %1$d"), def->type);
return -1;
}
case VIR_TRISTATE_SWITCH_LAST:
case VIR_TRISTATE_SWITCH_OFF:
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Unexpected state of feature '%s'"), name);
+ _("Unexpected state of feature '%1$s'"), name);
return -1;
break;
}
if (!(type = virDomainVirtTypeToString(def->virtType))) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected domain type %d"), def->virtType);
+ _("unexpected domain type %1$d"), def->virtType);
return -1;
}
virDomainBootTypeToString(def->os.bootDevs[n]);
if (!boottype) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected boot device type %d"),
+ _("unexpected boot device type %1$d"),
def->os.bootDevs[n]);
return -1;
}
mode = virDomainSmbiosModeTypeToString(def->os.smbios_mode);
if (mode == NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected smbios mode %d"), def->os.smbios_mode);
+ _("unexpected smbios mode %1$d"), def->os.smbios_mode);
return -1;
}
virBufferAsprintf(buf, "<smbios mode='%s'/>\n", mode);
if (info->bootIndex == data->newInfo->bootIndex) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("boot order %u is already used by another device"),
+ _("boot order %1$u is already used by another device"),
data->newInfo->bootIndex);
return -1;
}
if (action == VIR_DOMAIN_DEVICE_ACTION_ATTACH &&
(virDomainDefGetMemoryTotal(def) + sz) > def->mem.max_memory) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Attaching memory device with size '%llu' would "
- "exceed domain's maxMemory config size '%llu'"),
+ _("Attaching memory device with size '%1$llu' would exceed domain's maxMemory config size '%2$llu'"),
sz, def->mem.max_memory);
return -1;
}
if (g_mkdir_with_parents(configDir, 0777) < 0) {
virReportSystemError(errno,
- _("cannot create config directory '%s'"),
+ _("cannot create config directory '%1$s'"),
configDir);
return -1;
}
if (unlink(configFile) < 0 &&
errno != ENOENT) {
virReportSystemError(errno,
- _("cannot remove config %s"),
+ _("cannot remove config %1$s"),
configFile);
return -1;
}
break;
case VIR_DOMAIN_LAST:
default:
- VIR_ERROR(_("invalid domain state: %d"), state);
+ VIR_ERROR(_("invalid domain state: %1$d"), state);
return;
}
}
virReportError(VIR_ERR_INVALID_ARG,
- _("'%s' is not a known interface"), device);
+ _("'%1$s' is not a known interface"), device);
return NULL;
}
if (dev->type == VIR_DOMAIN_DEVICE_NONE) {
if (reportError) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("no device found with alias %s"), devAlias);
+ _("no device found with alias %1$s"), devAlias);
} else {
VIR_DEBUG("no device found with alias %s", devAlias);
}
if (type >= VIR_DOMAIN_METADATA_LAST) {
virReportError(VIR_ERR_INVALID_ARG,
- _("unknown metadata type '%d'"), type);
+ _("unknown metadata type '%1$d'"), type);
return NULL;
}
if (type >= VIR_DOMAIN_METADATA_LAST) {
virReportError(VIR_ERR_INVALID_ARG,
- _("unknown metadata type '%d'"), type);
+ _("unknown metadata type '%1$d'"), type);
return -1;
}
{
if (STREQ(a->dst, b->dst)) {
virReportError(VIR_ERR_XML_ERROR,
- _("target '%s' duplicated for disk sources '%s' and '%s'"),
+ _("target '%1$s' duplicated for disk sources '%2$s' and '%3$s'"),
a->dst,
NULLSTR(virDomainDiskGetSource(a)),
NULLSTR(virDomainDiskGetSource(b)));
if (iface->type != VIR_DOMAIN_NET_TYPE_NETWORK) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Expected an interface of type 'network' not '%s'"),
+ _("Expected an interface of type 'network' not '%1$s'"),
virDomainNetTypeToString(iface->type));
return NULL;
}
if (iface->type != VIR_DOMAIN_NET_TYPE_NETWORK) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Expected an interface of type 'network' not '%s'"),
+ _("Expected an interface of type 'network' not '%1$s'"),
virDomainNetTypeToString(iface->type));
return -1;
}
if (!iface->data.network.actual) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Missing actual data for interface '%s'"),
+ _("Missing actual data for interface '%1$s'"),
iface->ifname);
return NULL;
}
if (iface->type != VIR_DOMAIN_NET_TYPE_NETWORK) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Expected an interface of type 'network' not '%s'"),
+ _("Expected an interface of type 'network' not '%1$s'"),
virDomainNetTypeToString(iface->type));
return NULL;
}
if (actual->data.hostdev.def.mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS ||
actual->data.hostdev.def.source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Actual interface '%s' hostdev was not a PCI device"),
+ _("Actual interface '%1$s' hostdev was not a PCI device"),
iface->ifname);
return NULL;
}
case VIR_DOMAIN_NET_TYPE_NULL:
case VIR_DOMAIN_NET_TYPE_VDS:
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("Unexpected network port type %s"),
+ _("Unexpected network port type %1$s"),
virDomainNetTypeToString(virDomainNetGetActualType(iface)));
return NULL;
if (g_strv_length(tokens) != 4) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected iscsi volume name '%s'"),
+ _("unexpected iscsi volume name '%1$s'"),
src->srcpool->volume);
return -1;
}
if (virStoragePoolIsActive(pool) != 1) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("storage pool '%s' containing volume '%s' "
- "is not active"),
+ _("storage pool '%1$s' containing volume '%2$s' is not active"),
src->srcpool->pool, src->srcpool->volume);
return -1;
}
case VIR_STORAGE_VOL_NETWORK:
case VIR_STORAGE_VOL_NETDIR:
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected storage volume type '%s' "
- "for storage pool type '%s'"),
+ _("unexpected storage volume type '%1$s' for storage pool type '%2$s'"),
virStorageVolTypeToString(info.type),
virStoragePoolTypeToString(pooldef->type));
return -1;
case VIR_STORAGE_POOL_GLUSTER:
case VIR_STORAGE_POOL_LAST:
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
- _("using '%s' pools for backing 'volume' disks "
- "isn't yet supported"),
+ _("using '%1$s' pools for backing 'volume' disks isn't yet supported"),
virStoragePoolTypeToString(pooldef->type));
return -1;
}
for (i = 0; i < VIR_DOMAIN_TAINT_LAST; i++) {
if (vm->taint & (1 << i)) {
(*msgs)[n++] = g_strdup_printf(
- _("tainted: %s"),
+ _("tainted: %1$s"),
_(virDomainTaintMessageTypeToString(i)));
}
}
for (i = 0; i < vm->ndeprecations; i++) {
(*msgs)[n++] = g_strdup_printf(
- _("deprecated configuration: %s"),
+ _("deprecated configuration: %1$s"),
vm->deprecations[i]);
}
}
projects / libvirt.git / commitdiff