External/libvirt
1
0
Fork 0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2024-07-31 05:57:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

qemu/qemu_domain: Update format strings in translated messages

Browse Source 
Signed-off-by: Jiri Denemark <jdenemar@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
This commit is contained in:
Jiri Denemark 2023-03-09 13:12:25 +01:00
parent 9c6fc8b555
commit 27ed822d30
1 changed files with 87 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

192
src/qemu/qemu_domain.c
View File

@ -446,7 +446,7 @@ qemuDomainObjFromDomain(virDomainPtr domain)
if (!vm) { if (!vm) {
virUUIDFormat(domain->uuid, uuidstr); virUUIDFormat(domain->uuid, uuidstr);
virReportError(VIR_ERR_NO_DOMAIN, virReportError(VIR_ERR_NO_DOMAIN,
_("no domain with matching uuid '%s' (%s)"), _("no domain with matching uuid '%1$s' (%2$s)"),
uuidstr, domain->name); uuidstr, domain->name);
return NULL; return NULL;
} }
@ -612,7 +612,7 @@ qemuDomainMasterKeyReadFile(qemuDomainObjPrivate *priv)
if (!virFileExists(path)) { if (!virFileExists(path)) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("domain master key file doesn't exist in %s"), _("domain master key file doesn't exist in %1$s"),
priv->libDir); priv->libDir);
goto error; goto error;
} }
@ -633,7 +633,7 @@ qemuDomainMasterKeyReadFile(qemuDomainObjPrivate *priv)
if (masterKeyLen != QEMU_DOMAIN_MASTER_KEY_LEN) { if (masterKeyLen != QEMU_DOMAIN_MASTER_KEY_LEN) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("invalid master key read, size=%zd"), masterKeyLen); _("invalid master key read, size=%1$zd"), masterKeyLen);
goto error; goto error;
} }
@ -1386,7 +1386,7 @@ qemuDomainSecretInfoTLSNew(qemuDomainObjPrivate *priv,
if (virUUIDParse(secretUUID, seclookupdef.u.uuid) < 0) { if (virUUIDParse(secretUUID, seclookupdef.u.uuid) < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("malformed TLS secret uuid '%s' provided"), _("malformed TLS secret uuid '%1$s' provided"),
secretUUID); secretUUID);
return NULL; return NULL;
} }
@ -2030,7 +2030,7 @@ qemuStorageSourcePrivateDataParse(xmlXPathContextPtr ctxt,
if (!(encalias = virXMLPropString(encnodes[i], "alias"))) { if (!(encalias = virXMLPropString(encnodes[i], "alias"))) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("missing alias on encryption secret #%zu"), i); _("missing alias on encryption secret #%1$zu"), i);
return -1; return -1;
} }
@ -2658,12 +2658,12 @@ qemuDomainObjPrivateXMLParseVcpu(xmlNodePtr node,
if (idstr && if (idstr &&
(virStrToLong_uip(idstr, NULL, 10, &idx) < 0)) { (virStrToLong_uip(idstr, NULL, 10, &idx) < 0)) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("cannot parse vcpu index '%s'"), idstr); _("cannot parse vcpu index '%1$s'"), idstr);
return -1; return -1;
} }
if (!(vcpu = virDomainDefGetVcpu(def, idx))) { if (!(vcpu = virDomainDefGetVcpu(def, idx))) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("invalid vcpu index '%u'"), idx); _("invalid vcpu index '%1$u'"), idx);
return -1; return -1;
} }
@ -3132,7 +3132,7 @@ qemuDomainObjPrivateXMLParseSlirpFeatures(xmlNodePtr featuresNode,
feature = qemuSlirpFeatureTypeFromString(str); feature = qemuSlirpFeatureTypeFromString(str);
if (feature < 0) { if (feature < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("Unknown slirp feature %s"), str); _("Unknown slirp feature %1$s"), str);
return -1; return -1;
} }
@ -3185,7 +3185,7 @@ qemuDomainObjPrivateXMLParse(xmlXPathContextPtr ctxt,
default: default:
VIR_FREE(monitorpath); VIR_FREE(monitorpath);
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("unsupported monitor type '%s'"), _("unsupported monitor type '%1$s'"),
virDomainChrTypeToString(priv->monConfig->type)); virDomainChrTypeToString(priv->monConfig->type));
return -1; return -1;
} }
@ -3208,7 +3208,7 @@ qemuDomainObjPrivateXMLParse(xmlXPathContextPtr ctxt,
if (ns < 0) { if (ns < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("malformed namespace name: %s"), _("malformed namespace name: %1$s"),
next->name); next->name);
return -1; return -1;
} }
@ -3248,7 +3248,7 @@ qemuDomainObjPrivateXMLParse(xmlXPathContextPtr ctxt,
int flag = virQEMUCapsTypeFromString(str); int flag = virQEMUCapsTypeFromString(str);
if (flag < 0) { if (flag < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("Unknown qemu capabilities flag %s"), str); _("Unknown qemu capabilities flag %1$s"), str);
return -1; return -1;
} }
virQEMUCapsSet(qemuCaps, flag); virQEMUCapsSet(qemuCaps, flag);
@ -3642,7 +3642,7 @@ qemuDomainDefNamespaceParseOverrideProperties(qemuDomainXmlNsOverrideProperty *p
case QEMU_DOMAIN_XML_NS_OVERRIDE_SIGNED: case QEMU_DOMAIN_XML_NS_OVERRIDE_SIGNED:
if (virStrToLong_ll(prop->value, NULL, 10, &ll) < 0) { if (virStrToLong_ll(prop->value, NULL, 10, &ll) < 0) {
virReportError(VIR_ERR_XML_ERROR, virReportError(VIR_ERR_XML_ERROR,
_("invalid value '%s' of 'value' attribute of 'qemu:property'"), _("invalid value '%1$s' of 'value' attribute of 'qemu:property'"),
prop->value); prop->value);
return -1; return -1;
} }
@ -3652,7 +3652,7 @@ qemuDomainDefNamespaceParseOverrideProperties(qemuDomainXmlNsOverrideProperty *p
case QEMU_DOMAIN_XML_NS_OVERRIDE_UNSIGNED: case QEMU_DOMAIN_XML_NS_OVERRIDE_UNSIGNED:
if (virStrToLong_ullp(prop->value, NULL, 10, &ull) < 0) { if (virStrToLong_ullp(prop->value, NULL, 10, &ull) < 0) {
virReportError(VIR_ERR_XML_ERROR, virReportError(VIR_ERR_XML_ERROR,
_("invalid value '%s' of 'value' attribute of 'qemu:property'"), _("invalid value '%1$s' of 'value' attribute of 'qemu:property'"),
prop->value); prop->value);
return -1; return -1;
} }
@ -3662,7 +3662,7 @@ qemuDomainDefNamespaceParseOverrideProperties(qemuDomainXmlNsOverrideProperty *p
case QEMU_DOMAIN_XML_NS_OVERRIDE_BOOL: case QEMU_DOMAIN_XML_NS_OVERRIDE_BOOL:
if (STRNEQ(prop->value, "true") && STRNEQ(prop->value, "false")) { if (STRNEQ(prop->value, "true") && STRNEQ(prop->value, "false")) {
virReportError(VIR_ERR_XML_ERROR, virReportError(VIR_ERR_XML_ERROR,
_("invalid value '%s' of 'value' attribute of 'qemu:property'"), _("invalid value '%1$s' of 'value' attribute of 'qemu:property'"),
prop->value); prop->value);
return -1; return -1;
} }
@ -3963,7 +3963,7 @@ qemuDomainDefSuggestDefaultAudioBackend(virQEMUDriver *driver,
} else { } else {
if (((*audioBackend) = qemuAudioDriverTypeFromString(audioenv)) < 0) { if (((*audioBackend) = qemuAudioDriverTypeFromString(audioenv)) < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("unknown QEMU_AUDIO_DRV setting %s"), audioenv); _("unknown QEMU_AUDIO_DRV setting %1$s"), audioenv);
return -1; return -1;
} }
} }
@ -3975,7 +3975,7 @@ qemuDomainDefSuggestDefaultAudioBackend(virQEMUDriver *driver,
(((*audioSDLDriver) = (((*audioSDLDriver) =
virDomainAudioSDLDriverTypeFromString(sdldriver)) <= 0)) { virDomainAudioSDLDriverTypeFromString(sdldriver)) <= 0)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("unknown SDL_AUDIODRIVER setting %s"), sdldriver); _("unknown SDL_AUDIODRIVER setting %1$s"), sdldriver);
return -1; return -1;
} }
} }
@ -4222,9 +4222,7 @@ qemuDomainDefAddDefaultDevices(virQEMUDriver *driver,
if (pciRoot >= 0) { if (pciRoot >= 0) {
if (def->controllers[pciRoot]->model != VIR_DOMAIN_CONTROLLER_MODEL_PCI_ROOT) { if (def->controllers[pciRoot]->model != VIR_DOMAIN_CONTROLLER_MODEL_PCI_ROOT) {
virReportError(VIR_ERR_XML_ERROR, virReportError(VIR_ERR_XML_ERROR,
_("The PCI controller with index='0' must be " _("The PCI controller with index='0' must be model='pci-root' for this machine type, but model='%1$s' was found instead"),
"model='pci-root' for this machine type, "
"but model='%s' was found instead"),
virDomainControllerModelPCITypeToString(def->controllers[pciRoot]->model)); virDomainControllerModelPCITypeToString(def->controllers[pciRoot]->model));
return -1; return -1;
} }
@ -4245,9 +4243,7 @@ qemuDomainDefAddDefaultDevices(virQEMUDriver *driver,
if (pciRoot >= 0) { if (pciRoot >= 0) {
if (def->controllers[pciRoot]->model != VIR_DOMAIN_CONTROLLER_MODEL_PCIE_ROOT) { if (def->controllers[pciRoot]->model != VIR_DOMAIN_CONTROLLER_MODEL_PCIE_ROOT) {
virReportError(VIR_ERR_XML_ERROR, virReportError(VIR_ERR_XML_ERROR,
_("The PCI controller with index='0' must be " _("The PCI controller with index='0' must be model='pcie-root' for this machine type, but model='%1$s' was found instead"),
"model='pcie-root' for this machine type, "
"but model='%s' was found instead"),
virDomainControllerModelPCITypeToString(def->controllers[pciRoot]->model)); virDomainControllerModelPCITypeToString(def->controllers[pciRoot]->model));
return -1; return -1;
} }
@ -4531,7 +4527,7 @@ qemuDomainDefMachinePostParse(virDomainDef *def,
def->virtType); def->virtType);
if (!machine) { if (!machine) {
virReportError(VIR_ERR_INVALID_ARG, virReportError(VIR_ERR_INVALID_ARG,
_("could not get preferred machine for %s type=%s"), _("could not get preferred machine for %1$s type=%2$s"),
def->emulator, def->emulator,
virDomainVirtTypeToString(def->virtType)); virDomainVirtTypeToString(def->virtType));
return -1; return -1;
@ -4862,7 +4858,7 @@ qemuDomainDefPostParseBasic(virDomainDef *def,
if (!(def->emulator = virQEMUCapsGetDefaultEmulator( if (!(def->emulator = virQEMUCapsGetDefaultEmulator(
driver->hostarch, def->os.arch))) { driver->hostarch, def->os.arch))) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("No emulator found for arch '%s'"), _("No emulator found for arch '%1$s'"),
virArchToString(def->os.arch)); virArchToString(def->os.arch));
return 1; return 1;
} }
@ -4960,7 +4956,7 @@ qemuDomainValidateActualNetDef(const virDomainNetDef *net,
actualType == VIR_DOMAIN_NET_TYPE_VHOSTUSER || actualType == VIR_DOMAIN_NET_TYPE_VHOSTUSER ||
actualType == VIR_DOMAIN_NET_TYPE_VDPA)) { actualType == VIR_DOMAIN_NET_TYPE_VDPA)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("interface %s - multiqueue is not supported for network interfaces of type %s"), _("interface %1$s - multiqueue is not supported for network interfaces of type %2$s"),
macstr, virDomainNetTypeToString(actualType)); macstr, virDomainNetTypeToString(actualType));
return -1; return -1;
} }
@ -4978,14 +4974,14 @@ qemuDomainValidateActualNetDef(const virDomainNetDef *net,
actualType == VIR_DOMAIN_NET_TYPE_BRIDGE || actualType == VIR_DOMAIN_NET_TYPE_BRIDGE ||
actualType == VIR_DOMAIN_NET_TYPE_ETHERNET)) { actualType == VIR_DOMAIN_NET_TYPE_ETHERNET)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("interface %s - filterref is not supported for network interfaces of type %s"), _("interface %1$s - filterref is not supported for network interfaces of type %2$s"),
macstr, virDomainNetTypeToString(actualType)); macstr, virDomainNetTypeToString(actualType));
return -1; return -1;
} }
if (vport && vport->virtPortType != VIR_NETDEV_VPORT_PROFILE_NONE) { if (vport && vport->virtPortType != VIR_NETDEV_VPORT_PROFILE_NONE) {
/* currently none of the defined virtualport types support iptables */ /* currently none of the defined virtualport types support iptables */
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("interface %s - filterref is not supported for network interfaces with virtualport type %s"), _("interface %1$s - filterref is not supported for network interfaces with virtualport type %2$s"),
macstr, virNetDevVPortTypeToString(vport->virtPortType)); macstr, virNetDevVPortTypeToString(vport->virtPortType));
return -1; return -1;
} }
@ -4996,7 +4992,7 @@ qemuDomainValidateActualNetDef(const virDomainNetDef *net,
actualType == VIR_DOMAIN_NET_TYPE_BRIDGE || actualType == VIR_DOMAIN_NET_TYPE_BRIDGE ||
actualType == VIR_DOMAIN_NET_TYPE_ETHERNET)) { actualType == VIR_DOMAIN_NET_TYPE_ETHERNET)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("interface %s - custom tap device path is not supported for network interfaces of type %s"), _("interface %1$s - custom tap device path is not supported for network interfaces of type %2$s"),
macstr, virDomainNetTypeToString(actualType)); macstr, virDomainNetTypeToString(actualType));
return -1; return -1;
} }
@ -5004,7 +5000,7 @@ qemuDomainValidateActualNetDef(const virDomainNetDef *net,
if (net->teaming && net->teaming->type == VIR_DOMAIN_NET_TEAMING_TYPE_TRANSIENT && if (net->teaming && net->teaming->type == VIR_DOMAIN_NET_TEAMING_TYPE_TRANSIENT &&
actualType != VIR_DOMAIN_NET_TYPE_HOSTDEV) { actualType != VIR_DOMAIN_NET_TYPE_HOSTDEV) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("interface %s - teaming transient device must be type='hostdev', not '%s'"), _("interface %1$s - teaming transient device must be type='hostdev', not '%2$s'"),
macstr, virDomainNetTypeToString(actualType)); macstr, virDomainNetTypeToString(actualType));
return -1; return -1;
} }
@ -5199,7 +5195,7 @@ qemuDomainValidateStorageSource(virStorageSource *src,
case VIR_STORAGE_ENCRYPTION_FORMAT_LUKS2: case VIR_STORAGE_ENCRYPTION_FORMAT_LUKS2:
case VIR_STORAGE_ENCRYPTION_FORMAT_LUKS_ANY: case VIR_STORAGE_ENCRYPTION_FORMAT_LUKS_ANY:
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("'%s' is currently not supported by the qemu encryption engine"), _("'%1$s' is currently not supported by the qemu encryption engine"),
virStorageEncryptionFormatTypeToString(src->encryption->format)); virStorageEncryptionFormatTypeToString(src->encryption->format));
return -1; return -1;
@ -5407,30 +5403,27 @@ qemuDomainShmemDefPostParse(virDomainShmemDef *shm)
if (!shm->server.enabled) { if (!shm->server.enabled) {
if (shm->model == VIR_DOMAIN_SHMEM_MODEL_IVSHMEM_DOORBELL) { if (shm->model == VIR_DOMAIN_SHMEM_MODEL_IVSHMEM_DOORBELL) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("shmem model '%s' is supported " _("shmem model '%1$s' is supported only with server option enabled"),
"only with server option enabled"),
virDomainShmemModelTypeToString(shm->model)); virDomainShmemModelTypeToString(shm->model));
return -1; return -1;
} }
if (shm->msi.enabled) { if (shm->msi.enabled) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("shmem model '%s' doesn't support " _("shmem model '%1$s' doesn't support msi"),
"msi"),
virDomainShmemModelTypeToString(shm->model)); virDomainShmemModelTypeToString(shm->model));
} }
} else { } else {
if (shm->model == VIR_DOMAIN_SHMEM_MODEL_IVSHMEM_PLAIN) { if (shm->model == VIR_DOMAIN_SHMEM_MODEL_IVSHMEM_PLAIN) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("shmem model '%s' is supported " _("shmem model '%1$s' is supported only with server option disabled"),
"only with server option disabled"),
virDomainShmemModelTypeToString(shm->model)); virDomainShmemModelTypeToString(shm->model));
return -1; return -1;
} }
if (shm->size) { if (shm->size) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("shmem model '%s' does not support size setting"), _("shmem model '%1$s' does not support size setting"),
virDomainShmemModelTypeToString(shm->model)); virDomainShmemModelTypeToString(shm->model));
return -1; return -1;
} }
@ -5510,8 +5503,7 @@ qemuDomainControllerDefPostParse(virDomainControllerDef *cont,
if (cont->model == VIR_DOMAIN_CONTROLLER_MODEL_USB_QUSB1 || if (cont->model == VIR_DOMAIN_CONTROLLER_MODEL_USB_QUSB1 ||
cont->model == VIR_DOMAIN_CONTROLLER_MODEL_USB_QUSB2) { cont->model == VIR_DOMAIN_CONTROLLER_MODEL_USB_QUSB2) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("USB controller model type 'qusb1' or 'qusb2' " _("USB controller model type 'qusb1' or 'qusb2' is not supported in %1$s"),
"is not supported in %s"),
virDomainVirtTypeToString(def->virtType)); virDomainVirtTypeToString(def->virtType));
return -1; return -1;
} }
@ -5519,7 +5511,7 @@ qemuDomainControllerDefPostParse(virDomainControllerDef *cont,
cont->model == VIR_DOMAIN_CONTROLLER_MODEL_USB_QEMU_XHCI) && cont->model == VIR_DOMAIN_CONTROLLER_MODEL_USB_QEMU_XHCI) &&
cont->opts.usbopts.ports > QEMU_USB_XHCI_MAXPORTS) { cont->opts.usbopts.ports > QEMU_USB_XHCI_MAXPORTS) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("'%s' controller only supports up to '%u' ports"), _("'%1$s' controller only supports up to '%2$u' ports"),
virDomainControllerModelUSBTypeToString(cont->model), virDomainControllerModelUSBTypeToString(cont->model),
QEMU_USB_XHCI_MAXPORTS); QEMU_USB_XHCI_MAXPORTS);
return -1; return -1;
@ -5564,10 +5556,7 @@ qemuDomainControllerDefPostParse(virDomainControllerDef *cont,
cont->opts.pciopts.numaNode >= cont->opts.pciopts.numaNode >=
(int)virDomainNumaGetNodeCount(def->numa)) { (int)virDomainNumaGetNodeCount(def->numa)) {
virReportError(VIR_ERR_XML_ERROR, virReportError(VIR_ERR_XML_ERROR,
_("%s with index %d is " _("%1$s with index %2$d is configured for a NUMA node (%3$d) not present in the domain's <cpu><numa> array (%4$zu)"),
"configured for a NUMA node (%d) "
"not present in the domain's "
"<cpu><numa> array (%zu)"),
virDomainControllerModelPCITypeToString(cont->model), virDomainControllerModelPCITypeToString(cont->model),
cont->idx, cont->opts.pciopts.numaNode, cont->idx, cont->opts.pciopts.numaNode,
virDomainNumaGetNodeCount(def->numa)); virDomainNumaGetNodeCount(def->numa));
@ -6445,7 +6434,7 @@ qemuDomainObjExitRemote(virDomainObj *obj,
if (checkActive && !virDomainObjIsActive(obj)) { if (checkActive && !virDomainObjIsActive(obj)) {
virReportError(VIR_ERR_OPERATION_FAILED, virReportError(VIR_ERR_OPERATION_FAILED,
_("domain '%s' is not running"), _("domain '%1$s' is not running"),
obj->def->name); obj->def->name);
return -1; return -1;
} }
@ -6888,7 +6877,7 @@ qemuDomainObjCheckMachineTaint(virQEMUDriver *driver,
obj->def->virtType, obj->def->virtType,
obj->def->os.machine)) { obj->def->os.machine)) {
qemuDomainObjTaintMsg(driver, obj, VIR_DOMAIN_TAINT_DEPRECATED_CONFIG, logCtxt, qemuDomainObjTaintMsg(driver, obj, VIR_DOMAIN_TAINT_DEPRECATED_CONFIG, logCtxt,
_("machine type '%s'"), _("machine type '%1$s'"),
obj->def->os.machine); obj->def->os.machine);
} }
} }
@ -6915,7 +6904,7 @@ qemuDomainObjCheckCPUTaint(virQEMUDriver *driver,
obj->def->virtType, obj->def->virtType,
obj->def->cpu->model)) { obj->def->cpu->model)) {
qemuDomainObjTaintMsg(driver, obj, VIR_DOMAIN_TAINT_DEPRECATED_CONFIG, logCtxt, qemuDomainObjTaintMsg(driver, obj, VIR_DOMAIN_TAINT_DEPRECATED_CONFIG, logCtxt,
_("CPU model '%s'"), _("CPU model '%1$s'"),
obj->def->cpu->model); obj->def->cpu->model);
} }
break; break;
@ -7057,12 +7046,12 @@ qemuDomainLogContext *qemuDomainLogContextNew(virQEMUDriver *driver,
goto error; goto error;
} else { } else {
if ((ctxt->writefd = open(ctxt->path, O_WRONLY | O_CREAT | O_APPEND, S_IRUSR | S_IWUSR)) < 0) { if ((ctxt->writefd = open(ctxt->path, O_WRONLY | O_CREAT | O_APPEND, S_IRUSR | S_IWUSR)) < 0) {
virReportSystemError(errno, _("failed to create logfile %s"), virReportSystemError(errno, _("failed to create logfile %1$s"),
ctxt->path); ctxt->path);
goto error; goto error;
} }
if (virSetCloseExec(ctxt->writefd) < 0) { if (virSetCloseExec(ctxt->writefd) < 0) {
virReportSystemError(errno, _("failed to set close-on-exec flag on %s"), virReportSystemError(errno, _("failed to set close-on-exec flag on %1$s"),
ctxt->path); ctxt->path);
goto error; goto error;
} }
@ -7073,26 +7062,26 @@ qemuDomainLogContext *qemuDomainLogContextNew(virQEMUDriver *driver,
if (mode == QEMU_DOMAIN_LOG_CONTEXT_MODE_START && if (mode == QEMU_DOMAIN_LOG_CONTEXT_MODE_START &&
!driver->privileged && !driver->privileged &&
ftruncate(ctxt->writefd, 0) < 0) { ftruncate(ctxt->writefd, 0) < 0) {
virReportSystemError(errno, _("failed to truncate %s"), virReportSystemError(errno, _("failed to truncate %1$s"),
ctxt->path); ctxt->path);
goto error; goto error;
} }
if (mode == QEMU_DOMAIN_LOG_CONTEXT_MODE_START) { if (mode == QEMU_DOMAIN_LOG_CONTEXT_MODE_START) {
if ((ctxt->readfd = open(ctxt->path, O_RDONLY)) < 0) { if ((ctxt->readfd = open(ctxt->path, O_RDONLY)) < 0) {
virReportSystemError(errno, _("failed to open logfile %s"), virReportSystemError(errno, _("failed to open logfile %1$s"),
ctxt->path); ctxt->path);
goto error; goto error;
} }
if (virSetCloseExec(ctxt->readfd) < 0) { if (virSetCloseExec(ctxt->readfd) < 0) {
virReportSystemError(errno, _("failed to set close-on-exec flag on %s"), virReportSystemError(errno, _("failed to set close-on-exec flag on %1$s"),
ctxt->path); ctxt->path);
goto error; goto error;
} }
} }
if ((ctxt->pos = lseek(ctxt->writefd, 0, SEEK_END)) < 0) { if ((ctxt->pos = lseek(ctxt->writefd, 0, SEEK_END)) < 0) {
virReportSystemError(errno, _("failed to seek in log file %s"), virReportSystemError(errno, _("failed to seek in log file %1$s"),
ctxt->path); ctxt->path);
goto error; goto error;
} }
@ -7224,7 +7213,7 @@ qemuDomainLogAppendMessage(virQEMUDriver *driver,
goto cleanup; goto cleanup;
} else { } else {
if ((writefd = open(path, O_WRONLY | O_CREAT | O_APPEND, S_IRUSR | S_IWUSR)) < 0) { if ((writefd = open(path, O_WRONLY | O_CREAT | O_APPEND, S_IRUSR | S_IWUSR)) < 0) {
virReportSystemError(errno, _("failed to create logfile %s"), virReportSystemError(errno, _("failed to create logfile %1$s"),
path); path);
goto cleanup; goto cleanup;
} }
@ -7303,7 +7292,7 @@ qemuDomainSnapshotWriteMetadata(virDomainObj *vm,
snapDir = g_strdup_printf("%s/%s", snapshotDir, vm->def->name); snapDir = g_strdup_printf("%s/%s", snapshotDir, vm->def->name);
if (g_mkdir_with_parents(snapDir, 0777) < 0) { if (g_mkdir_with_parents(snapDir, 0777) < 0) {
virReportSystemError(errno, _("cannot create snapshot directory '%s'"), virReportSystemError(errno, _("cannot create snapshot directory '%1$s'"),
snapDir); snapDir);
return -1; return -1;
} }
@ -7347,7 +7336,7 @@ qemuDomainSnapshotForEachQcow2Raw(virQEMUDriver *driver,
if (!virStorageSourceIsLocalStorage(def->disks[i]->src)) { if (!virStorageSourceIsLocalStorage(def->disks[i]->src)) {
virReportError(VIR_ERR_OPERATION_INVALID, virReportError(VIR_ERR_OPERATION_INVALID,
_("can't manipulate inactive snapshots of disk '%s'"), _("can't manipulate inactive snapshots of disk '%1$s'"),
def->disks[i]->dst); def->disks[i]->dst);
return -1; return -1;
} }
@ -7368,7 +7357,7 @@ qemuDomainSnapshotForEachQcow2Raw(virQEMUDriver *driver,
"-d", false, i); "-d", false, i);
} }
virReportError(VIR_ERR_OPERATION_INVALID, virReportError(VIR_ERR_OPERATION_INVALID,
_("Disk device '%s' does not support snapshotting"), _("Disk device '%1$s' does not support snapshotting"),
def->disks[i]->dst); def->disks[i]->dst);
return -1; return -1;
} }
@ -7778,8 +7767,8 @@ qemuDomainStorageSourceValidateDepth(virStorageSource *src,
if (nlayers > QEMU_DOMAIN_STORAGE_SOURCE_CHAIN_MAX_DEPTH) { if (nlayers > QEMU_DOMAIN_STORAGE_SOURCE_CHAIN_MAX_DEPTH) {
if (diskdst) if (diskdst)
virReportError(VIR_ERR_OPERATION_UNSUPPORTED, virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
_("backing chains more than 200 layers deep are not " _("backing chains more than 200 layers deep are not supported for disk '%1$s'"),
"supported for disk '%s'"), diskdst); diskdst);
else else
virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s", virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
_("backing chains more than 200 layers deep are not " _("backing chains more than 200 layers deep are not "
@ -8296,7 +8285,7 @@ qemuDomainDiskChangeSupported(virDomainDiskDef *disk,
break; \ break; \
if (disk->field != orig_disk->field) { \ if (disk->field != orig_disk->field) { \
virReportError(VIR_ERR_OPERATION_UNSUPPORTED, \ virReportError(VIR_ERR_OPERATION_UNSUPPORTED, \
_("cannot modify field '%s' of the disk"), \ _("cannot modify field '%1$s' of the disk"), \
field_name); \ field_name); \
return false; \ return false; \
} \ } \
@ -8308,7 +8297,7 @@ qemuDomainDiskChangeSupported(virDomainDiskDef *disk,
break; \ break; \
if (STRNEQ_NULLABLE(disk->field, orig_disk->field)) { \ if (STRNEQ_NULLABLE(disk->field, orig_disk->field)) { \
virReportError(VIR_ERR_OPERATION_UNSUPPORTED, \ virReportError(VIR_ERR_OPERATION_UNSUPPORTED, \
_("cannot modify field '%s' of the disk"), \ _("cannot modify field '%1$s' of the disk"), \
field_name); \ field_name); \
return false; \ return false; \
} \ } \
@ -8318,7 +8307,7 @@ qemuDomainDiskChangeSupported(virDomainDiskDef *disk,
CHECK_EQ(bus, "bus", false); CHECK_EQ(bus, "bus", false);
if (STRNEQ(disk->dst, orig_disk->dst)) { if (STRNEQ(disk->dst, orig_disk->dst)) {
virReportError(VIR_ERR_OPERATION_UNSUPPORTED, virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
_("cannot modify field '%s' of the disk"), _("cannot modify field '%1$s' of the disk"),
"target"); "target");
return false; return false;
} }
@ -8408,7 +8397,7 @@ qemuDomainDiskChangeSupported(virDomainDiskDef *disk,
if (disk->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE && if (disk->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE &&
!virDomainDeviceInfoAddressIsEqual(&disk->info, &orig_disk->info)) { !virDomainDeviceInfoAddressIsEqual(&disk->info, &orig_disk->info)) {
virReportError(VIR_ERR_OPERATION_UNSUPPORTED, virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
_("cannot modify field '%s' of the disk"), _("cannot modify field '%1$s' of the disk"),
"address"); "address");
return false; return false;
} }
@ -8433,7 +8422,7 @@ qemuDomainDiskChangeSupported(virDomainDiskDef *disk,
if (!virStoragePRDefIsEqual(disk->src->pr, if (!virStoragePRDefIsEqual(disk->src->pr,
orig_disk->src->pr)) { orig_disk->src->pr)) {
virReportError(VIR_ERR_OPERATION_UNSUPPORTED, virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
_("cannot modify field '%s' of the disk"), _("cannot modify field '%1$s' of the disk"),
"reservations"); "reservations");
return false; return false;
} }
@ -8452,7 +8441,7 @@ qemuDomainDiskBlockJobIsActive(virDomainDiskDef *disk)
if (disk->mirror) { if (disk->mirror) {
virReportError(VIR_ERR_BLOCK_COPY_ACTIVE, virReportError(VIR_ERR_BLOCK_COPY_ACTIVE,
_("disk '%s' already in active block job"), _("disk '%1$s' already in active block job"),
disk->dst); disk->dst);
return true; return true;
@ -8461,7 +8450,7 @@ qemuDomainDiskBlockJobIsActive(virDomainDiskDef *disk)
if (diskPriv->blockjob && if (diskPriv->blockjob &&
qemuBlockJobIsRunning(diskPriv->blockjob)) { qemuBlockJobIsRunning(diskPriv->blockjob)) {
virReportError(VIR_ERR_OPERATION_UNSUPPORTED, virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
_("disk '%s' already in active block job"), _("disk '%1$s' already in active block job"),
disk->dst); disk->dst);
return true; return true;
} }
@ -8585,8 +8574,7 @@ qemuDomainABIStabilityCheck(const virDomainDef *src,
if (src->mem.source != dst->mem.source) { if (src->mem.source != dst->mem.source) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("Target memoryBacking source '%s' doesn't " _("Target memoryBacking source '%1$s' doesn't match source memoryBacking source'%2$s'"),
"match source memoryBacking source'%s'"),
virDomainMemorySourceTypeToString(dst->mem.source), virDomainMemorySourceTypeToString(dst->mem.source),
virDomainMemorySourceTypeToString(src->mem.source)); virDomainMemorySourceTypeToString(src->mem.source));
return false; return false;
@ -8598,8 +8586,7 @@ qemuDomainABIStabilityCheck(const virDomainDef *src,
if (STRNEQ_NULLABLE(srcAlias, dstAlias)) { if (STRNEQ_NULLABLE(srcAlias, dstAlias)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("Target memory device alias '%s' doesn't " _("Target memory device alias '%1$s' doesn't match source alias '%2$s'"),
"match source alias '%s'"),
NULLSTR(srcAlias), NULLSTR(dstAlias)); NULLSTR(srcAlias), NULLSTR(dstAlias));
return false; return false;
} }
@ -8768,8 +8755,8 @@ qemuDomainAlignMemorySizes(virDomainDef *def)
if (mem > maxmemkb) { if (mem > maxmemkb) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("memory size of NUMA node '%zu' overflowed after " _("memory size of NUMA node '%1$zu' overflowed after alignment"),
"alignment"), i); i);
return -1; return -1;
} }
virDomainNumaSetNodeMemorySize(def->numa, i, mem); virDomainNumaSetNodeMemorySize(def->numa, i, mem);
@ -8808,8 +8795,8 @@ qemuDomainAlignMemorySizes(virDomainDef *def)
if (def->mems[i]->size > maxmemkb) { if (def->mems[i]->size > maxmemkb) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("size of memory module '%zu' overflowed after " _("size of memory module '%1$zu' overflowed after alignment"),
"alignment"), i); i);
return -1; return -1;
} }
} }
@ -9164,8 +9151,7 @@ qemuCheckMemoryDimmConflict(const virDomainDef *def,
if (mem->info.addr.dimm.slot == tmp->info.addr.dimm.slot) { if (mem->info.addr.dimm.slot == tmp->info.addr.dimm.slot) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("memory device slot '%u' is already being " _("memory device slot '%1$u' is already being used by another memory device"),
"used by another memory device"),
mem->info.addr.dimm.slot); mem->info.addr.dimm.slot);
return true; return true;
} }
@ -9173,8 +9159,7 @@ qemuCheckMemoryDimmConflict(const virDomainDef *def,
if (mem->info.addr.dimm.base != 0 && if (mem->info.addr.dimm.base != 0 &&
mem->info.addr.dimm.base == tmp->info.addr.dimm.base) { mem->info.addr.dimm.base == tmp->info.addr.dimm.base) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("memory device base '0x%llx' is already being " _("memory device base '0x%1$llx' is already being used by another memory device"),
"used by another memory device"),
mem->info.addr.dimm.base); mem->info.addr.dimm.base);
return true; return true;
} }
@ -9213,8 +9198,7 @@ qemuDomainDefValidateMemoryHotplugDevice(const virDomainMemoryDef *mem,
if (mem->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DIMM) { if (mem->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DIMM) {
if (mem->info.addr.dimm.slot >= def->mem.memory_slots) { if (mem->info.addr.dimm.slot >= def->mem.memory_slots) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("memory device slot '%u' exceeds slots " _("memory device slot '%1$u' exceeds slots count '%2$u'"),
"count '%u'"),
mem->info.addr.dimm.slot, def->mem.memory_slots); mem->info.addr.dimm.slot, def->mem.memory_slots);
return -1; return -1;
} }
@ -9242,7 +9226,7 @@ qemuDomainDefValidateMemoryHotplugDevice(const virDomainMemoryDef *mem,
if (mem->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI && if (mem->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI &&
mem->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE) { mem->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("only 'pci' addresses are supported for the %s device"), _("only 'pci' addresses are supported for the %1$s device"),
virDomainMemoryModelTypeToString(mem->model)); virDomainMemoryModelTypeToString(mem->model));
return -1; return -1;
} }
@ -9250,7 +9234,7 @@ qemuDomainDefValidateMemoryHotplugDevice(const virDomainMemoryDef *mem,
case VIR_DOMAIN_MEMORY_MODEL_SGX_EPC: case VIR_DOMAIN_MEMORY_MODEL_SGX_EPC:
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("hotplug is not supported for the %s device"), _("hotplug is not supported for the %1$s device"),
virDomainMemoryModelTypeToString(mem->model)); virDomainMemoryModelTypeToString(mem->model));
return -1; return -1;
@ -9330,7 +9314,7 @@ qemuDomainDefValidateMemoryHotplug(const virDomainDef *def,
if (nmems > def->mem.memory_slots) { if (nmems > def->mem.memory_slots) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("memory device count '%u' exceeds slots count '%u'"), _("memory device count '%1$u' exceeds slots count '%2$u'"),
nmems, def->mem.memory_slots); nmems, def->mem.memory_slots);
return -1; return -1;
} }
@ -9846,13 +9830,13 @@ qemuDomainValidateVcpuInfo(virDomainObj *vm)
if (vcpu->online && vcpupriv->tid == 0) { if (vcpu->online && vcpupriv->tid == 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("qemu didn't report thread id for vcpu '%zu'"), i); _("qemu didn't report thread id for vcpu '%1$zu'"), i);
return -1; return -1;
} }
if (!vcpu->online && vcpupriv->tid != 0) { if (!vcpu->online && vcpupriv->tid != 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("qemu reported thread id for inactive vcpu '%zu'"), _("qemu reported thread id for inactive vcpu '%1$zu'"),
i); i);
return -1; return -1;
} }
@ -10123,7 +10107,7 @@ qemuDomainDiskByName(virDomainDef *def,
if (!(ret = virDomainDiskByName(def, name, true))) { if (!(ret = virDomainDiskByName(def, name, true))) {
virReportError(VIR_ERR_INVALID_ARG, virReportError(VIR_ERR_INVALID_ARG,
_("disk '%s' not found in domain"), name); _("disk '%1$s' not found in domain"), name);
return NULL; return NULL;
} }
@ -10381,7 +10365,7 @@ qemuDomainPrepareStorageSourceTLS(virStorageSource *src,
case VIR_STORAGE_NET_PROTOCOL_SSH: case VIR_STORAGE_NET_PROTOCOL_SSH:
if (src->haveTLS == VIR_TRISTATE_BOOL_YES) { if (src->haveTLS == VIR_TRISTATE_BOOL_YES) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("TLS transport is not supported for disk protocol '%s'"), _("TLS transport is not supported for disk protocol '%1$s'"),
virStorageNetProtocolTypeToString(src->protocol)); virStorageNetProtocolTypeToString(src->protocol));
return -1; return -1;
} }
@ -10716,13 +10700,13 @@ qemuDomainGetStorageSourceByDevstr(const char *devstr,
if (virStorageFileParseBackingStoreStr(devstr, &target, &idx) < 0) { if (virStorageFileParseBackingStoreStr(devstr, &target, &idx) < 0) {
virReportError(VIR_ERR_INVALID_ARG, virReportError(VIR_ERR_INVALID_ARG,
_("failed to parse block device '%s'"), devstr); _("failed to parse block device '%1$s'"), devstr);
return NULL; return NULL;
} }
if (!(disk = virDomainDiskByTarget(def, target))) { if (!(disk = virDomainDiskByTarget(def, target))) {
virReportError(VIR_ERR_INVALID_ARG, virReportError(VIR_ERR_INVALID_ARG,
_("failed to find disk '%s'"), target); _("failed to find disk '%1$s'"), target);
return NULL; return NULL;
} }
@ -10758,7 +10742,7 @@ qemuDomainGetStorageSourceByDevstr(const char *devstr,
} }
virReportError(VIR_ERR_INVALID_ARG, virReportError(VIR_ERR_INVALID_ARG,
_("failed to find disk '%s'"), devstr); _("failed to find disk '%1$s'"), devstr);
return NULL; return NULL;
} }
@ -11087,7 +11071,7 @@ qemuDomainPrepareStorageSourceFDs(virStorageSource *src,
if (!(fdt = virHashLookup(priv->fds, src->fdgroup))) { if (!(fdt = virHashLookup(priv->fds, src->fdgroup))) {
virReportError(VIR_ERR_INVALID_ARG, virReportError(VIR_ERR_INVALID_ARG,
_("file descriptor group '%s' was not associated with the domain"), _("file descriptor group '%1$s' was not associated with the domain"),
src->fdgroup); src->fdgroup);
return -1; return -1;
} }
@ -11110,7 +11094,7 @@ qemuDomainPrepareStorageSourceFDs(virStorageSource *src,
if (tmpfd < 0) { if (tmpfd < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("failed to duplicate file descriptor for fd group '%s'"), _("failed to duplicate file descriptor for fd group '%1$s'"),
src->fdgroup); src->fdgroup);
return -1; return -1;
} }
@ -11621,21 +11605,21 @@ qemuDomainDiskBlockJobIsSupported(virDomainDiskDef *disk)
{ {
if (qemuDiskBusIsSD(disk->bus)) { if (qemuDiskBusIsSD(disk->bus)) {
virReportError(VIR_ERR_OPERATION_UNSUPPORTED, virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
_("block jobs are not supported on disk '%s' using bus 'sd'"), _("block jobs are not supported on disk '%1$s' using bus 'sd'"),
disk->dst); disk->dst);
return false; return false;
} }
if (disk->transient) { if (disk->transient) {
virReportError(VIR_ERR_OPERATION_UNSUPPORTED, virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
_("block jobs are not supported on transient disk '%s'"), _("block jobs are not supported on transient disk '%1$s'"),
disk->dst); disk->dst);
return false; return false;
} }
if (virStorageSourceGetActualType(disk->src) == VIR_STORAGE_TYPE_VHOST_USER) { if (virStorageSourceGetActualType(disk->src) == VIR_STORAGE_TYPE_VHOST_USER) {
virReportError(VIR_ERR_OPERATION_UNSUPPORTED, virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
_("block jobs are not supported on vhostuser disk '%s'"), _("block jobs are not supported on vhostuser disk '%1$s'"),
disk->dst); disk->dst);
return false; return false;
} }
@ -11715,10 +11699,8 @@ virQEMUFileOpenAs(uid_t fallback_uid,
case -1: case -1:
virReportSystemError(-fd, oflags & O_CREAT virReportSystemError(-fd, oflags & O_CREAT
? _("Failed to create file " ? _("Failed to create file '%1$s': couldn't determine fs type")
"'%s': couldn't determine fs type") : _("Failed to open file '%1$s': couldn't determine fs type"),
: _("Failed to open file "
"'%s': couldn't determine fs type"),
path); path);
goto cleanup; goto cleanup;
@ -11747,8 +11729,8 @@ virQEMUFileOpenAs(uid_t fallback_uid,
fallback_uid, fallback_gid, fallback_uid, fallback_gid,
vfoflags | VIR_FILE_OPEN_FORK)) < 0) { vfoflags | VIR_FILE_OPEN_FORK)) < 0) {
virReportSystemError(-fd, oflags & O_CREAT virReportSystemError(-fd, oflags & O_CREAT
? _("Error from child process creating '%s'") ? _("Error from child process creating '%1$s'")
: _("Error from child process opening '%s'"), : _("Error from child process opening '%1$s'"),
path); path);
goto cleanup; goto cleanup;
} }
@ -11761,8 +11743,8 @@ virQEMUFileOpenAs(uid_t fallback_uid,
error: error:
virReportSystemError(-fd, oflags & O_CREAT virReportSystemError(-fd, oflags & O_CREAT
? _("Failed to create file '%s'") ? _("Failed to create file '%1$s'")
: _("Failed to open file '%s'"), : _("Failed to open file '%1$s'"),
path); path);
goto cleanup; goto cleanup;
} }
@ -11890,14 +11872,14 @@ qemuDomainNamePathsCleanup(virQEMUDriverConfig *cfg,
if (virFileExists(cfg_file) && if (virFileExists(cfg_file) &&
unlink(cfg_file) < 0) { unlink(cfg_file) < 0) {
virReportSystemError(errno, _("Failed to unlink '%s'"), cfg_file); virReportSystemError(errno, _("Failed to unlink '%1$s'"), cfg_file);
if (!bestEffort) if (!bestEffort)
return -1; return -1;
} }
if (virFileIsLink(autostart_link) == 1 && if (virFileIsLink(autostart_link) == 1 &&
unlink(autostart_link) < 0) { unlink(autostart_link) < 0) {
virReportSystemError(errno, _("Failed to unlink '%s'"), autostart_link); virReportSystemError(errno, _("Failed to unlink '%1$s'"), autostart_link);
if (!bestEffort) if (!bestEffort)
return -1; return -1;
} }