[PATCH 14/27] qemu: Move error messages onto a single line

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



Error messages are exempt from the 80 columns rule. Move them
onto one line.

Signed-off-by: Michal Privoznik <mprivozn@xxxxxxxxxx>
---
 src/qemu/qemu_agent.c            |  18 +--
 src/qemu/qemu_capabilities.c     |  45 +++----
 src/qemu/qemu_command.c          |  42 ++-----
 src/qemu/qemu_conf.c             |   5 +-
 src/qemu/qemu_domain.c           |  51 +++-----
 src/qemu/qemu_domain_address.c   |  15 +--
 src/qemu/qemu_driver.c           | 120 ++++++------------
 src/qemu/qemu_hostdev.c          |   3 +-
 src/qemu/qemu_hotplug.c          |  18 +--
 src/qemu/qemu_migration.c        |  48 +++----
 src/qemu/qemu_migration_params.c |   6 +-
 src/qemu/qemu_monitor.c          |   3 +-
 src/qemu/qemu_monitor_json.c     | 102 +++++----------
 src/qemu/qemu_process.c          |  20 +--
 src/qemu/qemu_snapshot.c         |  27 ++--
 src/qemu/qemu_tpm.c              |   4 +-
 src/qemu/qemu_validate.c         | 209 ++++++++++---------------------
 17 files changed, 243 insertions(+), 493 deletions(-)

diff --git a/src/qemu/qemu_agent.c b/src/qemu/qemu_agent.c
index 7fc412c17e..f9bcf38dfb 100644
--- a/src/qemu/qemu_agent.c
+++ b/src/qemu/qemu_agent.c
@@ -160,8 +160,7 @@ qemuAgentOpenUnix(const char *socketpath)
 
     if (virSetCloseExec(agentfd) < 0) {
         virReportSystemError(errno, "%s",
-                             _("Unable to set agent "
-                               "close-on-exec flag"));
+                             _("Unable to set agent close-on-exec flag"));
         goto error;
     }
 
@@ -757,8 +756,7 @@ static int qemuAgentSend(qemuAgent *agent,
                 ret = -2;
             } else {
                 virReportSystemError(errno, "%s",
-                                     _("Unable to wait on agent socket "
-                                       "condition"));
+                                     _("Unable to wait on agent socket condition"));
             }
             agent->inSync = false;
             goto cleanup;
@@ -1344,8 +1342,7 @@ qemuAgentGetVCPUs(qemuAgent *agent,
 
         if (!entry) {
             virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                           _("array element missing in guest-get-vcpus return "
-                             "value"));
+                           _("array element missing in guest-get-vcpus return value"));
             return -1;
         }
 
@@ -1862,8 +1859,7 @@ qemuAgentGetFSInfo(qemuAgent *agent,
 
         if (!(result = virJSONValueObjectGetString(entry, "mountpoint"))) {
             virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                           _("'mountpoint' missing in reply of "
-                             "guest-get-fsinfo"));
+                           _("'mountpoint' missing in reply of guest-get-fsinfo"));
             goto cleanup;
         }
 
@@ -2207,8 +2203,7 @@ qemuAgentGetUsers(qemuAgent *agent,
 
         if (!entry) {
             virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                           _("array element missing in guest-get-users return "
-                             "value"));
+                           _("array element missing in guest-get-users return value"));
             return -1;
         }
 
@@ -2522,8 +2517,7 @@ int qemuAgentGetDisks(qemuAgent *agent,
 
         if (!entry) {
             virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                           _("array element missing in guest-get-disks return "
-                             "value"));
+                           _("array element missing in guest-get-disks return value"));
             goto error;
         }
 
diff --git a/src/qemu/qemu_capabilities.c b/src/qemu/qemu_capabilities.c
index 05cc11218a..bdb20b47ba 100644
--- a/src/qemu/qemu_capabilities.c
+++ b/src/qemu/qemu_capabilities.c
@@ -3957,8 +3957,7 @@ virQEMUCapsLoadHostCPUModelInfo(virQEMUCapsAccel *caps,
 
     if (!(hostCPU->name = virXMLPropString(hostCPUNode, "model"))) {
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                       _("missing host CPU model name in QEMU "
-                         "capabilities cache"));
+                       _("missing host CPU model name in QEMU capabilities cache"));
         return -1;
     }
 
@@ -3983,16 +3982,14 @@ virQEMUCapsLoadHostCPUModelInfo(virQEMUCapsAccel *caps,
 
             if (!(prop->name = virXMLPropString(ctxt->node, "name"))) {
                 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                               _("missing 'name' attribute for a host CPU"
-                                 " model property in QEMU capabilities cache"));
+                               _("missing 'name' attribute for a host CPU model property in QEMU capabilities cache"));
                 return -1;
             }
 
             if (!(type = virXMLPropString(ctxt->node, "type")) ||
                 (val = qemuMonitorCPUPropertyTypeFromString(type)) < 0) {
                 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                               _("missing or invalid CPU model property type "
-                                 "in QEMU capabilities cache"));
+                               _("missing or invalid CPU model property type in QEMU capabilities cache"));
                 return -1;
             }
 
@@ -4109,8 +4106,7 @@ virQEMUCapsLoadCPUModels(virArch arch,
             for (j = 0; j < nblockers; j++) {
                 if (!(cpu->blockers[j] = virXMLPropString(blockerNodes[j], "name"))) {
                     virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                                   _("missing blocker name in QEMU "
-                                     "capabilities cache"));
+                                   _("missing blocker name in QEMU capabilities cache"));
                     return -1;
                 }
 
@@ -4254,8 +4250,7 @@ virQEMUCapsParseSEVInfo(virQEMUCaps *qemuCaps, xmlXPathContextPtr ctxt)
 
     if (virXPathBoolean("boolean(./sev)", ctxt) == 0) {
         virReportError(VIR_ERR_XML_ERROR, "%s",
-                       _("missing SEV platform data in QEMU "
-                         "capabilities cache"));
+                       _("missing SEV platform data in QEMU capabilities cache"));
         return -1;
     }
 
@@ -4263,30 +4258,26 @@ virQEMUCapsParseSEVInfo(virQEMUCaps *qemuCaps, xmlXPathContextPtr ctxt)
 
     if (virXPathUInt("string(./sev/cbitpos)", ctxt, &sev->cbitpos) < 0) {
         virReportError(VIR_ERR_XML_ERROR, "%s",
-                       _("missing or malformed SEV cbitpos information "
-                         "in QEMU capabilities cache"));
+                       _("missing or malformed SEV cbitpos information in QEMU capabilities cache"));
         return -1;
     }
 
     if (virXPathUInt("string(./sev/reducedPhysBits)", ctxt,
                      &sev->reduced_phys_bits) < 0) {
         virReportError(VIR_ERR_XML_ERROR, "%s",
-                       _("missing or malformed SEV reducedPhysBits information "
-                         "in QEMU capabilities cache"));
+                       _("missing or malformed SEV reducedPhysBits information in QEMU capabilities cache"));
         return -1;
     }
 
     if (!(sev->pdh = virXPathString("string(./sev/pdh)", ctxt)))  {
         virReportError(VIR_ERR_XML_ERROR, "%s",
-                       _("missing SEV pdh information "
-                         "in QEMU capabilities cache"));
+                       _("missing SEV pdh information in QEMU capabilities cache"));
         return -1;
     }
 
     if (!(sev->cert_chain = virXPathString("string(./sev/certChain)", ctxt))) {
         virReportError(VIR_ERR_XML_ERROR, "%s",
-                       _("missing SEV certChain information "
-                         "in QEMU capabilities cache"));
+                       _("missing SEV certChain information in QEMU capabilities cache"));
         return -1;
     }
 
@@ -4507,28 +4498,24 @@ virQEMUCapsParseGIC(virQEMUCaps *qemuCaps, xmlXPathContextPtr ctxt)
 
             if (!(version = virXMLPropString(nodes[i], "version"))) {
                 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                               _("missing GIC version "
-                                 "in QEMU capabilities cache"));
+                               _("missing GIC version in QEMU capabilities cache"));
                 return -1;
             }
             if (virStrToLong_ui(version, NULL, 10, &uintValue) < 0) {
                 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                               _("malformed GIC version "
-                                 "in QEMU capabilities cache"));
+                               _("malformed GIC version in QEMU capabilities cache"));
                 return -1;
             }
             cap->version = uintValue;
 
             if (!(kernel = virXMLPropString(nodes[i], "kernel"))) {
                 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                               _("missing in-kernel GIC information "
-                                 "in QEMU capabilities cache"));
+                               _("missing in-kernel GIC information in QEMU capabilities cache"));
                 return -1;
             }
             if (!(boolValue = STREQ(kernel, "yes")) && STRNEQ(kernel, "no")) {
                 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                               _("malformed in-kernel GIC information "
-                                 "in QEMU capabilities cache"));
+                               _("malformed in-kernel GIC information in QEMU capabilities cache"));
                 return -1;
             }
             if (boolValue)
@@ -4536,14 +4523,12 @@ virQEMUCapsParseGIC(virQEMUCaps *qemuCaps, xmlXPathContextPtr ctxt)
 
             if (!(emulated = virXMLPropString(nodes[i], "emulated"))) {
                 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                               _("missing emulated GIC information "
-                                 "in QEMU capabilities cache"));
+                               _("missing emulated GIC information in QEMU capabilities cache"));
                 return -1;
             }
             if (!(boolValue = STREQ(emulated, "yes")) && STRNEQ(emulated, "no")) {
                 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                               _("malformed emulated GIC information "
-                                 "in QEMU capabilities cache"));
+                               _("malformed emulated GIC information in QEMU capabilities cache"));
                 return -1;
             }
             if (boolValue)
diff --git a/src/qemu/qemu_command.c b/src/qemu/qemu_command.c
index 6bcf2fdadd..4aa686bfd5 100644
--- a/src/qemu/qemu_command.c
+++ b/src/qemu/qemu_command.c
@@ -2910,8 +2910,7 @@ qemuBuildLegacyUSBControllerCommandLine(virCommand *cmd,
 
     if (nlegacy > 1) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Multiple legacy USB controllers are "
-                         "not supported"));
+                       _("Multiple legacy USB controllers are not supported"));
         return -1;
     }
 
@@ -3122,9 +3121,8 @@ qemuBuildMemoryGetDefaultPagesize(virQEMUDriverConfig *cfg,
     virHugeTLBFS *p;
 
     if (!cfg->nhugetlbfs) {
-        virReportError(VIR_ERR_INTERNAL_ERROR,
-                       "%s", _("hugetlbfs filesystem is not mounted "
-                               "or disabled by administrator config"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("hugetlbfs filesystem is not mounted or disabled by administrator config"));
         return -1;
     }
 
@@ -3482,8 +3480,7 @@ qemuBuildMemoryBackendProps(virJSONValue **backendProps,
         mem->source.nvdimm.pmem) {
         if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_OBJECT_MEMORY_FILE_PMEM)) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("nvdimm pmem property is not available "
-                             "with this QEMU binary"));
+                           _("nvdimm pmem property is not available with this QEMU binary"));
             return -1;
         }
         if (virJSONValueObjectAdd(&props, "b:pmem", true, NULL) < 0)
@@ -5747,8 +5744,7 @@ qemuBuildSmbiosCommandLine(virCommand *cmd,
 
         if (source->nbaseBoard > 1) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("qemu does not support more than "
-                             "one entry to Type 2 in SMBIOS table"));
+                           _("qemu does not support more than one entry to Type 2 in SMBIOS table"));
             return -1;
         }
 
@@ -6242,8 +6238,7 @@ qemuBuildGlobalControllerCommandLine(virCommand *cmd,
 
             default:
                 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                               _("64-bit PCI hole setting is only for root"
-                                 " PCI controllers"));
+                               _("64-bit PCI hole setting is only for root PCI controllers"));
                 return -1;
             }
 
@@ -6782,8 +6777,7 @@ qemuAppendDomainFeaturesMachineParam(virBuffer *buf,
         case VIR_GIC_VERSION_HOST:
             if (!hasGICVersionOption) {
                 virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                               _("gic-version option is not available "
-                                 "with this QEMU binary"));
+                               _("gic-version option is not available with this QEMU binary"));
                 return -1;
             }
 
@@ -8252,9 +8246,7 @@ qemuBuildGraphicsSPICECommandLine(virQEMUDriverConfig *cfg,
     case VIR_DOMAIN_GRAPHICS_SPICE_CHANNEL_MODE_SECURE:
         if (!hasSecure) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("spice defaultMode secure requested in XML "
-                             "configuration, but TLS connection is not "
-                             "available"));
+                           _("spice defaultMode secure requested in XML configuration, but TLS connection is not available"));
             return -1;
         }
         virBufferAddLit(&opt, "tls-channel=default,");
@@ -8262,9 +8254,7 @@ qemuBuildGraphicsSPICECommandLine(virQEMUDriverConfig *cfg,
     case VIR_DOMAIN_GRAPHICS_SPICE_CHANNEL_MODE_INSECURE:
         if (!hasInsecure) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("spice defaultMode insecure requested in XML "
-                             "configuration, but plaintext connection is not "
-                             "available"));
+                           _("spice defaultMode insecure requested in XML configuration, but plaintext connection is not available"));
             return -1;
         }
         virBufferAddLit(&opt, "plaintext-channel=default,");
@@ -8280,9 +8270,7 @@ qemuBuildGraphicsSPICECommandLine(virQEMUDriverConfig *cfg,
         case VIR_DOMAIN_GRAPHICS_SPICE_CHANNEL_MODE_SECURE:
             if (!hasSecure) {
                 virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                               _("spice secure channels set in XML "
-                                 "configuration, but TLS connection is not "
-                                 "available"));
+                               _("spice secure channels set in XML configuration, but TLS connection is not available"));
                 return -1;
             }
             virBufferAsprintf(&opt, "tls-channel=%s,",
@@ -8292,9 +8280,7 @@ qemuBuildGraphicsSPICECommandLine(virQEMUDriverConfig *cfg,
         case VIR_DOMAIN_GRAPHICS_SPICE_CHANNEL_MODE_INSECURE:
             if (!hasInsecure) {
                 virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                               _("spice insecure channels set in XML "
-                                 "configuration, but plaintext connection "
-                                 "is not available"));
+                               _("spice insecure channels set in XML configuration, but plaintext connection is not available"));
                 return -1;
             }
             virBufferAsprintf(&opt, "plaintext-channel=%s,",
@@ -9030,8 +9016,7 @@ qemuBuildShmemCommandLine(virCommand *cmd,
 
     if (shmem->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("only 'pci' addresses are supported for the "
-                         "shared memory device"));
+                       _("only 'pci' addresses are supported for the shared memory device"));
         return -1;
     }
 
@@ -10027,8 +10012,7 @@ qemuBuildCommandLineValidate(virQEMUDriver *driver,
 
     if (sdl > 1 || vnc > 1 || spice > 1 || egl_headless > 1 || dbus > 1) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("only 1 graphics device of each type "
-                         "(sdl, vnc, spice, headless, dbus) is supported"));
+                       _("only 1 graphics device of each type (sdl, vnc, spice, headless, dbus) is supported"));
         return -1;
     }
 
diff --git a/src/qemu/qemu_conf.c b/src/qemu/qemu_conf.c
index 3f811d064f..94648026fb 100644
--- a/src/qemu/qemu_conf.c
+++ b/src/qemu/qemu_conf.c
@@ -1548,9 +1548,8 @@ qemuGetDomainHupageMemPath(virQEMUDriver *driver,
     size_t i = 0;
 
     if (!cfg->nhugetlbfs) {
-        virReportError(VIR_ERR_INTERNAL_ERROR,
-                       "%s", _("hugetlbfs filesystem is not mounted "
-                               "or disabled by administrator config"));
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("hugetlbfs filesystem is not mounted or disabled by administrator config"));
         return -1;
     }
 
diff --git a/src/qemu/qemu_domain.c b/src/qemu/qemu_domain.c
index 0b2b22a219..03c2aa1002 100644
--- a/src/qemu/qemu_domain.c
+++ b/src/qemu/qemu_domain.c
@@ -4591,8 +4591,7 @@ qemuDomainDefVcpusPostParse(virDomainDef *def)
             /* they can be ordered only at the beginning */
             if (prevvcpu->hotpluggable == VIR_TRISTATE_BOOL_YES) {
                 virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                               _("online non-hotpluggable vcpus need to be "
-                                 "ordered prior to hotplugable vcpus"));
+                               _("online non-hotpluggable vcpus need to be ordered prior to hotplugable vcpus"));
                 return -1;
             }
 
@@ -4600,8 +4599,7 @@ qemuDomainDefVcpusPostParse(virDomainDef *def)
              * Also note that multiple vcpus may share order on some platforms */
             if (prevvcpu->order > vcpu->order) {
                 virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                               _("online non-hotpluggable vcpus must be ordered "
-                                 "in ascending order"));
+                               _("online non-hotpluggable vcpus must be ordered in ascending order"));
                 return -1;
             }
         }
@@ -4644,8 +4642,7 @@ qemuDomainDefSetDefaultCPU(virDomainDef *def,
 
     if (STREQ(model, "host") && def->virtType != VIR_DOMAIN_VIRT_KVM) {
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                       _("QEMU reports invalid default CPU model \"host\" "
-                         "for non-kvm domain virt type"));
+                       _("QEMU reports invalid default CPU model \"host\" for non-kvm domain virt type"));
         return -1;
     }
 
@@ -5080,15 +5077,13 @@ qemuDomainValidateStorageSource(virStorageSource *src,
 
     if (src->format == VIR_STORAGE_FILE_DIR) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("'directory' storage format is not directly supported by QEMU, "
-                         "use 'dir' disk type instead"));
+                       _("'directory' storage format is not directly supported by QEMU, use 'dir' disk type instead"));
         return -1;
     }
 
     if (src->format == VIR_STORAGE_FILE_ISO) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("storage format 'iso' is not directly supported by QEMU, "
-                         "use 'raw' instead"));
+                       _("storage format 'iso' is not directly supported by QEMU, use 'raw' instead"));
         return -1;
     }
 
@@ -5096,8 +5091,7 @@ qemuDomainValidateStorageSource(virStorageSource *src,
         actualType != VIR_STORAGE_TYPE_VOLUME &&
         actualType != VIR_STORAGE_TYPE_DIR) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("storage format 'fat' is supported only with 'dir' "
-                         "storage type"));
+                       _("storage format 'fat' is supported only with 'dir' storage type"));
         return -1;
     }
 
@@ -5628,23 +5622,20 @@ qemuDomainControllerDefPostParse(virDomainControllerDef *cont,
              cont->model == VIR_DOMAIN_CONTROLLER_MODEL_PCIE_ROOT) &&
             cont->idx != 0) {
             virReportError(VIR_ERR_XML_ERROR, "%s",
-                           _("pci-root and pcie-root controllers "
-                             "should have index 0"));
+                           _("pci-root and pcie-root controllers should have index 0"));
             return -1;
         }
 
         if (cont->model == VIR_DOMAIN_CONTROLLER_MODEL_PCI_EXPANDER_BUS &&
             !qemuDomainIsI440FX(def)) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("pci-expander-bus controllers are only supported "
-                             "on 440fx-based machinetypes"));
+                           _("pci-expander-bus controllers are only supported on 440fx-based machinetypes"));
             return -1;
         }
         if (cont->model == VIR_DOMAIN_CONTROLLER_MODEL_PCIE_EXPANDER_BUS &&
             !(qemuDomainIsQ35(def) || qemuDomainIsARMVirt(def))) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("pcie-expander-bus controllers are not supported "
-                             "with this machine type"));
+                           _("pcie-expander-bus controllers are not supported with this machine type"));
             return -1;
         }
 
@@ -6129,8 +6120,7 @@ qemuDomainNVDimmAlignSizePseries(virDomainMemoryDef *mem)
      * smaller than the 256MiB alignment. */
     if (guestArea < ppc64AlignSize) {
         virReportError(VIR_ERR_XML_ERROR, "%s",
-                       _("minimum target size for the NVDIMM "
-                         "must be 256MB plus the label size"));
+                       _("minimum target size for the NVDIMM must be 256MB plus the label size"));
         return -1;
     }
 
@@ -7868,8 +7858,7 @@ qemuDomainStorageSourceValidateDepth(virStorageSource *src,
                            diskdst);
         else
             virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                           _("backing chains more than 200 layers deep are not "
-                             "supported"));
+                           _("backing chains more than 200 layers deep are not supported"));
 
         return -1;
     }
@@ -8785,8 +8774,7 @@ qemuDomainAgentAvailable(virDomainObj *vm,
     if (priv->agentError) {
         if (reportError) {
             virReportError(VIR_ERR_AGENT_UNRESPONSIVE, "%s",
-                           _("QEMU guest agent is not "
-                             "available due to an error"));
+                           _("QEMU guest agent is not available due to an error"));
         }
         return false;
     }
@@ -9284,8 +9272,7 @@ qemuDomainDefValidateMemoryHotplugDevice(const virDomainMemoryDef *mem,
         if (mem->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DIMM &&
             mem->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("only 'dimm' addresses are supported for the "
-                             "pc-dimm device"));
+                           _("only 'dimm' addresses are supported for the pc-dimm device"));
             return -1;
         }
 
@@ -9307,8 +9294,7 @@ qemuDomainDefValidateMemoryHotplugDevice(const virDomainMemoryDef *mem,
         if (mem->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI &&
             mem->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("only 'pci' addresses are supported for the "
-                             "virtio-pmem device"));
+                           _("only 'pci' addresses are supported for the virtio-pmem device"));
             return -1;
         }
 
@@ -9341,8 +9327,7 @@ qemuDomainDefValidateMemoryHotplugDevice(const virDomainMemoryDef *mem,
         virDomainNumaGetNodeCount(def->numa) != 0) {
         if (mem->targetNode == -1) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("target NUMA node needs to be specified for "
-                             "memory device"));
+                           _("target NUMA node needs to be specified for memory device"));
             return -1;
         }
     }
@@ -9400,8 +9385,7 @@ qemuDomainDefValidateMemoryHotplug(const virDomainDef *def,
     if (!virDomainDefHasMemoryHotplug(def)) {
         if (nmems) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("cannot use/hotplug a memory device when domain "
-                             "'maxMemory' is not defined"));
+                           _("cannot use/hotplug a memory device when domain 'maxMemory' is not defined"));
             return -1;
         }
 
@@ -9415,8 +9399,7 @@ qemuDomainDefValidateMemoryHotplug(const virDomainDef *def,
          * with memory hotplug. */
         if (virDomainNumaGetNodeCount(def->numa) == 0) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("At least one numa node has to be configured when "
-                             "enabling memory hotplug"));
+                           _("At least one numa node has to be configured when enabling memory hotplug"));
             return -1;
         }
     }
diff --git a/src/qemu/qemu_domain_address.c b/src/qemu/qemu_domain_address.c
index 49c5e199fa..e26dc38f76 100644
--- a/src/qemu/qemu_domain_address.c
+++ b/src/qemu/qemu_domain_address.c
@@ -1633,8 +1633,7 @@ qemuDomainCollectPCIAddress(virDomainDef *def G_GNUC_UNUSED,
             if (addrs->nbuses > 0 &&
                 !(addrs->buses[0].flags & VIR_PCI_CONNECT_TYPE_PCI_DEVICE)) {
                 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                               _("Bus 0 must be PCI for integrated PIIX3 "
-                                 "USB or IDE controllers"));
+                               _("Bus 0 must be PCI for integrated PIIX3 USB or IDE controllers"));
                 return -1;
             }
             return 0;
@@ -1809,8 +1808,7 @@ qemuDomainValidateDevicePCISlotsPIIX3(virDomainDef *def,
                 if (!virPCIDeviceAddressEqual(&cont->info.addr.pci,
                                               &primaryIDEAddr)) {
                     virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                                   _("Primary IDE controller must have PCI "
-                                     "address 0:0:1.1"));
+                                   _("Primary IDE controller must have PCI address 0:0:1.1"));
                     return -1;
                 }
             } else {
@@ -1825,8 +1823,7 @@ qemuDomainValidateDevicePCISlotsPIIX3(virDomainDef *def,
                 if (!virPCIDeviceAddressEqual(&cont->info.addr.pci,
                                               &piix3USBAddr)) {
                     virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                                   _("PIIX3 USB controller at index 0 must "
-                                     "have PCI address 0:0:1.2"));
+                                   _("PIIX3 USB controller at index 0 must have PCI address 0:0:1.2"));
                     return -1;
                 }
             } else {
@@ -1919,8 +1916,7 @@ qemuDomainValidateDevicePCISlotsQ35(virDomainDef *def,
                     if (!virPCIDeviceAddressEqual(&cont->info.addr.pci,
                                                   &primarySATAAddr)) {
                         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                                       _("Primary SATA controller must have "
-                                         "PCI address 0:0:1f.2"));
+                                       _("Primary SATA controller must have PCI address 0:0:1f.2"));
                         return -1;
                     }
                 } else {
@@ -3053,8 +3049,7 @@ qemuDomainUSBAddressAddHubs(virDomainDef *def)
 
     if (data.count > 0 && !virDomainDefHasUSB(def)) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("USB is disabled for this domain, but USB devices "
-                         "are present in the domain XML"));
+                       _("USB is disabled for this domain, but USB devices are present in the domain XML"));
         return -1;
     }
 
diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c
index 5db42f0753..0d4da937b0 100644
--- a/src/qemu/qemu_driver.c
+++ b/src/qemu/qemu_driver.c
@@ -2198,8 +2198,7 @@ static int qemuDomainSetMemoryFlags(virDomainPtr dom, unsigned long newmem,
 
         if (def) {
             virReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                           _("cannot resize the maximum memory on an "
-                             "active domain"));
+                           _("cannot resize the maximum memory on an active domain"));
             goto endjob;
         }
 
@@ -2208,16 +2207,14 @@ static int qemuDomainSetMemoryFlags(virDomainPtr dom, unsigned long newmem,
              * is no way to change the individual node sizes with this API */
             if (virDomainNumaGetNodeCount(persistentDef->numa) > 0) {
                 virReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                               _("initial memory size of a domain with NUMA "
-                                 "nodes cannot be modified with this API"));
+                               _("initial memory size of a domain with NUMA nodes cannot be modified with this API"));
                 goto endjob;
             }
 
             if (persistentDef->mem.max_memory &&
                 persistentDef->mem.max_memory < newmem) {
                 virReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                               _("cannot set initial memory size greater than "
-                                 "the maximum memory size"));
+                               _("cannot set initial memory size greater than the maximum memory size"));
                 goto endjob;
             }
 
@@ -2274,8 +2271,7 @@ static int qemuDomainSetMemoryFlags(virDomainPtr dom, unsigned long newmem,
             /* Lack of balloon support is a fatal error */
             if (r == 0) {
                 virReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                               _("Unable to change memory of active domain without "
-                                 "the balloon device and guest OS balloon driver"));
+                               _("Unable to change memory of active domain without the balloon device and guest OS balloon driver"));
                 goto endjob;
             }
         }
@@ -2341,8 +2337,7 @@ static int qemuDomainSetMemoryStatsPeriod(virDomainPtr dom, int period,
     if (def) {
         if (!virDomainDefHasMemballoon(def)) {
             virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                           _("No memory balloon device configured, "
-                             "can not set the collection period"));
+                           _("No memory balloon device configured, can not set the collection period"));
             goto endjob;
         }
 
@@ -2362,8 +2357,7 @@ static int qemuDomainSetMemoryStatsPeriod(virDomainPtr dom, int period,
     if (persistentDef) {
         if (!virDomainDefHasMemballoon(persistentDef)) {
             virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                           _("No memory balloon device configured, "
-                             "can not set the collection period"));
+                           _("No memory balloon device configured, can not set the collection period"));
             goto endjob;
         }
         persistentDef->memballoon->period = period;
@@ -3141,8 +3135,7 @@ doCoreDump(virQEMUDriver *driver,
     } else {
         if (dumpformat != VIR_DOMAIN_CORE_DUMP_FORMAT_RAW) {
             virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                           _("kdump-compressed format is only supported with "
-                             "memory-only dump"));
+                           _("kdump-compressed format is only supported with memory-only dump"));
             goto cleanup;
         }
 
@@ -4166,8 +4159,7 @@ qemuDomainSetVcpusMax(virQEMUDriver *driver,
 
     if (virDomainNumaGetCPUCountTotal(persistentDef->numa) > nvcpus) {
         virReportError(VIR_ERR_INVALID_ARG, "%s",
-                       _("Number of CPUs in <numa> exceeds the desired "
-                         "maximum vcpu count"));
+                       _("Number of CPUs in <numa> exceeds the desired maximum vcpu count"));
         return -1;
     }
 
@@ -4514,8 +4506,7 @@ qemuDomainPinEmulator(virDomainPtr dom,
 
             if (virDomainCgroupSetupCpusetCpus(cgroup_emulator, pcpumap) < 0) {
                 virReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                               _("failed to set cpuset.cpus in cgroup"
-                                 " for emulator threads"));
+                               _("failed to set cpuset.cpus in cgroup for emulator threads"));
                 goto endjob;
             }
         }
@@ -4665,8 +4656,7 @@ qemuDomainGetVcpusFlags(virDomainPtr dom, unsigned int flags)
 
         if (!virDomainObjIsActive(vm)) {
             virReportError(VIR_ERR_INVALID_ARG, "%s",
-                           _("vCPU count provided by the guest agent can only be "
-                             "requested for live domains"));
+                           _("vCPU count provided by the guest agent can only be requested for live domains"));
             goto endjob;
         }
 
@@ -6539,14 +6529,12 @@ qemuDomainUndefineFlags(virDomainPtr dom,
         if (flags & VIR_DOMAIN_UNDEFINE_MANAGED_SAVE) {
             if (unlink(name) < 0) {
                 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                               _("Failed to remove domain managed "
-                                 "save image"));
+                               _("Failed to remove domain managed save image"));
                 goto endjob;
             }
         } else {
             virReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                           _("Refusing to undefine while domain managed "
-                             "save image exists"));
+                           _("Refusing to undefine while domain managed save image exists"));
             goto endjob;
         }
     }
@@ -10635,8 +10623,7 @@ qemuDomainMigratePrepare2(virConnectPtr dconn,
          * VIR_MIGRATE_TUNNELLED set
          */
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                       _("Tunnelled migration requested but invalid "
-                         "RPC method called"));
+                       _("Tunnelled migration requested but invalid RPC method called"));
         return -1;
     }
 
@@ -10865,8 +10852,7 @@ qemuDomainMigratePrepare3(virConnectPtr dconn,
          * VIR_MIGRATE_TUNNELLED set
          */
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                       _("Tunnelled migration requested but invalid "
-                         "RPC method called"));
+                       _("Tunnelled migration requested but invalid RPC method called"));
         return -1;
     }
 
@@ -10952,24 +10938,21 @@ qemuDomainMigratePrepare3Params(virConnectPtr dconn,
         nmigrate_disks > 0) {
         if (uri_in && STRPREFIX(uri_in, "unix:") && !nbdURI) {
             virReportError(VIR_ERR_INVALID_ARG, "%s",
-                           _("NBD URI must be supplied when "
-                             "migration URI uses UNIX transport method"));
+                           _("NBD URI must be supplied when migration URI uses UNIX transport method"));
             return -1;
         }
     }
 
     if (nbdURI && nbdPort) {
         virReportError(VIR_ERR_INVALID_ARG, "%s",
-                       _("Both port and URI requested for disk migration "
-                         "while being mutually exclusive"));
+                       _("Both port and URI requested for disk migration while being mutually exclusive"));
         return -1;
     }
 
     if (listenAddress) {
         if (uri_in && STRPREFIX(uri_in, "unix:")) {
             virReportError(VIR_ERR_INVALID_ARG, "%s",
-                           _("Usage of listen-address is forbidden when "
-                             "migration URI uses UNIX transport method"));
+                           _("Usage of listen-address is forbidden when migration URI uses UNIX transport method"));
             return -1;
         }
     } else {
@@ -10981,8 +10964,7 @@ qemuDomainMigratePrepare3Params(virConnectPtr dconn,
          * VIR_MIGRATE_TUNNELLED set
          */
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                       _("Tunnelled migration requested but invalid "
-                         "RPC method called"));
+                       _("Tunnelled migration requested but invalid RPC method called"));
         return -1;
     }
 
@@ -11201,16 +11183,14 @@ qemuDomainMigratePerform3Params(virDomainPtr dom,
 
     if (nbdURI && nbdPort) {
         virReportError(VIR_ERR_INVALID_ARG, "%s",
-                       _("Both port and URI requested for disk migration "
-                         "while being mutually exclusive"));
+                       _("Both port and URI requested for disk migration while being mutually exclusive"));
         goto cleanup;
     }
 
     if (listenAddress) {
         if (uri && STRPREFIX(uri, "unix:")) {
             virReportError(VIR_ERR_INVALID_ARG, "%s",
-                           _("Usage of listen-address is forbidden when "
-                             "migration URI uses UNIX transport method"));
+                           _("Usage of listen-address is forbidden when migration URI uses UNIX transport method"));
             return -1;
         }
     }
@@ -11226,8 +11206,7 @@ qemuDomainMigratePerform3Params(virDomainPtr dom,
         nmigrate_disks > 0) {
         if (uri && STRPREFIX(uri, "unix:") && !nbdURI) {
             virReportError(VIR_ERR_INVALID_ARG, "%s",
-                           _("NBD URI must be supplied when "
-                             "migration URI uses UNIX transport method"));
+                           _("NBD URI must be supplied when migration URI uses UNIX transport method"));
             return -1;
         }
     }
@@ -11991,8 +11970,7 @@ qemuDomainGetJobStatsInternal(virDomainObj *vm,
 
     if (vm->job->asyncJob == VIR_ASYNC_JOB_MIGRATION_IN) {
         virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-               _("migration statistics are available only on "
-                 "the source host"));
+               _("migration statistics are available only on the source host"));
         return -1;
     }
 
@@ -12192,14 +12170,12 @@ qemuDomainAbortJobFlags(virDomainPtr dom,
 
     case VIR_ASYNC_JOB_MIGRATION_IN:
         virReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                       _("cannot abort incoming migration;"
-                         " use virDomainDestroy instead"));
+                       _("cannot abort incoming migration; use virDomainDestroy instead"));
         break;
 
     case VIR_ASYNC_JOB_START:
         virReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                       _("cannot abort VM start;"
-                         " use virDomainDestroy instead"));
+                       _("cannot abort VM start; use virDomainDestroy instead"));
         break;
 
     case VIR_ASYNC_JOB_MIGRATION_OUT:
@@ -12337,8 +12313,7 @@ qemuDomainMigrateGetMaxDowntime(virDomainPtr dom,
 
     if (rc == 1) {
         virReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                       _("Querying migration downtime is not supported by "
-                         "QEMU binary"));
+                       _("Querying migration downtime is not supported by QEMU binary"));
         goto endjob;
     }
 
@@ -12378,8 +12353,7 @@ qemuDomainMigrateGetCompressionCache(virDomainPtr dom,
 
     if (!qemuMigrationCapsGet(vm, QEMU_MIGRATION_CAP_XBZRLE)) {
         virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                       _("Compressed migration is not supported by "
-                         "QEMU binary"));
+                       _("Compressed migration is not supported by QEMU binary"));
         goto endjob;
     }
 
@@ -12427,8 +12401,7 @@ qemuDomainMigrateSetCompressionCache(virDomainPtr dom,
 
     if (!qemuMigrationCapsGet(vm, QEMU_MIGRATION_CAP_XBZRLE)) {
         virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                       _("Compressed migration is not supported by "
-                         "QEMU binary"));
+                       _("Compressed migration is not supported by QEMU binary"));
         goto endjob;
     }
 
@@ -12559,8 +12532,7 @@ qemuDomainMigrationGetPostcopyBandwidth(virDomainObj *vm,
 
     if (rc == 1) {
         virReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                       _("querying maximum post-copy migration speed is "
-                         "not supported by QEMU binary"));
+                       _("querying maximum post-copy migration speed is not supported by QEMU binary"));
         goto cleanup;
     }
 
@@ -12644,15 +12616,13 @@ qemuDomainMigrateStartPostCopy(virDomainPtr dom,
 
     if (vm->job->asyncJob != VIR_ASYNC_JOB_MIGRATION_OUT) {
         virReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                       _("post-copy can only be started while "
-                         "outgoing migration is in progress"));
+                       _("post-copy can only be started while outgoing migration is in progress"));
         goto endjob;
     }
 
     if (!(vm->job->apiFlags & VIR_MIGRATE_POSTCOPY)) {
         virReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                       _("switching to post-copy requires migration to be "
-                         "started with VIR_MIGRATE_POSTCOPY flag"));
+                       _("switching to post-copy requires migration to be started with VIR_MIGRATE_POSTCOPY flag"));
         goto endjob;
     }
 
@@ -13584,8 +13554,7 @@ qemuDomainBlockPullCommon(virDomainObj *vm,
 
     if (flags & VIR_DOMAIN_BLOCK_REBASE_RELATIVE && !base) {
         virReportError(VIR_ERR_INVALID_ARG, "%s",
-                       _("flag VIR_DOMAIN_BLOCK_REBASE_RELATIVE is valid only "
-                         "with non-null base"));
+                       _("flag VIR_DOMAIN_BLOCK_REBASE_RELATIVE is valid only with non-null base"));
         goto cleanup;
     }
 
@@ -13972,8 +13941,7 @@ qemuDomainBlockCopyValidateMirror(virStorageSource *mirror,
     if (virStorageSourceAccess(mirror, F_OK) < 0) {
         if (errno != ENOENT) {
             virReportSystemError(errno, "%s",
-                                 _("unable to verify existence of "
-                                   "block copy target"));
+                                 _("unable to verify existence of block copy target"));
             return -1;
         }
 
@@ -14211,8 +14179,7 @@ qemuDomainBlockCopyCommon(virDomainObj *vm,
     if (disk->src->shared && !disk->src->readonly &&
         !qemuBlockStorageSourceSupportsConcurrentAccess(mirror)) {
         virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                       _("can't pivot a shared disk to a storage volume not "
-                         "supporting sharing"));
+                       _("can't pivot a shared disk to a storage volume not supporting sharing"));
         goto endjob;
     }
 
@@ -14919,8 +14886,7 @@ qemuDomainCheckBlockIoTuneReset(virDomainDiskDef *disk,
     if (newiotune->group_name &&
         STRNEQ_NULLABLE(newiotune->group_name, disk->blkdeviotune.group_name)) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("creating a new group/updating existing with all"
-                         " tune parameters zero is not supported"));
+                       _("creating a new group/updating existing with all tune parameters zero is not supported"));
         return -1;
     }
 
@@ -15099,32 +15065,28 @@ qemuDomainSetBlockIoTune(virDomainPtr dom,
     if ((info.total_bytes_sec && info.read_bytes_sec) ||
         (info.total_bytes_sec && info.write_bytes_sec)) {
         virReportError(VIR_ERR_INVALID_ARG, "%s",
-                       _("total and read/write of bytes_sec "
-                         "cannot be set at the same time"));
+                       _("total and read/write of bytes_sec cannot be set at the same time"));
         goto endjob;
     }
 
     if ((info.total_iops_sec && info.read_iops_sec) ||
         (info.total_iops_sec && info.write_iops_sec)) {
         virReportError(VIR_ERR_INVALID_ARG, "%s",
-                       _("total and read/write of iops_sec "
-                         "cannot be set at the same time"));
+                       _("total and read/write of iops_sec cannot be set at the same time"));
         goto endjob;
     }
 
     if ((info.total_bytes_sec_max && info.read_bytes_sec_max) ||
         (info.total_bytes_sec_max && info.write_bytes_sec_max)) {
         virReportError(VIR_ERR_INVALID_ARG, "%s",
-                       _("total and read/write of bytes_sec_max "
-                         "cannot be set at the same time"));
+                       _("total and read/write of bytes_sec_max cannot be set at the same time"));
         goto endjob;
     }
 
     if ((info.total_iops_sec_max && info.read_iops_sec_max) ||
         (info.total_iops_sec_max && info.write_iops_sec_max)) {
         virReportError(VIR_ERR_INVALID_ARG, "%s",
-                       _("total and read/write of iops_sec_max "
-                         "cannot be set at the same time"));
+                       _("total and read/write of iops_sec_max cannot be set at the same time"));
         goto endjob;
     }
 
@@ -15916,8 +15878,7 @@ qemuDomainFSTrim(virDomainPtr dom,
 
     if (mountPoint) {
         virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s",
-                       _("Specifying mount point "
-                         "is not supported for now"));
+                       _("Specifying mount point is not supported for now"));
         return -1;
     }
 
@@ -16322,8 +16283,7 @@ qemuDomainSetTime(virDomainPtr dom,
         !virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_RTC_RESET_REINJECTION))
     {
         virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                       _("cannot set time: qemu doesn't support "
-                         "rtc-reset-reinjection command"));
+                       _("cannot set time: qemu doesn't support rtc-reset-reinjection command"));
         goto cleanup;
     }
 
diff --git a/src/qemu/qemu_hostdev.c b/src/qemu/qemu_hostdev.c
index f329442f8c..4992c23ee0 100644
--- a/src/qemu/qemu_hostdev.c
+++ b/src/qemu/qemu_hostdev.c
@@ -245,8 +245,7 @@ qemuHostdevPrepareMediatedDevices(virQEMUDriver *driver,
         if (virHostdevIsMdevDevice(hostdevs[i])) {
             if (!supportsVFIO) {
                 virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                               _("Mediated host device assignment requires "
-                                 "VFIO support"));
+                               _("Mediated host device assignment requires VFIO support"));
                 return -1;
             }
             break;
diff --git a/src/qemu/qemu_hotplug.c b/src/qemu/qemu_hotplug.c
index d7d1db8ecc..5a25f81d7a 100644
--- a/src/qemu/qemu_hotplug.c
+++ b/src/qemu/qemu_hotplug.c
@@ -6363,8 +6363,7 @@ qemuDomainHotplugDelVcpu(virQEMUDriver *driver,
     if ((rc = qemuDomainWaitForDeviceRemoval(vm)) <= 0) {
         if (rc == 0)
             virReportError(VIR_ERR_OPERATION_TIMEOUT, "%s",
-                           _("vcpu unplug request timed out. Unplug result "
-                             "must be manually inspected in the domain"));
+                           _("vcpu unplug request timed out. Unplug result must be manually inspected in the domain"));
 
         goto cleanup;
     }
@@ -6502,8 +6501,7 @@ qemuDomainSelectHotplugVcpuEntities(virDomainDef *def,
 
             if (curvcpus > nvcpus) {
                 virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                               _("target vm vcpu granularity does not allow the "
-                                 "desired vcpu count"));
+                               _("target vm vcpu granularity does not allow the desired vcpu count"));
                 return NULL;
             }
 
@@ -6529,8 +6527,7 @@ qemuDomainSelectHotplugVcpuEntities(virDomainDef *def,
 
             if (curvcpus < nvcpus) {
                 virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                               _("target vm vcpu granularity does not allow the "
-                                 "desired vcpu count"));
+                               _("target vm vcpu granularity does not allow the desired vcpu count"));
                 return NULL;
             }
 
@@ -6540,8 +6537,7 @@ qemuDomainSelectHotplugVcpuEntities(virDomainDef *def,
 
     if (curvcpus != nvcpus) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("failed to find appropriate hotpluggable vcpus to "
-                         "reach the desired target vcpu count"));
+                       _("failed to find appropriate hotpluggable vcpus to reach the desired target vcpu count"));
         return NULL;
     }
 
@@ -6848,8 +6844,7 @@ qemuDomainSetVcpuInternal(virQEMUDriver *driver,
     if (def) {
         if (!qemuDomainSupportsNewVcpuHotplug(vm)) {
             virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                           _("this qemu version does not support specific "
-                             "vCPU hotplug"));
+                           _("this qemu version does not support specific vCPU hotplug"));
             return -1;
         }
 
@@ -6935,8 +6930,7 @@ qemuDomainChangeDiskLive(virDomainObj *vm,
         if (disk->device != VIR_DOMAIN_DISK_DEVICE_CDROM &&
             disk->device != VIR_DOMAIN_DISK_DEVICE_FLOPPY) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("disk source can be changed only in removable "
-                             "drives"));
+                           _("disk source can be changed only in removable drives"));
             return -1;
         }
 
diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c
index 9b490a130d..b209e18dff 100644
--- a/src/qemu/qemu_migration.c
+++ b/src/qemu/qemu_migration.c
@@ -476,8 +476,7 @@ qemuMigrationDstPrecreateStorage(virDomainObj *vm,
 
         if (incremental) {
             virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                           _("pre-creation of storage targets for incremental "
-                             "storage migration is not supported"));
+                           _("pre-creation of storage targets for incremental storage migration is not supported"));
             goto cleanup;
         }
 
@@ -1479,8 +1478,7 @@ qemuMigrationSrcIsAllowed(virDomainObj *vm,
 
                 if (block) {
                     virReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                                   _("domain has 'invtsc' CPU feature but "
-                                     "TSC frequency is not specified"));
+                                   _("domain has 'invtsc' CPU feature but TSC frequency is not specified"));
                     return false;
                 }
             }
@@ -1493,8 +1491,7 @@ qemuMigrationSrcIsAllowed(virDomainObj *vm,
             if (mem->model == VIR_DOMAIN_MEMORY_MODEL_DIMM &&
                 mem->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DIMM) {
                 virReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                               _("domain's dimm info lacks slot ID "
-                                 "or base address"));
+                               _("domain's dimm info lacks slot ID or base address"));
 
                 return false;
             }
@@ -1648,8 +1645,7 @@ qemuMigrationSrcIsSafe(virDomainDef *def,
         }
 
         virReportError(VIR_ERR_MIGRATE_UNSAFE, "%s",
-                       _("Migration may lead to data corruption if disks"
-                         " use cache other than none or directsync"));
+                       _("Migration may lead to data corruption if disks use cache other than none or directsync"));
         return false;
     }
 
@@ -2205,8 +2201,7 @@ qemuMigrationDstCheckProtocol(virQEMUCaps *qemuCaps,
     if (STRPREFIX(migrateFrom, "rdma")) {
         if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_RDMA)) {
             virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                           _("incoming RDMA migration is not supported "
-                             "with this QEMU binary"));
+                           _("incoming RDMA migration is not supported with this QEMU binary"));
             return -1;
         }
     } else if (!STRPREFIX(migrateFrom, "tcp") &&
@@ -2572,8 +2567,7 @@ qemuMigrationSrcBeginPhase(virQEMUDriver *driver,
         (!(flags & VIR_MIGRATE_LIVE) ||
          flags & VIR_MIGRATE_PAUSED)) {
         virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s",
-                       _("post-copy migration is not supported with non-live "
-                         "or paused migration"));
+                       _("post-copy migration is not supported with non-live or paused migration"));
         return NULL;
     }
 
@@ -3733,8 +3727,7 @@ qemuMigrationDstPrepareDirect(virQEMUDriver *driver,
 
         if (STRPREFIX(hostname, "localhost")) {
             virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                           _("hostname on destination resolved to localhost,"
-                             " but migration requires an FQDN"));
+                           _("hostname on destination resolved to localhost, but migration requires an FQDN"));
             goto cleanup;
         }
 
@@ -4600,8 +4593,7 @@ qemuMigrationSrcStart(virDomainObj *vm,
         if (spec->fwdType != MIGRATION_FWD_DIRECT) {
             if (!tunnelFd) {
                 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                               _("tunnelFD argument is required for tunnelled "
-                                 "migration"));
+                               _("tunnelFD argument is required for tunnelled migration"));
                 VIR_FORCE_CLOSE(spec->dest.fd.local);
                 VIR_FORCE_CLOSE(spec->dest.fd.qemu);
                 return -1;
@@ -5149,14 +5141,12 @@ qemuMigrationSrcPerformNative(virQEMUDriver *driver,
     if (STREQ(uribits->scheme, "rdma")) {
         if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATE_RDMA)) {
             virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                           _("outgoing RDMA migration is not supported "
-                             "with this QEMU binary"));
+                           _("outgoing RDMA migration is not supported with this QEMU binary"));
             return -1;
         }
         if (!virMemoryLimitIsSet(vm->def->mem.hard_limit)) {
             virReportError(VIR_ERR_OPERATION_INVALID, "%s",
-                           _("cannot start RDMA migration with no memory hard "
-                             "limit set"));
+                           _("cannot start RDMA migration with no memory hard limit set"));
             return -1;
         }
     }
@@ -5166,8 +5156,7 @@ qemuMigrationSrcPerformNative(virQEMUDriver *driver,
             !(flags & VIR_MIGRATE_POSTCOPY_RESUME) &&
             !qemuMigrationParamsTLSHostnameIsSet(migParams)) {
             virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                           _("Explicit destination hostname is required "
-                             "for TLS migration over UNIX socket"));
+                           _("Explicit destination hostname is required for TLS migration over UNIX socket"));
             return -1;
         }
 
@@ -5878,22 +5867,19 @@ qemuMigrationSrcPerformPeer2Peer(virQEMUDriver *driver,
 
     if (flags & VIR_MIGRATE_TUNNELLED && uri) {
         virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s",
-                       _("migration URI is not supported by tunnelled "
-                         "migration"));
+                       _("migration URI is not supported by tunnelled migration"));
         goto cleanup;
     }
 
     if (flags & VIR_MIGRATE_TUNNELLED && listenAddress) {
         virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s",
-                       _("listen address is not supported by tunnelled "
-                         "migration"));
+                       _("listen address is not supported by tunnelled migration"));
         goto cleanup;
     }
 
     if (flags & VIR_MIGRATE_TUNNELLED && nbdPort) {
         virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s",
-                       _("disk port address is not supported by tunnelled "
-                         "migration"));
+                       _("disk port address is not supported by tunnelled migration"));
         goto cleanup;
     }
 
@@ -5956,15 +5942,13 @@ qemuMigrationSrcPerformPeer2Peer(virQEMUDriver *driver,
      * old-style APIs. */
     if (!useParams && (graphicsuri || listenAddress || nmigrate_disks)) {
         virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s",
-                       _("Migration APIs with extensible parameters are not "
-                         "supported but extended parameters were passed"));
+                       _("Migration APIs with extensible parameters are not supported but extended parameters were passed"));
         goto cleanup;
     }
 
     if (offline && !dstOffline) {
         virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s",
-                       _("offline migration is not supported by "
-                         "the destination host"));
+                       _("offline migration is not supported by the destination host"));
         goto cleanup;
     }
 
diff --git a/src/qemu/qemu_migration_params.c b/src/qemu/qemu_migration_params.c
index 807cccd86e..79fe6e97c8 100644
--- a/src/qemu/qemu_migration_params.c
+++ b/src/qemu/qemu_migration_params.c
@@ -1006,8 +1006,7 @@ qemuMigrationParamsApply(virDomainObj *vm,
         if (asyncJob == VIR_ASYNC_JOB_NONE) {
             if (!virBitmapIsAllClear(migParams->caps)) {
                 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                               _("Migration capabilities can only be set by "
-                                 "a migration job"));
+                               _("Migration capabilities can only be set by a migration job"));
                 goto cleanup;
             }
         } else if (qemuMigrationParamsApplyCaps(vm, migParams->caps) < 0) {
@@ -1091,8 +1090,7 @@ qemuMigrationParamsEnableTLS(virQEMUDriver *driver,
 
     if (!jobPriv->migParams->params[QEMU_MIGRATION_PARAM_TLS_CREDS].set) {
         virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                       _("TLS migration is not supported with this "
-                         "QEMU binary"));
+                       _("TLS migration is not supported with this QEMU binary"));
         return -1;
     }
 
diff --git a/src/qemu/qemu_monitor.c b/src/qemu/qemu_monitor.c
index 02da1d6dfc..7053539c7d 100644
--- a/src/qemu/qemu_monitor.c
+++ b/src/qemu/qemu_monitor.c
@@ -976,8 +976,7 @@ qemuMonitorInitBalloonObjectPath(qemuMonitor *mon,
 
     /* If we get here, we found the path, but not the property */
     virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                   _("Property 'guest-stats-polling-interval' "
-                     "not found on memory balloon driver."));
+                   _("Property 'guest-stats-polling-interval' not found on memory balloon driver."));
 
  cleanup:
     for (i = 0; i < nprops; i++)
diff --git a/src/qemu/qemu_monitor_json.c b/src/qemu/qemu_monitor_json.c
index 34c4b543e8..5b9edadcf7 100644
--- a/src/qemu/qemu_monitor_json.c
+++ b/src/qemu/qemu_monitor_json.c
@@ -2253,8 +2253,7 @@ qemuMonitorJSONBlockStatsCollectData(virJSONValue *dev,
 
     if ((stats = virJSONValueObjectGetObject(dev, "stats")) == NULL) {
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                       _("blockstats stats entry was not "
-                         "in expected format"));
+                       _("blockstats stats entry was not in expected format"));
         return NULL;
     }
 
@@ -2425,8 +2424,7 @@ qemuMonitorJSONGetAllBlockStatsInfo(qemuMonitor *mon,
 
         if (!dev || virJSONValueGetType(dev) != VIR_JSON_TYPE_OBJECT) {
             virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                           _("blockstats device entry was not "
-                             "in expected format"));
+                           _("blockstats device entry was not in expected format"));
             return -1;
         }
 
@@ -3025,8 +3023,7 @@ qemuMonitorJSONGetMigrationStatsReply(virJSONValue *reply,
                                                   &stats->disk_transferred);
             if (rc < 0) {
                 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                               _("disk migration was active, but "
-                                 "'transferred' data was missing"));
+                               _("disk migration was active, but 'transferred' data was missing"));
                 return -1;
             }
 
@@ -3034,8 +3031,7 @@ qemuMonitorJSONGetMigrationStatsReply(virJSONValue *reply,
                                                   &stats->disk_remaining);
             if (rc < 0) {
                 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                               _("disk migration was active, but 'remaining' "
-                                 "data was missing"));
+                               _("disk migration was active, but 'remaining' data was missing"));
                 return -1;
             }
 
@@ -3043,8 +3039,7 @@ qemuMonitorJSONGetMigrationStatsReply(virJSONValue *reply,
                                                   &stats->disk_total);
             if (rc < 0) {
                 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                               _("disk migration was active, but 'total' "
-                                 "data was missing"));
+                               _("disk migration was active, but 'total' data was missing"));
                 return -1;
             }
 
@@ -3062,8 +3057,7 @@ qemuMonitorJSONGetMigrationStatsReply(virJSONValue *reply,
                                                   &stats->xbzrle_cache_size);
             if (rc < 0) {
                 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                               _("XBZRLE is active, but 'cache-size' data "
-                                 "was missing"));
+                               _("XBZRLE is active, but 'cache-size' data was missing"));
                 return -1;
             }
 
@@ -3071,8 +3065,7 @@ qemuMonitorJSONGetMigrationStatsReply(virJSONValue *reply,
                                                   &stats->xbzrle_bytes);
             if (rc < 0) {
                 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                               _("XBZRLE is active, but 'bytes' data "
-                                 "was missing"));
+                               _("XBZRLE is active, but 'bytes' data was missing"));
                 return -1;
             }
 
@@ -3080,8 +3073,7 @@ qemuMonitorJSONGetMigrationStatsReply(virJSONValue *reply,
                                                   &stats->xbzrle_pages);
             if (rc < 0) {
                 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                               _("XBZRLE is active, but 'pages' data "
-                                 "was missing"));
+                               _("XBZRLE is active, but 'pages' data was missing"));
                 return -1;
             }
 
@@ -3089,8 +3081,7 @@ qemuMonitorJSONGetMigrationStatsReply(virJSONValue *reply,
                                                   &stats->xbzrle_cache_miss);
             if (rc < 0) {
                 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                               _("XBZRLE is active, but 'cache-miss' data "
-                                 "was missing"));
+                               _("XBZRLE is active, but 'cache-miss' data was missing"));
                 return -1;
             }
 
@@ -3098,8 +3089,7 @@ qemuMonitorJSONGetMigrationStatsReply(virJSONValue *reply,
                                                   &stats->xbzrle_overflow);
             if (rc < 0) {
                 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                               _("XBZRLE is active, but 'overflow' data "
-                                 "was missing"));
+                               _("XBZRLE is active, but 'overflow' data was missing"));
                 return -1;
             }
         }
@@ -3619,30 +3609,26 @@ qemuMonitorJSONQueryRxFilterParse(virJSONValue *msg,
 
     if (!(tmp = virJSONValueObjectGetString(entry, "name"))) {
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                       _("Missing or invalid name "
-                         "in query-rx-filter response"));
+                       _("Missing or invalid name in query-rx-filter response"));
         return -1;
     }
     fil->name = g_strdup(tmp);
     if ((!(tmp = virJSONValueObjectGetString(entry, "main-mac"))) ||
         virMacAddrParse(tmp, &fil->mac) < 0) {
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                       _("Missing or invalid 'main-mac' "
-                         "in query-rx-filter response"));
+                       _("Missing or invalid 'main-mac' in query-rx-filter response"));
         return -1;
     }
     if (virJSONValueObjectGetBoolean(entry, "promiscuous",
                                      &fil->promiscuous) < 0) {
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                       _("Missing or invalid 'promiscuous' "
-                         "in query-rx-filter response"));
+                       _("Missing or invalid 'promiscuous' in query-rx-filter response"));
         return -1;
     }
     if (virJSONValueObjectGetBoolean(entry, "broadcast-allowed",
                                      &fil->broadcastAllowed) < 0) {
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                       _("Missing or invalid 'broadcast-allowed' "
-                         "in query-rx-filter response"));
+                       _("Missing or invalid 'broadcast-allowed' in query-rx-filter response"));
         return -1;
     }
 
@@ -3650,15 +3636,13 @@ qemuMonitorJSONQueryRxFilterParse(virJSONValue *msg,
         ((fil->unicast.mode
           = virNetDevRxFilterModeTypeFromString(tmp)) < 0)) {
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                       _("Missing or invalid 'unicast' "
-                         "in query-rx-filter response"));
+                       _("Missing or invalid 'unicast' in query-rx-filter response"));
         return -1;
     }
     if (virJSONValueObjectGetBoolean(entry, "unicast-overflow",
                                      &fil->unicast.overflow) < 0) {
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                       _("Missing or invalid 'unicast-overflow' "
-                         "in query-rx-filter response"));
+                       _("Missing or invalid 'unicast-overflow' in query-rx-filter response"));
         return -1;
     }
     if ((!(table = virJSONValueObjectGetArray(entry, "unicast-table")))) {
@@ -3689,15 +3673,13 @@ qemuMonitorJSONQueryRxFilterParse(virJSONValue *msg,
         ((fil->multicast.mode
           = virNetDevRxFilterModeTypeFromString(tmp)) < 0)) {
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                       _("Missing or invalid 'multicast' "
-                         "in query-rx-filter response"));
+                       _("Missing or invalid 'multicast' in query-rx-filter response"));
         return -1;
     }
     if (virJSONValueObjectGetBoolean(entry, "multicast-overflow",
                                      &fil->multicast.overflow) < 0) {
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                       _("Missing or invalid 'multicast-overflow' "
-                         "in query-rx-filter response"));
+                       _("Missing or invalid 'multicast-overflow' in query-rx-filter response"));
         return -1;
     }
     if ((!(table = virJSONValueObjectGetArray(entry, "multicast-table")))) {
@@ -3728,8 +3710,7 @@ qemuMonitorJSONQueryRxFilterParse(virJSONValue *msg,
         ((fil->vlan.mode
           = virNetDevRxFilterModeTypeFromString(tmp)) < 0)) {
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                       _("Missing or invalid 'vlan' "
-                         "in query-rx-filter response"));
+                       _("Missing or invalid 'vlan' in query-rx-filter response"));
         return -1;
     }
     if ((!(table = virJSONValueObjectGetArray(entry, "vlan-table")))) {
@@ -4528,8 +4509,7 @@ qemuMonitorJSONBlockIoThrottleInfo(virJSONValue *io_throttle,
 
         if (!temp_dev || virJSONValueGetType(temp_dev) != VIR_JSON_TYPE_OBJECT) {
             virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                           _("block_io_throttle device entry "
-                             "was not in expected format"));
+                           _("block_io_throttle device entry was not in expected format"));
             return -1;
         }
 
@@ -4538,8 +4518,7 @@ qemuMonitorJSONBlockIoThrottleInfo(virJSONValue *io_throttle,
 
         if (!current_drive && !current_qdev) {
             virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                           _("block_io_throttle device entry "
-                             "was not in expected format"));
+                           _("block_io_throttle device entry was not in expected format"));
             return -1;
         }
 
@@ -4550,8 +4529,7 @@ qemuMonitorJSONBlockIoThrottleInfo(virJSONValue *io_throttle,
         found = true;
         if (!(inserted = virJSONValueObjectGetObject(temp_dev, "inserted"))) {
             virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                           _("block_io_throttle inserted entry "
-                             "was not in expected format"));
+                           _("block_io_throttle inserted entry was not in expected format"));
             return -1;
         }
         GET_THROTTLE_STATS("bps", total_bytes_sec);
@@ -4795,8 +4773,7 @@ int qemuMonitorJSONGetMachines(qemuMonitor *mon,
         if (virJSONValueObjectHasKey(child, "default-cpu-type")) {
             if (!(tmp = virJSONValueObjectGetString(child, "default-cpu-type"))) {
                 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                               _("query-machines reply has malformed "
-                                 "'default-cpu-type' data"));
+                               _("query-machines reply has malformed 'default-cpu-type' data"));
                 goto cleanup;
             }
 
@@ -4806,8 +4783,7 @@ int qemuMonitorJSONGetMachines(qemuMonitor *mon,
         if (virJSONValueObjectHasKey(child, "numa-mem-supported")) {
             if (virJSONValueObjectGetBoolean(child, "numa-mem-supported", &info->numaMemSupported) < 0) {
                 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                               _("query-machines reply has malformed "
-                                 "'numa-mem-supported' data"));
+                               _("query-machines reply has malformed 'numa-mem-supported' data"));
                 goto cleanup;
             }
         } else {
@@ -4817,8 +4793,7 @@ int qemuMonitorJSONGetMachines(qemuMonitor *mon,
         if (virJSONValueObjectHasKey(child, "default-ram-id")) {
             if (!(tmp = virJSONValueObjectGetString(child, "default-ram-id"))) {
                 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                               _("query-machines reply has malformed "
-                                 "'default-ram-id' data"));
+                               _("query-machines reply has malformed 'default-ram-id' data"));
                 goto cleanup;
             }
 
@@ -5243,8 +5218,7 @@ qemuMonitorJSONGetCPUModelComparison(qemuMonitor *mon,
 
     if (!(data_result = virJSONValueObjectGetString(data, "result"))) {
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                       _("query-cpu-model-comparison reply data was missing "
-                         "'result'"));
+                       _("query-cpu-model-comparison reply data was missing 'result'"));
         return -1;
     }
 
@@ -5983,30 +5957,26 @@ qemuMonitorJSONGetSEVCapabilities(qemuMonitor *mon,
 
     if (virJSONValueObjectGetNumberUint(caps, "cbitpos", &cbitpos) < 0) {
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                       _("query-sev-capabilities reply was missing"
-                         " 'cbitpos' field"));
+                       _("query-sev-capabilities reply was missing 'cbitpos' field"));
         return -1;
     }
 
     if (virJSONValueObjectGetNumberUint(caps, "reduced-phys-bits",
                                         &reduced_phys_bits) < 0) {
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                       _("query-sev-capabilities reply was missing"
-                         " 'reduced-phys-bits' field"));
+                       _("query-sev-capabilities reply was missing 'reduced-phys-bits' field"));
         return -1;
     }
 
     if (!(pdh = virJSONValueObjectGetString(caps, "pdh"))) {
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                       _("query-sev-capabilities reply was missing"
-                         " 'pdh' field"));
+                       _("query-sev-capabilities reply was missing 'pdh' field"));
         return -1;
     }
 
     if (!(cert_chain = virJSONValueObjectGetString(caps, "cert-chain"))) {
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                       _("query-sev-capabilities reply was missing"
-                         " 'cert-chain' field"));
+                       _("query-sev-capabilities reply was missing 'cert-chain' field"));
         return -1;
     }
 
@@ -7072,8 +7042,7 @@ qemuMonitorJSONGetIOThreads(qemuMonitor *mon,
         if (virJSONValueObjectGetNumberInt(child, "thread-id",
                                            &info->thread_id) < 0) {
             virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                           _("query-iothreads reply has malformed "
-                             "'thread-id' data"));
+                           _("query-iothreads reply has malformed 'thread-id' data"));
             goto cleanup;
         }
 
@@ -7194,8 +7163,7 @@ qemuMonitorJSONGetMemoryDeviceInfo(qemuMonitor *mon,
 
         if (!(modelStr = virJSONValueObjectGetString(elem, "type"))) {
             virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                           _("query-memory-devices reply data doesn't contain "
-                             "enum type discriminator"));
+                           _("query-memory-devices reply data doesn't contain enum type discriminator"));
             return -1;
         }
 
@@ -7206,8 +7174,7 @@ qemuMonitorJSONGetMemoryDeviceInfo(qemuMonitor *mon,
 
         if (!(dimminfo = virJSONValueObjectGetObject(elem, "data"))) {
             virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                           _("query-memory-devices reply data doesn't "
-                             "contain enum data"));
+                           _("query-memory-devices reply data doesn't contain enum data"));
             return -1;
         }
 
@@ -7622,8 +7589,7 @@ qemuMonitorJSONProcessHotpluggableCpusReply(virJSONValue *vcpu,
     if (entry->node_id == -1 && entry->socket_id == -1 &&
         entry->core_id == -1 && entry->thread_id == -1) {
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                       _("query-hotpluggable-cpus entry doesn't report "
-                         "topology information"));
+                       _("query-hotpluggable-cpus entry doesn't report topology information"));
         return -1;
     }
 
diff --git a/src/qemu/qemu_process.c b/src/qemu/qemu_process.c
index a6ed69cfe2..b0eb44e0b9 100644
--- a/src/qemu/qemu_process.c
+++ b/src/qemu/qemu_process.c
@@ -4237,8 +4237,7 @@ qemuProcessSPICEAllocatePorts(virQEMUDriver *driver,
     if (needTLSPort || graphics->data.spice.tlsPort == -1) {
         if (!cfg->spiceTLS) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("Auto allocation of spice TLS port requested "
-                             "but spice TLS is disabled in qemu.conf"));
+                           _("Auto allocation of spice TLS port requested but spice TLS is disabled in qemu.conf"));
             return -1;
         }
 
@@ -5003,8 +5002,7 @@ qemuProcessGraphicsSetupNetworkAddress(virDomainGraphicsListenDef *glisten,
     rc = qemuProcessGetNetworkAddress(glisten->network, &glisten->address);
     if (rc <= -2) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("network-based listen isn't possible, "
-                         "network driver isn't present"));
+                       _("network-based listen isn't possible, network driver isn't present"));
         return -1;
     }
     if (rc < 0)
@@ -5355,8 +5353,7 @@ qemuProcessStartValidateGraphics(virDomainObj *vm)
         case VIR_DOMAIN_GRAPHICS_TYPE_SPICE:
             if (graphics->nListens > 1) {
                 virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                               _("QEMU does not support multiple listens for "
-                                 "one graphics device."));
+                               _("QEMU does not support multiple listens for one graphics device."));
                 return -1;
             }
             break;
@@ -5412,8 +5409,7 @@ qemuProcessStartValidateDisks(virDomainObj *vm,
             src->protocol == VIR_STORAGE_NET_PROTOCOL_VXHS &&
             !virQEMUCapsGet(qemuCaps, QEMU_CAPS_VXHS)) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("VxHS protocol is not supported with this "
-                             "QEMU binary"));
+                           _("VxHS protocol is not supported with this QEMU binary"));
             return -1;
         }
 
@@ -5527,10 +5523,7 @@ qemuProcessStartValidate(virQEMUDriver *driver,
             VIR_DEBUG("Checking for KVM availability");
             if (!virFileExists("/dev/kvm")) {
                 virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                               _("Domain requires KVM, but it is not available. "
-                                 "Check that virtualization is enabled in the "
-                                 "host BIOS, and host configuration is setup to "
-                                 "load the kvm modules."));
+                               _("Domain requires KVM, but it is not available. Check that virtualization is enabled in the host BIOS, and host configuration is setup to load the kvm modules."));
                 return -1;
             }
         }
@@ -9149,8 +9142,7 @@ qemuProcessReconnectHelper(virDomainObj *obj,
     if (virThreadCreateFull(&thread, false, qemuProcessReconnect,
                             name, false, data) < 0) {
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
-                       _("Could not create thread. QEMU initialization "
-                         "might be incomplete"));
+                       _("Could not create thread. QEMU initialization might be incomplete"));
         /* We can't spawn a thread and thus connect to monitor. Kill qemu.
          * It's safe to call qemuProcessStop without a job here since there
          * is no thread that could be doing anything else with the same domain
diff --git a/src/qemu/qemu_snapshot.c b/src/qemu/qemu_snapshot.c
index d943281e35..ec853686d3 100644
--- a/src/qemu/qemu_snapshot.c
+++ b/src/qemu/qemu_snapshot.c
@@ -490,8 +490,7 @@ qemuSnapshotPrepareDiskExternalActive(virDomainSnapshotDiskDef *snapdisk,
 
     if (domdisk->device == VIR_DOMAIN_DISK_DEVICE_LUN) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("external active snapshots are not supported on scsi "
-                         "passthrough devices"));
+                       _("external active snapshots are not supported on scsi passthrough devices"));
         return -1;
     }
 
@@ -766,16 +765,14 @@ qemuSnapshotPrepare(virDomainObj *vm,
     if ((def->memory == VIR_DOMAIN_SNAPSHOT_LOCATION_INTERNAL && !found_internal) ||
         (found_internal && forbid_internal)) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("internal and full system snapshots require all "
-                         "disks to be selected for snapshot"));
+                       _("internal and full system snapshots require all disks to be selected for snapshot"));
         return -1;
     }
 
     /* disk snapshot requires at least one disk */
     if (def->state == VIR_DOMAIN_SNAPSHOT_DISK_SNAPSHOT && !external) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("disk-only snapshots require at least "
-                         "one disk to be selected for snapshot"));
+                       _("disk-only snapshots require at least one disk to be selected for snapshot"));
         return -1;
     }
 
@@ -786,8 +783,7 @@ qemuSnapshotPrepare(virDomainObj *vm,
          (def->memory == VIR_DOMAIN_SNAPSHOT_LOCATION_INTERNAL && external) ||
          (def->memory == VIR_DOMAIN_SNAPSHOT_LOCATION_EXTERNAL && found_internal)) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("mixing internal and external targets for a snapshot "
-                         "is not yet supported"));
+                       _("mixing internal and external targets for a snapshot is not yet supported"));
         return -1;
     }
 
@@ -808,8 +804,7 @@ qemuSnapshotPrepare(virDomainObj *vm,
         found_internal &&
         virDomainDefHasOldStyleUEFI(vm->def)) {
         virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                       _("internal snapshots of a VM with pflash based "
-                         "firmware are not supported"));
+                       _("internal snapshots of a VM with pflash based firmware are not supported"));
         return -1;
     }
 
@@ -1534,8 +1529,7 @@ qemuSnapshotCreateXMLValidateDef(virDomainObj *vm,
         (!virDomainObjIsActive(vm) ||
          def->memory != VIR_DOMAIN_SNAPSHOT_LOCATION_EXTERNAL)) {
         virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                       _("live snapshot creation is supported only "
-                         "during full system snapshots"));
+                       _("live snapshot creation is supported only during full system snapshots"));
         return -1;
     }
 
@@ -1560,8 +1554,7 @@ qemuSnapshotCreateXMLValidateDef(virDomainObj *vm,
 
     case VIR_DOMAIN_SNAPSHOT_PMSUSPENDED:
         virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                       _("qemu doesn't support taking snapshots of "
-                         "PMSUSPENDED guests"));
+                       _("qemu doesn't support taking snapshots of PMSUSPENDED guests"));
         return -1;
 
         /* invalid states */
@@ -1621,8 +1614,7 @@ qemuSnapshotCreateAlignDisks(virDomainObj *vm,
         if (virDomainObjIsActive(vm) &&
             def->memory == VIR_DOMAIN_SNAPSHOT_LOCATION_NO) {
             virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                           _("internal snapshot of a running VM "
-                             "must include the memory state"));
+                           _("internal snapshot of a running VM must include the memory state"));
             return -1;
         }
 
@@ -2551,8 +2543,7 @@ qemuSnapshotRevert(virDomainObj *vm,
 
     case VIR_DOMAIN_SNAPSHOT_PMSUSPENDED:
         virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
-                       _("qemu doesn't support reversion of snapshot taken in "
-                         "PMSUSPENDED state"));
+                       _("qemu doesn't support reversion of snapshot taken in PMSUSPENDED state"));
         goto endjob;
 
     case VIR_DOMAIN_SNAPSHOT_DISK_SNAPSHOT:
diff --git a/src/qemu/qemu_tpm.c b/src/qemu/qemu_tpm.c
index 450f96ecfd..bf0c6bcb0d 100644
--- a/src/qemu/qemu_tpm.c
+++ b/src/qemu/qemu_tpm.c
@@ -383,9 +383,7 @@ qemuTPMEmulatorRunSetup(const char *storagepath,
     if (!privileged && tpmversion == VIR_DOMAIN_TPM_VERSION_1_2 &&
         !virTPMSwtpmSetupCapsGet(VIR_TPM_SWTPM_SETUP_FEATURE_TPM12_NOT_NEED_ROOT)) {
         return virFileWriteStr(logfile,
-                               _("Did not create EK and certificates since "
-                                 "this requires privileged mode for a "
-                                 "TPM 1.2\n"), 0600);
+                               _("Did not create EK and certificates since this requires privileged mode for a TPM 1.2\n"), 0600);
     }
 
     if (!privileged && qemuTPMCreateConfigFiles(swtpm_setup) < 0)
diff --git a/src/qemu/qemu_validate.c b/src/qemu/qemu_validate.c
index 797caf6076..8f9e8fd7f0 100644
--- a/src/qemu/qemu_validate.c
+++ b/src/qemu/qemu_validate.c
@@ -139,8 +139,7 @@ qemuValidateDomainDefFeatures(const virDomainDef *def,
                 !virQEMUCapsSupportsVmport(qemuCaps, def)) {
 
                 virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                               _("vmport is not available "
-                                 "with this QEMU binary"));
+                               _("vmport is not available with this QEMU binary"));
                 return -1;
             }
             break;
@@ -149,8 +148,7 @@ qemuValidateDomainDefFeatures(const virDomainDef *def,
             if (def->features[i] == VIR_TRISTATE_SWITCH_ON &&
                 !virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VMCOREINFO)) {
                 virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                              _("vmcoreinfo is not available "
-                                "with this QEMU binary"));
+                              _("vmcoreinfo is not available with this QEMU binary"));
                 return -1;
             }
             break;
@@ -828,8 +826,7 @@ qemuValidateDomainDefMemory(const virDomainDef *def,
 
     if (mem->allocation == VIR_DOMAIN_MEMORY_ALLOCATION_ONDEMAND) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("hugepages are not allowed with memory "
-                         "allocation ondemand"));
+                       _("hugepages are not allowed with memory allocation ondemand"));
         return -1;
     }
 
@@ -842,8 +839,7 @@ qemuValidateDomainDefMemory(const virDomainDef *def,
 
     if (mem->source == VIR_DOMAIN_MEMORY_SOURCE_ANONYMOUS) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("hugepages are not allowed with anonymous "
-                         "memory source"));
+                       _("hugepages are not allowed with anonymous memory source"));
         return -1;
     }
 
@@ -970,15 +966,13 @@ qemuValidateDomainDefPanic(const virDomainDef *def,
              * cannot be configured by the user */
             if (!ARCH_IS_S390(def->os.arch)) {
                 virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                               _("only S390 guests support "
-                                 "panic device of model 's390'"));
+                               _("only S390 guests support panic device of model 's390'"));
                 return -1;
             }
             if (def->panics[i]->info.type !=
                 VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE) {
                 virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                               _("setting the panic device address is not "
-                                 "supported for model 's390'"));
+                               _("setting the panic device address is not supported for model 's390'"));
                 return -1;
             }
             break;
@@ -989,15 +983,13 @@ qemuValidateDomainDefPanic(const virDomainDef *def,
              * cannot be configured by the user */
             if (!ARCH_IS_X86(def->os.arch)) {
                 virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                               _("only i686 and x86_64 guests support "
-                                 "panic device of model 'hyperv'"));
+                               _("only i686 and x86_64 guests support panic device of model 'hyperv'"));
                 return -1;
             }
             if (def->panics[i]->info.type !=
                 VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE) {
                 virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                               _("setting the panic device address is not "
-                                 "supported for model 'hyperv'"));
+                               _("setting the panic device address is not supported for model 'hyperv'"));
                 return -1;
             }
             break;
@@ -1008,15 +1000,13 @@ qemuValidateDomainDefPanic(const virDomainDef *def,
              * cannot be configured by the user */
             if (!qemuDomainIsPSeries(def)) {
                 virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                               _("only pSeries guests support panic device "
-                                 "of model 'pseries'"));
+                               _("only pSeries guests support panic device of model 'pseries'"));
                 return -1;
             }
             if (def->panics[i]->info.type !=
                 VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE) {
                 virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                               _("setting the panic device address is not "
-                                 "supported for model 'pseries'"));
+                               _("setting the panic device address is not supported for model 'pseries'"));
                 return -1;
             }
             break;
@@ -1024,16 +1014,14 @@ qemuValidateDomainDefPanic(const virDomainDef *def,
         case VIR_DOMAIN_PANIC_MODEL_ISA:
             if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_PANIC)) {
                 virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                               _("the QEMU binary does not support the "
-                                 "ISA panic device"));
+                               _("the QEMU binary does not support the ISA panic device"));
                 return -1;
             }
 
             if (def->panics[i]->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE &&
                 def->panics[i]->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_ISA) {
                 virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                               _("panic is supported only "
-                                 "with ISA address type"));
+                               _("panic is supported only with ISA address type"));
                 return -1;
             }
             break;
@@ -1338,8 +1326,7 @@ qemuValidateDomainDef(const virDomainDef *def,
         case VIR_DOMAIN_LAUNCH_SECURITY_SEV:
             if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_SEV_GUEST)) {
                 virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                               _("SEV launch security is not supported with "
-                                 "this QEMU binary"));
+                               _("SEV launch security is not supported with this QEMU binary"));
                 return -1;
             }
 
@@ -1734,8 +1721,7 @@ qemuValidateDomainDeviceDefNetwork(const virDomainNetDef *net,
         }
         if (net->guestIP.nroutes) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("Invalid attempt to set network interface "
-                             "guest-side IP route, not supported by QEMU"));
+                           _("Invalid attempt to set network interface guest-side IP route, not supported by QEMU"));
             return -1;
         }
 
@@ -1751,8 +1737,7 @@ qemuValidateDomainDeviceDefNetwork(const virDomainNetDef *net,
             if (VIR_SOCKET_ADDR_IS_FAMILY(&ip->address, AF_INET)) {
                 if (hasIPv4) {
                     virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                                   _("Only one IPv4 address per "
-                                     "interface is allowed"));
+                                   _("Only one IPv4 address per interface is allowed"));
                     return -1;
                 }
                 hasIPv4 = true;
@@ -1768,8 +1753,7 @@ qemuValidateDomainDeviceDefNetwork(const virDomainNetDef *net,
             if (VIR_SOCKET_ADDR_IS_FAMILY(&ip->address, AF_INET6)) {
                 if (hasIPv6) {
                     virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                                   _("Only one IPv6 address per "
-                                     "interface is allowed"));
+                                   _("Only one IPv6 address per interface is allowed"));
                     return -1;
                 }
                 hasIPv6 = true;
@@ -1804,9 +1788,7 @@ qemuValidateDomainDeviceDefNetwork(const virDomainNetDef *net,
         }
     } else if (net->guestIP.nroutes || net->guestIP.nips) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Invalid attempt to set network interface "
-                         "guest-side IP route and/or address info, "
-                         "not supported by QEMU"));
+                       _("Invalid attempt to set network interface guest-side IP route and/or address info, not supported by QEMU"));
         return -1;
     }
 
@@ -2204,8 +2186,7 @@ qemuValidateDomainRNGDef(const virDomainRNGDef *def,
     case VIR_DOMAIN_RNG_BACKEND_RANDOM:
         if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_OBJECT_RNG_RANDOM)) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("this qemu doesn't support the rng-random "
-                             "backend"));
+                           _("this qemu doesn't support the rng-random backend"));
             return -1;
         }
         break;
@@ -2213,8 +2194,7 @@ qemuValidateDomainRNGDef(const virDomainRNGDef *def,
     case VIR_DOMAIN_RNG_BACKEND_EGD:
         if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_OBJECT_RNG_EGD)) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("this qemu doesn't support the rng-egd "
-                             "backend"));
+                           _("this qemu doesn't support the rng-egd backend"));
             return -1;
         }
 
@@ -2228,8 +2208,7 @@ qemuValidateDomainRNGDef(const virDomainRNGDef *def,
     case VIR_DOMAIN_RNG_BACKEND_BUILTIN:
         if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_OBJECT_RNG_BUILTIN)) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("this qemu doesn't support the rng-builtin "
-                             "backend"));
+                           _("this qemu doesn't support the rng-builtin backend"));
             return -1;
         }
         break;
@@ -2270,16 +2249,14 @@ qemuValidateDomainRedirdevDef(const virDomainRedirdevDef *dev,
 
     if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_USB_REDIR)) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("USB redirection is not supported "
-                         "by this version of QEMU"));
+                       _("USB redirection is not supported by this version of QEMU"));
         return -1;
     }
 
     if (def->redirfilter && def->redirfilter->nusbdevs &&
         !virQEMUCapsGet(qemuCaps, QEMU_CAPS_USB_REDIR_FILTER)) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("USB redirection filter is not "
-                         "supported by this version of QEMU"));
+                       _("USB redirection filter is not supported by this version of QEMU"));
         return -1;
     }
 
@@ -2298,8 +2275,7 @@ qemuValidateDomainWatchdogDef(const virDomainWatchdogDef *dev,
     if (def->nwatchdogs &&
         def->watchdogs[0]->action != dev->action) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("watchdogs with different actions are not supported "
-                         "with this QEMU binary"));
+                       _("watchdogs with different actions are not supported with this QEMU binary"));
         return -1;
     }
 
@@ -2379,17 +2355,14 @@ qemuValidateDomainMdevDefVFIOPCI(const virDomainHostdevDef *hostdev,
 
     if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VFIO_PCI)) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("VFIO PCI device assignment is not "
-                         "supported by this version of QEMU"));
+                       _("VFIO PCI device assignment is not supported by this version of QEMU"));
         return -1;
     }
 
     /* VFIO-PCI does not support boot */
     if (hostdev->info->bootIndex) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("booting from assigned devices is not "
-                         "supported by mediated devices of "
-                         "model vfio-pci"));
+                       _("booting from assigned devices is not supported by mediated devices of model vfio-pci"));
         return -1;
     }
 
@@ -2399,15 +2372,13 @@ qemuValidateDomainMdevDefVFIOPCI(const virDomainHostdevDef *hostdev,
 
     if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_VFIO_PCI_DISPLAY)) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("display property of device vfio-pci is "
-                         "not supported by this version of QEMU"));
+                       _("display property of device vfio-pci is not supported by this version of QEMU"));
         return -1;
     }
 
     if (dev->model != VIR_MDEV_MODEL_TYPE_VFIO_PCI) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("<hostdev> attribute 'display' is only supported"
-                         " with model='vfio-pci'"));
+                       _("<hostdev> attribute 'display' is only supported with model='vfio-pci'"));
 
         return -1;
     }
@@ -2415,8 +2386,7 @@ qemuValidateDomainMdevDefVFIOPCI(const virDomainHostdevDef *hostdev,
     if (dev->display == VIR_TRISTATE_SWITCH_ON) {
         if (def->ngraphics == 0) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("graphics device is needed for attribute value "
-                             "'display=on' in <hostdev>"));
+                           _("graphics device is needed for attribute value 'display=on' in <hostdev>"));
             return -1;
         }
     }
@@ -2435,17 +2405,14 @@ qemuValidateDomainMdevDefVFIOAP(const virDomainHostdevDef *hostdev,
 
     if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VFIO_AP)) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("VFIO AP device assignment is not "
-                         "supported by this version of QEMU"));
+                       _("VFIO AP device assignment is not supported by this version of QEMU"));
         return -1;
     }
 
     /* VFIO-AP does not support boot */
     if (hostdev->info->bootIndex) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("booting from assigned devices is not "
-                         "supported by mediated devices of "
-                         "model vfio-ap"));
+                       _("booting from assigned devices is not supported by mediated devices of model vfio-ap"));
         return -1;
     }
 
@@ -2457,8 +2424,7 @@ qemuValidateDomainMdevDefVFIOAP(const virDomainHostdevDef *hostdev,
             hdev->source.subsys.u.mdev.model == VIR_MDEV_MODEL_TYPE_VFIO_AP) {
             if (vfioap_found) {
                 virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                               _("Only one hostdev of model vfio-ap is "
-                                 "supported"));
+                               _("Only one hostdev of model vfio-ap is supported"));
                 return -1;
             }
             vfioap_found = true;
@@ -2485,8 +2451,7 @@ qemuValidateDomainMdevDef(const virDomainHostdevDef *hostdev,
     case VIR_MDEV_MODEL_TYPE_VFIO_CCW:
         if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VFIO_CCW)) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("VFIO CCW device assignment is not "
-                             "supported by this version of QEMU"));
+                           _("VFIO CCW device assignment is not supported by this version of QEMU"));
             return -1;
         }
         break;
@@ -2536,16 +2501,14 @@ qemuValidateDomainDeviceDefHostdev(const virDomainHostdevDef *hostdev,
             if (backend == VIR_DOMAIN_HOSTDEV_PCI_BACKEND_VFIO) {
                 if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VFIO_PCI)) {
                     virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                                   _("VFIO PCI device assignment is not "
-                                     "supported by this version of qemu"));
+                                   _("VFIO PCI device assignment is not supported by this version of qemu"));
                     return -1;
                 }
             }
 
             if (hostdev->writeFiltering != VIR_TRISTATE_BOOL_ABSENT) {
                 virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                               _("Write filtering of PCI device configuration "
-                                 "space is not supported by qemu"));
+                               _("Write filtering of PCI device configuration space is not supported by qemu"));
                 return -1;
             }
             break;
@@ -2553,8 +2516,7 @@ qemuValidateDomainDeviceDefHostdev(const virDomainHostdevDef *hostdev,
         case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_SCSI_HOST:
             if (hostdev->info->bootIndex) {
                 virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                               _("booting from assigned devices is not "
-                                 "supported by vhost SCSI devices"));
+                               _("booting from assigned devices is not supported by vhost SCSI devices"));
                 return -1;
             }
 
@@ -2639,8 +2601,7 @@ qemuValidateDomainDeviceDefVideo(const virDomainVideoDef *video,
         if (video->vgamem) {
             if (video->vgamem < 1024) {
                 virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                               _("value for 'vgamem' must be at least 1 MiB "
-                                 "(1024 KiB)"));
+                               _("value for 'vgamem' must be at least 1 MiB (1024 KiB)"));
                 return -1;
             }
 
@@ -2666,9 +2627,8 @@ qemuValidateDomainDeviceDefVideo(const virDomainVideoDef *video,
     if (video->type == VIR_DOMAIN_VIDEO_TYPE_VGA ||
         video->type == VIR_DOMAIN_VIDEO_TYPE_VMVGA) {
         if (video->vram && video->vram < 1024) {
-            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
-                           "%s", _("value for 'vram' must be at least "
-                                   "1 MiB (1024 KiB)"));
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                           _("value for 'vram' must be at least 1 MiB (1024 KiB)"));
             return -1;
         }
     }
@@ -2867,8 +2827,7 @@ qemuValidateDomainDeviceDefDiskFrontend(const virDomainDiskDef *disk,
         if (disk->bus == VIR_DOMAIN_DISK_BUS_SCSI &&
             !virQEMUCapsGet(qemuCaps, QEMU_CAPS_SCSI_BLOCK)) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("This QEMU doesn't support scsi-block for "
-                             "lun passthrough"));
+                           _("This QEMU doesn't support scsi-block for lun passthrough"));
             return -1;
         }
 
@@ -2887,8 +2846,7 @@ qemuValidateDomainDeviceDefDiskFrontend(const virDomainDiskDef *disk,
         }
         if (disk->vendor || disk->product) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("Setting vendor or product is not supported "
-                             "for lun device"));
+                           _("Setting vendor or product is not supported for lun device"));
             return -1;
         }
     }
@@ -2960,8 +2918,7 @@ qemuValidateDomainDeviceDefDiskFrontend(const virDomainDiskDef *disk,
     case VIR_DOMAIN_DISK_BUS_USB:
         if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_USB_STORAGE)) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("This QEMU doesn't support '-device "
-                             "usb-storage'"));
+                           _("This QEMU doesn't support '-device usb-storage'"));
             return -1;
         }
 
@@ -3025,8 +2982,7 @@ qemuValidateDomainDeviceDefDiskFrontend(const virDomainDiskDef *disk,
         disk->bus == VIR_DOMAIN_DISK_BUS_SCSI &&
         disk->device == VIR_DOMAIN_DISK_DEVICE_LUN) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("scsi-block 'lun' devices do not support the "
-                         "serial property"));
+                       _("scsi-block 'lun' devices do not support the serial property"));
         return -1;
     }
 
@@ -3056,8 +3012,7 @@ qemuValidateDomainDeviceDefDiskBlkdeviotune(const virDomainDiskDef *disk,
     if (disk->blkdeviotune.group_name &&
         !virDomainBlockIoTuneInfoHasAny(&disk->blkdeviotune)) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("group_name can be configured only together with "
-                         "settings"));
+                       _("group_name can be configured only together with settings"));
         return -1;
     }
 
@@ -3285,8 +3240,7 @@ qemuValidateCheckSCSIControllerModel(virQEMUCaps *qemuCaps,
     case VIR_DOMAIN_CONTROLLER_MODEL_SCSI_LSILOGIC:
         if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_SCSI_LSI)) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("This QEMU doesn't support "
-                             "the LSI 53C895A SCSI controller"));
+                           _("This QEMU doesn't support the LSI 53C895A SCSI controller"));
             return false;
         }
         break;
@@ -3295,8 +3249,7 @@ qemuValidateCheckSCSIControllerModel(virQEMUCaps *qemuCaps,
     case VIR_DOMAIN_CONTROLLER_MODEL_SCSI_VIRTIO_NON_TRANSITIONAL:
         if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_SCSI)) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("This QEMU doesn't support "
-                             "virtio scsi controller"));
+                           _("This QEMU doesn't support virtio scsi controller"));
             return false;
         }
         break;
@@ -3306,24 +3259,21 @@ qemuValidateCheckSCSIControllerModel(virQEMUCaps *qemuCaps,
     case VIR_DOMAIN_CONTROLLER_MODEL_SCSI_LSISAS1068:
         if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_SCSI_MPTSAS1068)) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("This QEMU doesn't support "
-                             "the LSI SAS1068 (MPT Fusion) controller"));
+                           _("This QEMU doesn't support the LSI SAS1068 (MPT Fusion) controller"));
             return false;
         }
         break;
     case VIR_DOMAIN_CONTROLLER_MODEL_SCSI_LSISAS1078:
         if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_SCSI_MEGASAS)) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("This QEMU doesn't support "
-                             "the LSI SAS1078 (MegaRAID) controller"));
+                           _("This QEMU doesn't support the LSI SAS1078 (MegaRAID) controller"));
             return false;
         }
         break;
     case VIR_DOMAIN_CONTROLLER_MODEL_SCSI_VMPVSCSI:
         if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_SCSI_PVSCSI)) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("This QEMU doesn't support "
-                             "the pvscsi (VMware paravirtual SCSI) controller"));
+                           _("This QEMU doesn't support the pvscsi (VMware paravirtual SCSI) controller"));
             return false;
         }
         break;
@@ -3336,22 +3286,19 @@ qemuValidateCheckSCSIControllerModel(virQEMUCaps *qemuCaps,
     case VIR_DOMAIN_CONTROLLER_MODEL_SCSI_NCR53C90:
         if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_SCSI_NCR53C90)) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("This QEMU doesn't support "
-                             "the NCR53C90 (ESP) controller"));
+                           _("This QEMU doesn't support the NCR53C90 (ESP) controller"));
         }
         return true;
     case VIR_DOMAIN_CONTROLLER_MODEL_SCSI_DC390:
         if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_SCSI_DC390)) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("This QEMU doesn't support "
-                             "the DC390 (ESP) controller"));
+                           _("This QEMU doesn't support the DC390 (ESP) controller"));
         }
         return true;
     case VIR_DOMAIN_CONTROLLER_MODEL_SCSI_AM53C974:
         if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_SCSI_AM53C974)) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("This QEMU doesn't support "
-                             "the AM53C974 (ESP) controller"));
+                           _("This QEMU doesn't support the AM53C974 (ESP) controller"));
         }
         return true;
     case VIR_DOMAIN_CONTROLLER_MODEL_SCSI_DEFAULT:
@@ -3401,12 +3348,10 @@ qemuValidateDomainDeviceDefControllerIDE(const virDomainControllerDef *controlle
      */
     if (qemuDomainHasBuiltinIDE(def))
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("Only a single IDE controller is supported "
-                         "for this machine type"));
+                       _("Only a single IDE controller is supported for this machine type"));
     else
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("IDE controllers are unsupported for "
-                         "this QEMU binary or machine type"));
+                       _("IDE controllers are unsupported for this QEMU binary or machine type"));
     return -1;
 }
 
@@ -3432,8 +3377,7 @@ qemuValidateCheckSCSIControllerIOThreads(const virDomainControllerDef *controlle
         controller->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI &&
         controller->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_CCW) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("virtio-scsi IOThreads only available for virtio "
-                         "pci and virtio ccw controllers"));
+                       _("virtio-scsi IOThreads only available for virtio pci and virtio ccw controllers"));
        return false;
     }
 
@@ -4154,8 +4098,7 @@ qemuValidateDomainDeviceDefSPICEGraphics(const virDomainGraphicsDef *graphics,
     case VIR_DOMAIN_GRAPHICS_LISTEN_TYPE_NETWORK:
         if (tlsPort > 0 && !cfg->spiceTLS) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("spice TLS port set in XML configuration, "
-                             "but TLS is disabled in qemu.conf"));
+                           _("spice TLS port set in XML configuration, but TLS is disabled in qemu.conf"));
             return -1;
         }
         break;
@@ -4262,8 +4205,7 @@ qemuValidateDomainDeviceDefGraphics(const virDomainGraphicsDef *graphics,
             graphics->type != VIR_DOMAIN_GRAPHICS_TYPE_VNC &&
             graphics->type != VIR_DOMAIN_GRAPHICS_TYPE_SPICE) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("graphics type 'egl-headless' is only supported "
-                             "with one of: 'vnc', 'spice' graphics types"));
+                           _("graphics type 'egl-headless' is only supported with one of: 'vnc', 'spice' graphics types"));
             return -1;
         }
 
@@ -4273,8 +4215,7 @@ qemuValidateDomainDeviceDefGraphics(const virDomainGraphicsDef *graphics,
         if (graphics->type == VIR_DOMAIN_GRAPHICS_TYPE_SPICE &&
             graphics->data.spice.gl == VIR_TRISTATE_BOOL_YES) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("multiple OpenGL displays are not supported "
-                             "by QEMU"));
+                           _("multiple OpenGL displays are not supported by QEMU"));
             return -1;
         }
     }
@@ -4291,8 +4232,7 @@ qemuValidateDomainDeviceDefGraphics(const virDomainGraphicsDef *graphics,
         if (graphics->data.egl_headless.rendernode &&
             !virQEMUCapsGet(qemuCaps, QEMU_CAPS_EGL_HEADLESS_RENDERNODE)) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("This QEMU doesn't support OpenGL rendernode "
-                             "with egl-headless graphics type"));
+                           _("This QEMU doesn't support OpenGL rendernode with egl-headless graphics type"));
             return -1;
         }
 
@@ -4555,16 +4495,14 @@ qemuValidateDomainDeviceDefSound(virDomainSoundDef *sound,
     case VIR_DOMAIN_SOUND_MODEL_USB:
         if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_OBJECT_USB_AUDIO)) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("usb-audio controller is not supported "
-                             "by this QEMU binary"));
+                           _("usb-audio controller is not supported by this QEMU binary"));
             return -1;
         }
         break;
     case VIR_DOMAIN_SOUND_MODEL_ICH9:
         if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_ICH9_INTEL_HDA)) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("The ich9-intel-hda audio controller "
-                             "is not supported in this QEMU binary"));
+                           _("The ich9-intel-hda audio controller is not supported in this QEMU binary"));
             return -1;
         }
         break;
@@ -4609,8 +4547,7 @@ qemuValidateDomainDeviceDefVsock(virQEMUCaps *qemuCaps)
 {
     if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VHOST_VSOCK)) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("vsock device is not supported "
-                         "with this QEMU binary"));
+                       _("vsock device is not supported with this QEMU binary"));
         return -1;
     }
 
@@ -4716,8 +4653,7 @@ qemuValidateDomainDeviceDefInput(const virDomainInputDef *input,
         input->type == VIR_DOMAIN_INPUT_TYPE_KBD &&
         !virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_USB_KBD)) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("usb keyboard is not supported by this "
-                         "QEMU binary"));
+                       _("usb keyboard is not supported by this QEMU binary"));
         return -1;
     }
 
@@ -4904,36 +4840,31 @@ qemuValidateDomainDeviceDefIOMMU(const virDomainIOMMUDef *iommu,
     if (iommu->intremap != VIR_TRISTATE_SWITCH_ABSENT &&
         !virQEMUCapsGet(qemuCaps, QEMU_CAPS_INTEL_IOMMU_INTREMAP)) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("iommu: interrupt remapping is not supported "
-                         "with this QEMU binary"));
+                       _("iommu: interrupt remapping is not supported with this QEMU binary"));
         return -1;
     }
     if (iommu->caching_mode != VIR_TRISTATE_SWITCH_ABSENT &&
         !virQEMUCapsGet(qemuCaps, QEMU_CAPS_INTEL_IOMMU_CACHING_MODE))  {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("iommu: caching mode is not supported "
-                         "with this QEMU binary"));
+                       _("iommu: caching mode is not supported with this QEMU binary"));
         return -1;
     }
     if (iommu->eim != VIR_TRISTATE_SWITCH_ABSENT &&
         !virQEMUCapsGet(qemuCaps, QEMU_CAPS_INTEL_IOMMU_EIM))  {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("iommu: eim is not supported "
-                         "with this QEMU binary"));
+                       _("iommu: eim is not supported with this QEMU binary"));
         return -1;
     }
     if (iommu->iotlb != VIR_TRISTATE_SWITCH_ABSENT &&
         !virQEMUCapsGet(qemuCaps, QEMU_CAPS_INTEL_IOMMU_DEVICE_IOTLB)) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("iommu: device IOTLB is not supported "
-                         "with this QEMU binary"));
+                       _("iommu: device IOTLB is not supported with this QEMU binary"));
         return -1;
     }
     if (iommu->aw_bits > 0 &&
         !virQEMUCapsGet(qemuCaps, QEMU_CAPS_INTEL_IOMMU_AW_BITS)) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                       _("iommu: aw_bits is not supported "
-                         "with this QEMU binary"));
+                       _("iommu: aw_bits is not supported with this QEMU binary"));
         return -1;
     }
 
@@ -4952,8 +4883,7 @@ qemuValidateDomainDeviceDefNVRAM(virDomainNVRAMDef *nvram,
     if (qemuDomainIsPSeries(def)) {
         if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_NVRAM)) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("nvram device is not supported by "
-                             "this QEMU binary"));
+                           _("nvram device is not supported by this QEMU binary"));
             return -1;
         }
     } else {
@@ -5021,8 +4951,7 @@ qemuValidateDomainDeviceDefMemory(virDomainMemoryDef *mem,
         if (mem->target.nvdimm.readonly &&
             !virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_NVDIMM_UNARMED)) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
-                           _("nvdimm readonly property is not available "
-                             "with this QEMU binary"));
+                           _("nvdimm readonly property is not available with this QEMU binary"));
             return -1;
         }
         break;
-- 
2.41.0




[Index of Archives]     [Virt Tools]     [Libvirt Users]     [Lib OS Info]     [Fedora Users]     [Fedora Desktop]     [Fedora SELinux]     [Big List of Linux Books]     [Yosemite News]     [KDE Users]     [Fedora Tools]

  Powered by Linux