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;
}
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;
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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)
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)
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;
}
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;
}
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)
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;
}
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;
}
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;
}
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,");
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,");
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,",
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,",
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;
}
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;
}
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;
}
/* 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;
}
* 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;
}
}
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;
}
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;
}
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;
}
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;
}
* 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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
}
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;
}
* 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;
}
}
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;
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 {
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 {
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 {
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;
}
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;
}
* 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;
}
/* 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;
}
}
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;
}
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;
} 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;
}
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;
}
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;
}
}
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;
}
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;
}
}
* 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;
}
* 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;
}
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 {
* 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;
}
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;
}
}
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;
}
}
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;
}
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:
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
!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;
}
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;
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
}
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;
}
}
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;
}
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") &&
(!(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;
}
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;
}
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;
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;
}
}
!(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;
}
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;
}
* 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;
}
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) {
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;
}
/* 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++)
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;
}
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;
}
&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;
}
&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;
}
&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;
}
&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;
}
&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;
}
&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;
}
&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;
}
&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;
}
}
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;
}
((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")))) {
((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")))) {
((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")))) {
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;
}
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;
}
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);
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;
}
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 {
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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)
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;
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;
}
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;
}
}
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
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;
}
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;
}
(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;
}
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;
}
(!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;
}
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 */
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;
}
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:
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)
!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;
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;
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;
}
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;
}
* 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;
* 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;
* 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;
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;
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;
}
}
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;
}
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;
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;
}
} 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;
}
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;
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;
}
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;
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;
}
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;
}
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;
}
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;
}
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;
}
}
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;
}
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;
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;
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;
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;
}
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;
}
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;
}
}
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;
}
}
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;
}
}
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;
}
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;
}
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;
}
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;
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;
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;
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:
*/
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;
}
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;
}
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;
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;
}
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;
}
}
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;
}
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;
{
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;
}
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;
}
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;
}
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 {
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;
projects / thirdparty / libvirt.git / commitdiff
