[libvirt] [PATCH 02/13] qemu: Define hvf capability

[Roman Bolshakov]

Signed-off-by: Roman Bolshakov <***@yadro.com>
---
src/qemu/qemu_capabilities.c | 1 +
src/qemu/qemu_capabilities.h | 1 +
2 files changed, 2 insertions(+)

diff --git a/src/qemu/qemu_capabilities.c b/src/qemu/qemu_capabilities.c
index e228f52ec0..65cf5b5c03 100644
--- a/src/qemu/qemu_capabilities.c
+++ b/src/qemu/qemu_capabilities.c
@@ -508,6 +508,7 @@ VIR_ENUM_IMPL(virQEMUCaps, QEMU_CAPS_LAST,
/* 315 */
"vfio-pci.display",
"blockdev",
+ "hvf",
);


diff --git a/src/qemu/qemu_capabilities.h b/src/qemu/qemu_capabilities.h
index 934620ed31..e61f1e78a9 100644
--- a/src/qemu/qemu_capabilities.h
+++ b/src/qemu/qemu_capabilities.h
@@ -492,6 +492,7 @@ typedef enum { /* virQEMUCapsFlags grouping marker for syntax-check */
/* 315 */
QEMU_CAPS_VFIO_PCI_DISPLAY, /* -device vfio-pci.display */
QEMU_CAPS_BLOCKDEV, /* -blockdev and blockdev-add are supported */
+ QEMU_CAPS_HVF, /* Whether Hypervisor.framework is available */

QEMU_CAPS_LAST /* this must always be the last item */
} virQEMUCapsFlags;

[Roman Bolshakov]

It replaces hardcoded checks that select accelCPU/accelCPUModels
(formerly known as kvmCPU/kvmCPUModels) for KVM. It'll be cleaner to use
the function when multiple accelerators are supported in qemu driver.

Explicit KVM domain checks should be done only when a feature is
available only for KVM.

Signed-off-by: Roman Bolshakov <***@yadro.com>
---
src/qemu/qemu_capabilities.c | 28 +++++++++++++++++-----------
1 file changed, 17 insertions(+), 11 deletions(-)

diff --git a/src/qemu/qemu_capabilities.c b/src/qemu/qemu_capabilities.c
index 4dac040246..eb3148038a 100644
--- a/src/qemu/qemu_capabilities.c
+++ b/src/qemu/qemu_capabilities.c
@@ -630,6 +630,11 @@ static const char *virQEMUCapsArchToString(virArch arch)
return virArchToString(arch);
}

+static bool
+virQEMUCapsTypeIsAccelerated(virDomainVirtType type)
+{
+ return type == VIR_DOMAIN_VIRT_KVM;
+}

/* Checks whether a domain with @guest arch can run natively on @host.
*/
@@ -1772,7 +1777,7 @@ virQEMUCapsAddCPUDefinitions(virQEMUCapsPtr qemuCaps,
size_t i;
virDomainCapsCPUModelsPtr cpus = NULL;

- if (type == VIR_DOMAIN_VIRT_KVM && qemuCaps->accelCPUModels)
+ if (virQEMUCapsTypeIsAccelerated(type) && qemuCaps->accelCPUModels)
cpus = qemuCaps->accelCPUModels;
else if (type == VIR_DOMAIN_VIRT_QEMU && qemuCaps->tcgCPUModels)
cpus = qemuCaps->tcgCPUModels;
@@ -1781,7 +1786,7 @@ virQEMUCapsAddCPUDefinitions(virQEMUCapsPtr qemuCaps,
if (!(cpus = virDomainCapsCPUModelsNew(count)))
return -1;

- if (type == VIR_DOMAIN_VIRT_KVM)
+ if (virQEMUCapsTypeIsAccelerated(type))
qemuCaps->accelCPUModels = cpus;
else
qemuCaps->tcgCPUModels = cpus;
@@ -1800,7 +1805,7 @@ virDomainCapsCPUModelsPtr
virQEMUCapsGetCPUDefinitions(virQEMUCapsPtr qemuCaps,
virDomainVirtType type)
{
- if (type == VIR_DOMAIN_VIRT_KVM)
+ if (virQEMUCapsTypeIsAccelerated(type))
return qemuCaps->accelCPUModels;
else
return qemuCaps->tcgCPUModels;
@@ -1811,7 +1816,7 @@ static virQEMUCapsHostCPUDataPtr
virQEMUCapsGetHostCPUData(virQEMUCapsPtr qemuCaps,
virDomainVirtType type)
{
- if (type == VIR_DOMAIN_VIRT_KVM)
+ if (virQEMUCapsTypeIsAccelerated(type))
return &qemuCaps->accelCPU;
else
return &qemuCaps->tcgCPU;
@@ -1867,7 +1872,7 @@ virQEMUCapsIsCPUModeSupported(virQEMUCapsPtr qemuCaps,

switch (mode) {
case VIR_CPU_MODE_HOST_PASSTHROUGH:
- return type == VIR_DOMAIN_VIRT_KVM &&
+ return virQEMUCapsTypeIsAccelerated(type) &&
virQEMUCapsGuestIsNative(caps->host.arch, qemuCaps->arch);

case VIR_CPU_MODE_HOST_MODEL:
@@ -1875,7 +1880,7 @@ virQEMUCapsIsCPUModeSupported(virQEMUCapsPtr qemuCaps,
VIR_QEMU_CAPS_HOST_CPU_REPORTED);

case VIR_CPU_MODE_CUSTOM:
- if (type == VIR_DOMAIN_VIRT_KVM)
+ if (virQEMUCapsTypeIsAccelerated(type))
cpus = qemuCaps->accelCPUModels;
else
cpus = qemuCaps->tcgCPUModels;
@@ -2976,7 +2981,7 @@ virQEMUCapsInitHostCPUModel(virQEMUCapsPtr qemuCaps,
virArchToString(qemuCaps->arch),
virDomainVirtTypeToString(type));
goto error;
- } else if (type == VIR_DOMAIN_VIRT_KVM &&
+ } else if (virQEMUCapsTypeIsAccelerated(type) &&
virCPUGetHostIsSupported(qemuCaps->arch)) {
if (!(fullCPU = virCPUGetHost(qemuCaps->arch, VIR_CPU_TYPE_GUEST,
NULL, NULL)))
@@ -3203,7 +3208,7 @@ virQEMUCapsLoadCPUModels(virQEMUCapsPtr qemuCaps,
if (!(cpus = virDomainCapsCPUModelsNew(n)))
goto cleanup;

- if (type == VIR_DOMAIN_VIRT_KVM)
+ if (virQEMUCapsTypeIsAccelerated(type))
qemuCaps->accelCPUModels = cpus;
else
qemuCaps->tcgCPUModels = cpus;
@@ -3677,7 +3682,7 @@ virQEMUCapsFormatCPUModels(virQEMUCapsPtr qemuCaps,
const char *typeStr;
size_t i;

- if (type == VIR_DOMAIN_VIRT_KVM) {
+ if (virQEMUCapsTypeIsAccelerated(type))
typeStr = "kvm";
cpus = qemuCaps->accelCPUModels;
} else {
@@ -4932,7 +4937,8 @@ virQEMUCapsCacheLookupDefault(virFileCachePtr cache,
if (virttype == VIR_DOMAIN_VIRT_NONE)
virttype = capsType;

- if (virttype == VIR_DOMAIN_VIRT_KVM && capsType == VIR_DOMAIN_VIRT_QEMU) {
+ if (virQEMUCapsTypeIsAccelerated(virttype) &&
+ !virQEMUCapsTypeIsAccelerated(capsType)) {
virReportError(VIR_ERR_INVALID_ARG,
_("KVM is not supported by '%s' on this host"),
binary);
@@ -5072,7 +5078,7 @@ virQEMUCapsFillDomainCPUCaps(virCapsPtr caps,
if (virCPUGetModels(domCaps->arch, &models) >= 0) {
virDomainCapsCPUModelsPtr cpus;

- if (domCaps->virttype == VIR_DOMAIN_VIRT_KVM)
+ if (virQEMUCapsTypeIsAccelerated(domCaps->virttype))
cpus = qemuCaps->accelCPUModels;
else
cpus = qemuCaps->tcgCPUModels;

[Roman Bolshakov]

This makes possible to add more accelerators by touching less code and
reduces code duplication.

Signed-off-by: Roman Bolshakov <***@yadro.com>
---
src/qemu/qemu_capabilities.c | 19 +++++++++++++------
1 file changed, 13 insertions(+), 6 deletions(-)

diff --git a/src/qemu/qemu_capabilities.c b/src/qemu/qemu_capabilities.c
index 02f05aef70..1a2a8c5b7a 100644
--- a/src/qemu/qemu_capabilities.c
+++ b/src/qemu/qemu_capabilities.c
@@ -651,6 +651,16 @@ virQEMUCapsToVirtType(virQEMUCapsPtr qemuCaps)
return VIR_DOMAIN_VIRT_QEMU;
}

+static const char *
+virQEMUCapsAccelStr(virDomainVirtType type)
+{
+ if (type == VIR_DOMAIN_VIRT_KVM) {
+ return "kvm";
+ } else {
+ return "tcg";
+ }
+}
+
/* Checks whether a domain with @guest arch can run natively on @host.
*/
bool
@@ -3639,7 +3649,7 @@ virQEMUCapsFormatHostCPUModelInfo(virQEMUCapsPtr qemuCaps,
{
virQEMUCapsHostCPUDataPtr cpuData = virQEMUCapsGetHostCPUData(qemuCaps, type);
qemuMonitorCPUModelInfoPtr model = cpuData->info;
- const char *typeStr = type == VIR_DOMAIN_VIRT_KVM ? "kvm" : "tcg";
+ const char *typeStr = virQEMUCapsAccelStr(type);
size_t i;

if (!model)
@@ -3694,16 +3704,13 @@ virQEMUCapsFormatCPUModels(virQEMUCapsPtr qemuCaps,
virDomainVirtType type)
{
virDomainCapsCPUModelsPtr cpus;
- const char *typeStr;
+ const char *typeStr = virQEMUCapsAccelStr(type);
size_t i;

if (virQEMUCapsTypeIsAccelerated(type))
- typeStr = "kvm";
cpus = qemuCaps->accelCPUModels;
- } else {
- typeStr = "tcg";
+ else
cpus = qemuCaps->tcgCPUModels;
- }

if (!cpus)
return;

[Roman Bolshakov]

With this change virsh domcapabilites shows:
<mode name='host-passthrough' supported='yes'/>

Signed-off-by: Roman Bolshakov <***@yadro.com>
---
src/qemu/qemu_capabilities.c | 22 +++++++++++++++++++---
1 file changed, 19 insertions(+), 3 deletions(-)

diff --git a/src/qemu/qemu_capabilities.c b/src/qemu/qemu_capabilities.c
index cd78f936ab..497b4ef1e9 100644
--- a/src/qemu/qemu_capabilities.c
+++ b/src/qemu/qemu_capabilities.c
@@ -633,13 +633,15 @@ static const char *virQEMUCapsArchToString(virArch arch)
static bool
virQEMUCapsTypeIsAccelerated(virDomainVirtType type)
{
- return type == VIR_DOMAIN_VIRT_KVM;
+ return type == VIR_DOMAIN_VIRT_KVM ||
+ type == VIR_DOMAIN_VIRT_HVF;
}

static bool
virQEMUCapsHaveAccel(virQEMUCapsPtr qemuCaps)
{
- return virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM);
+ return virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM) ||
+ virQEMUCapsGet(qemuCaps, QEMU_CAPS_HVF);
}

static virDomainVirtType
@@ -647,6 +649,8 @@ virQEMUCapsToVirtType(virQEMUCapsPtr qemuCaps)
{
if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM))
return VIR_DOMAIN_VIRT_KVM;
+ else if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_HVF))
+ return VIR_DOMAIN_VIRT_HVF;
else
return VIR_DOMAIN_VIRT_QEMU;
}
@@ -656,6 +660,8 @@ virQEMUCapsAccelStr(virDomainVirtType type)
{
if (type == VIR_DOMAIN_VIRT_KVM) {
return "kvm";
+ } else if (type == VIR_DOMAIN_VIRT_HVF) {
+ return "hvf";
} else {
return "tcg";
}
@@ -3081,6 +3087,8 @@ virQEMUCapsLoadHostCPUModelInfo(virQEMUCapsPtr qemuCaps,

if (virtType == VIR_DOMAIN_VIRT_KVM)
hostCPUNode = virXPathNode("./hostCPU[@type='kvm']", ctxt);
+ else if (virtType == VIR_DOMAIN_VIRT_HVF)
+ hostCPUNode = virXPathNode("./hostCPU[@type='hvf']", ctxt);
else
hostCPUNode = virXPathNode("./hostCPU[@type='tcg']", ctxt);

@@ -3216,6 +3224,8 @@ virQEMUCapsLoadCPUModels(virQEMUCapsPtr qemuCaps,

if (type == VIR_DOMAIN_VIRT_KVM)
n = virXPathNodeSet("./cpu[@type='kvm']", ctxt, &nodes);
+ else if (type == VIR_DOMAIN_VIRT_HVF)
+ n = virXPathNodeSet("./cpu[@type='hvf']", ctxt, &nodes);
else
n = virXPathNodeSet("./cpu[@type='tcg']", ctxt, &nodes);

@@ -3513,10 +3523,12 @@ virQEMUCapsLoadCache(virArch hostArch,
VIR_FREE(str);

if (virQEMUCapsLoadHostCPUModelInfo(qemuCaps, ctxt, VIR_DOMAIN_VIRT_KVM) < 0 ||
+ virQEMUCapsLoadHostCPUModelInfo(qemuCaps, ctxt, VIR_DOMAIN_VIRT_HVF) < 0 ||
virQEMUCapsLoadHostCPUModelInfo(qemuCaps, ctxt, VIR_DOMAIN_VIRT_QEMU) < 0)
goto cleanup;

if (virQEMUCapsLoadCPUModels(qemuCaps, ctxt, VIR_DOMAIN_VIRT_KVM) < 0 ||
+ virQEMUCapsLoadCPUModels(qemuCaps, ctxt, VIR_DOMAIN_VIRT_HVF) < 0 ||
virQEMUCapsLoadCPUModels(qemuCaps, ctxt, VIR_DOMAIN_VIRT_QEMU) < 0)
goto cleanup;

@@ -3630,6 +3642,7 @@ virQEMUCapsLoadCache(virArch hostArch,
goto cleanup;

virQEMUCapsInitHostCPUModel(qemuCaps, hostArch, VIR_DOMAIN_VIRT_KVM);
+ virQEMUCapsInitHostCPUModel(qemuCaps, hostArch, VIR_DOMAIN_VIRT_HVF);
virQEMUCapsInitHostCPUModel(qemuCaps, hostArch, VIR_DOMAIN_VIRT_QEMU);

ret = 0;
@@ -3809,9 +3822,11 @@ virQEMUCapsFormatCache(virQEMUCapsPtr qemuCaps)
virArchToString(qemuCaps->arch));

virQEMUCapsFormatHostCPUModelInfo(qemuCaps, &buf, VIR_DOMAIN_VIRT_KVM);
+ virQEMUCapsFormatHostCPUModelInfo(qemuCaps, &buf, VIR_DOMAIN_VIRT_HVF);
virQEMUCapsFormatHostCPUModelInfo(qemuCaps, &buf, VIR_DOMAIN_VIRT_QEMU);

virQEMUCapsFormatCPUModels(qemuCaps, &buf, VIR_DOMAIN_VIRT_KVM);
+ virQEMUCapsFormatCPUModels(qemuCaps, &buf, VIR_DOMAIN_VIRT_HVF);
virQEMUCapsFormatCPUModels(qemuCaps, &buf, VIR_DOMAIN_VIRT_QEMU);

for (i = 0; i < qemuCaps->nmachineTypes; i++) {
@@ -4422,7 +4437,7 @@ virQEMUCapsInitQMPCommandRun(virQEMUCapsInitQMPCommandPtr cmd,
if (forceTCG)
machine = "none,accel=tcg";
else
- machine = "none,accel=kvm:tcg";
+ machine = "none,accel=kvm:hvf:tcg";

VIR_DEBUG("Try to probe capabilities of '%s' via QMP, machine %s",
cmd->binary, machine);
@@ -4612,6 +4627,7 @@ virQEMUCapsNewForBinaryInternal(virArch hostArch,
qemuCaps->libvirtVersion = LIBVIR_VERSION_NUMBER;

virQEMUCapsInitHostCPUModel(qemuCaps, hostArch, VIR_DOMAIN_VIRT_KVM);
+ virQEMUCapsInitHostCPUModel(qemuCaps, hostArch, VIR_DOMAIN_VIRT_HVF);
virQEMUCapsInitHostCPUModel(qemuCaps, hostArch, VIR_DOMAIN_VIRT_QEMU);

if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM)) {

[Daniel P. Berrangé]

Post by Roman Bolshakov
<mode name='host-passthrough' supported='yes'/>
---
src/qemu/qemu_capabilities.c | 22 +++++++++++++++++++---
1 file changed, 19 insertions(+), 3 deletions(-)

Reviewed-by: Daniel P. Berrangé <***@redhat.com>


Regards,
Daniel

[Daniel P. Berrangé]

Post by Roman Bolshakov
<mode name='host-passthrough' supported='yes'/>
---
src/qemu/qemu_capabilities.c | 22 +++++++++++++++++++---
1 file changed, 19 insertions(+), 3 deletions(-)
diff --git a/src/qemu/qemu_capabilities.c b/src/qemu/qemu_capabilities.c
index cd78f936ab..497b4ef1e9 100644
--- a/src/qemu/qemu_capabilities.c
+++ b/src/qemu/qemu_capabilities.c
@@ -633,13 +633,15 @@ static const char *virQEMUCapsArchToString(virArch arch)
static bool
virQEMUCapsTypeIsAccelerated(virDomainVirtType type)
{
- return type == VIR_DOMAIN_VIRT_KVM;
+ return type == VIR_DOMAIN_VIRT_KVM ||
+ type == VIR_DOMAIN_VIRT_HVF;
}
static bool
virQEMUCapsHaveAccel(virQEMUCapsPtr qemuCaps)
{
- return virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM);
+ return virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM) ||
+ virQEMUCapsGet(qemuCaps, QEMU_CAPS_HVF);
}
static virDomainVirtType
@@ -647,6 +649,8 @@ virQEMUCapsToVirtType(virQEMUCapsPtr qemuCaps)
{
if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM))
return VIR_DOMAIN_VIRT_KVM;
+ else if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_HVF))
+ return VIR_DOMAIN_VIRT_HVF;
else
return VIR_DOMAIN_VIRT_QEMU;
}
@@ -656,6 +660,8 @@ virQEMUCapsAccelStr(virDomainVirtType type)
{
if (type == VIR_DOMAIN_VIRT_KVM) {
return "kvm";
+ } else if (type == VIR_DOMAIN_VIRT_HVF) {
+ return "hvf";
} else {
return "tcg";
}
@@ -3081,6 +3087,8 @@ virQEMUCapsLoadHostCPUModelInfo(virQEMUCapsPtr qemuCaps,
if (virtType == VIR_DOMAIN_VIRT_KVM)
+ else if (virtType == VIR_DOMAIN_VIRT_HVF)
else
@@ -3216,6 +3224,8 @@ virQEMUCapsLoadCPUModels(virQEMUCapsPtr qemuCaps,
if (type == VIR_DOMAIN_VIRT_KVM)
+ else if (type == VIR_DOMAIN_VIRT_HVF)
else
@@ -3513,10 +3523,12 @@ virQEMUCapsLoadCache(virArch hostArch,
VIR_FREE(str);
if (virQEMUCapsLoadHostCPUModelInfo(qemuCaps, ctxt, VIR_DOMAIN_VIRT_KVM) < 0 ||
+ virQEMUCapsLoadHostCPUModelInfo(qemuCaps, ctxt, VIR_DOMAIN_VIRT_HVF) < 0 ||
virQEMUCapsLoadHostCPUModelInfo(qemuCaps, ctxt, VIR_DOMAIN_VIRT_QEMU) < 0)
goto cleanup;

On investigation of why qemucapabilitiestest failed after this, I figured
out that this code is already broken for KVM. It is blindly loadting the
KVM CPU models in the capabilities XML regardless of whether KVM is
supported or not. Likewise for all the methods which follow below

Post by Roman Bolshakov
if (virQEMUCapsLoadCPUModels(qemuCaps, ctxt, VIR_DOMAIN_VIRT_KVM) < 0 ||
+ virQEMUCapsLoadCPUModels(qemuCaps, ctxt, VIR_DOMAIN_VIRT_HVF) < 0 ||
virQEMUCapsLoadCPUModels(qemuCaps, ctxt, VIR_DOMAIN_VIRT_QEMU) < 0)
goto cleanup;
@@ -3630,6 +3642,7 @@ virQEMUCapsLoadCache(virArch hostArch,
goto cleanup;
virQEMUCapsInitHostCPUModel(qemuCaps, hostArch, VIR_DOMAIN_VIRT_KVM);
+ virQEMUCapsInitHostCPUModel(qemuCaps, hostArch, VIR_DOMAIN_VIRT_HVF);
virQEMUCapsInitHostCPUModel(qemuCaps, hostArch, VIR_DOMAIN_VIRT_QEMU);
ret = 0;
@@ -3809,9 +3822,11 @@ virQEMUCapsFormatCache(virQEMUCapsPtr qemuCaps)
virArchToString(qemuCaps->arch));
virQEMUCapsFormatHostCPUModelInfo(qemuCaps, &buf, VIR_DOMAIN_VIRT_KVM);
+ virQEMUCapsFormatHostCPUModelInfo(qemuCaps, &buf, VIR_DOMAIN_VIRT_HVF);
virQEMUCapsFormatHostCPUModelInfo(qemuCaps, &buf, VIR_DOMAIN_VIRT_QEMU);
virQEMUCapsFormatCPUModels(qemuCaps, &buf, VIR_DOMAIN_VIRT_KVM);
+ virQEMUCapsFormatCPUModels(qemuCaps, &buf, VIR_DOMAIN_VIRT_HVF);
virQEMUCapsFormatCPUModels(qemuCaps, &buf, VIR_DOMAIN_VIRT_QEMU);
for (i = 0; i < qemuCaps->nmachineTypes; i++) {
@@ -4422,7 +4437,7 @@ virQEMUCapsInitQMPCommandRun(virQEMUCapsInitQMPCommandPtr cmd,
if (forceTCG)
machine = "none,accel=tcg";
else
- machine = "none,accel=kvm:tcg";
+ machine = "none,accel=kvm:hvf:tcg";
VIR_DEBUG("Try to probe capabilities of '%s' via QMP, machine %s",
cmd->binary, machine);
@@ -4612,6 +4627,7 @@ virQEMUCapsNewForBinaryInternal(virArch hostArch,
qemuCaps->libvirtVersion = LIBVIR_VERSION_NUMBER;
virQEMUCapsInitHostCPUModel(qemuCaps, hostArch, VIR_DOMAIN_VIRT_KVM);
+ virQEMUCapsInitHostCPUModel(qemuCaps, hostArch, VIR_DOMAIN_VIRT_HVF);
virQEMUCapsInitHostCPUModel(qemuCaps, hostArch, VIR_DOMAIN_VIRT_QEMU);
if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM)) {

I was able to fix the test with this diff


@@ -3546,13 +3546,17 @@ virQEMUCapsLoadCache(virArch hostArch,
}
VIR_FREE(str);

- if (virQEMUCapsLoadHostCPUModelInfo(qemuCaps, ctxt, VIR_DOMAIN_VIRT_KVM) < 0 ||
- virQEMUCapsLoadHostCPUModelInfo(qemuCaps, ctxt, VIR_DOMAIN_VIRT_HVF) < 0 ||
+ if ((virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM) &&
+ virQEMUCapsLoadHostCPUModelInfo(qemuCaps, ctxt, VIR_DOMAIN_VIRT_KVM) < 0) ||
+ (virQEMUCapsGet(qemuCaps, QEMU_CAPS_HVF) &&
+ virQEMUCapsLoadHostCPUModelInfo(qemuCaps, ctxt, VIR_DOMAIN_VIRT_HVF) < 0) ||
virQEMUCapsLoadHostCPUModelInfo(qemuCaps, ctxt, VIR_DOMAIN_VIRT_QEMU) < 0)
goto cleanup;

- if (virQEMUCapsLoadCPUModels(qemuCaps, ctxt, VIR_DOMAIN_VIRT_KVM) < 0 ||
- virQEMUCapsLoadCPUModels(qemuCaps, ctxt, VIR_DOMAIN_VIRT_HVF) < 0 ||
+ if ((virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM) &&
+ virQEMUCapsLoadCPUModels(qemuCaps, ctxt, VIR_DOMAIN_VIRT_KVM) < 0) ||
+ (virQEMUCapsGet(qemuCaps, QEMU_CAPS_HVF) &&
+ virQEMUCapsLoadCPUModels(qemuCaps, ctxt, VIR_DOMAIN_VIRT_HVF) < 0) ||
virQEMUCapsLoadCPUModels(qemuCaps, ctxt, VIR_DOMAIN_VIRT_QEMU) < 0)
goto cleanup;

@@ -3665,8 +3669,10 @@ virQEMUCapsLoadCache(virArch hostArch,
if (virQEMUCapsParseSEVInfo(qemuCaps, ctxt) < 0)
goto cleanup;

- virQEMUCapsInitHostCPUModel(qemuCaps, hostArch, VIR_DOMAIN_VIRT_KVM);
- virQEMUCapsInitHostCPUModel(qemuCaps, hostArch, VIR_DOMAIN_VIRT_HVF);
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM))
+ virQEMUCapsInitHostCPUModel(qemuCaps, hostArch, VIR_DOMAIN_VIRT_KVM);
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_HVF))
+ virQEMUCapsInitHostCPUModel(qemuCaps, hostArch, VIR_DOMAIN_VIRT_HVF);
virQEMUCapsInitHostCPUModel(qemuCaps, hostArch, VIR_DOMAIN_VIRT_QEMU);

ret = 0;
@@ -3845,12 +3851,16 @@ virQEMUCapsFormatCache(virQEMUCapsPtr qemuCaps)
virBufferAsprintf(&buf, "<arch>%s</arch>\n",
virArchToString(qemuCaps->arch));

- virQEMUCapsFormatHostCPUModelInfo(qemuCaps, &buf, VIR_DOMAIN_VIRT_KVM);
- virQEMUCapsFormatHostCPUModelInfo(qemuCaps, &buf, VIR_DOMAIN_VIRT_HVF);
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM))
+ virQEMUCapsFormatHostCPUModelInfo(qemuCaps, &buf, VIR_DOMAIN_VIRT_KVM);
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_HVF))
+ virQEMUCapsFormatHostCPUModelInfo(qemuCaps, &buf, VIR_DOMAIN_VIRT_HVF);
virQEMUCapsFormatHostCPUModelInfo(qemuCaps, &buf, VIR_DOMAIN_VIRT_QEMU);

- virQEMUCapsFormatCPUModels(qemuCaps, &buf, VIR_DOMAIN_VIRT_KVM);
- virQEMUCapsFormatCPUModels(qemuCaps, &buf, VIR_DOMAIN_VIRT_HVF);
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM))
+ virQEMUCapsFormatCPUModels(qemuCaps, &buf, VIR_DOMAIN_VIRT_KVM);
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_HVF))
+ virQEMUCapsFormatCPUModels(qemuCaps, &buf, VIR_DOMAIN_VIRT_HVF);
virQEMUCapsFormatCPUModels(qemuCaps, &buf, VIR_DOMAIN_VIRT_QEMU);

for (i = 0; i < qemuCaps->nmachineTypes; i++) {
@@ -4650,8 +4660,10 @@ virQEMUCapsNewForBinaryInternal(virArch hostArch,
qemuCaps->libvirtCtime = virGetSelfLastChanged();
qemuCaps->libvirtVersion = LIBVIR_VERSION_NUMBER;

- virQEMUCapsInitHostCPUModel(qemuCaps, hostArch, VIR_DOMAIN_VIRT_KVM);
- virQEMUCapsInitHostCPUModel(qemuCaps, hostArch, VIR_DOMAIN_VIRT_HVF);
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM))
+ virQEMUCapsInitHostCPUModel(qemuCaps, hostArch, VIR_DOMAIN_VIRT_KVM);
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_HVF))
+ virQEMUCapsInitHostCPUModel(qemuCaps, hostArch, VIR_DOMAIN_VIRT_HVF);
virQEMUCapsInitHostCPUModel(qemuCaps, hostArch, VIR_DOMAIN_VIRT_QEMU);

if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM)) {



but ideally the

if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM))

additions would be done in a separate patch to fix the pre-existing
mistake, separately from adding hvf support.

Regards,
Daniel

[Roman Bolshakov]

With more acceleration types, KVM should be used only in error messages
related to KVM.

Signed-off-by: Roman Bolshakov <***@yadro.com>
---
src/qemu/qemu_capabilities.c | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/qemu/qemu_capabilities.c b/src/qemu/qemu_capabilities.c
index 1a2a8c5b7a..cd78f936ab 100644
--- a/src/qemu/qemu_capabilities.c
+++ b/src/qemu/qemu_capabilities.c
@@ -4959,8 +4959,8 @@ virQEMUCapsCacheLookupDefault(virFileCachePtr cache,
if (virQEMUCapsTypeIsAccelerated(virttype) &&
!virQEMUCapsTypeIsAccelerated(capsType)) {
virReportError(VIR_ERR_INVALID_ARG,
- _("KVM is not supported by '%s' on this host"),
- binary);
+ _("the accel '%s' is not supported by '%s' on this host"),
+ virQEMUCapsAccelStr(virttype), binary);
goto cleanup;
}

[Roman Bolshakov]

The function should be used to check if qemu capabilities include a
hardware acceleration, i.e. QEMU accel is not TCG.

Signed-off-by: Roman Bolshakov <***@yadro.com>
---
src/qemu/qemu_capabilities.c | 12 +++++++++---
1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/src/qemu/qemu_capabilities.c b/src/qemu/qemu_capabilities.c
index eb3148038a..648e5bd585 100644
--- a/src/qemu/qemu_capabilities.c
+++ b/src/qemu/qemu_capabilities.c
@@ -636,6 +636,12 @@ virQEMUCapsTypeIsAccelerated(virDomainVirtType type)
return type == VIR_DOMAIN_VIRT_KVM;
}

+static bool
+virQEMUCapsHaveAccel(virQEMUCapsPtr qemuCaps)
+{
+ return virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM);
+}
+
/* Checks whether a domain with @guest arch can run natively on @host.
*/
bool
@@ -2365,7 +2371,7 @@ virQEMUCapsProbeQMPCPUDefinitions(virQEMUCapsPtr qemuCaps,
if (!(models = virQEMUCapsFetchCPUDefinitions(mon)))
return -1;

- if (tcg || !virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM))
+ if (tcg || !virQEMUCapsHaveAccel(qemuCaps))
qemuCaps->tcgCPUModels = models;
else
qemuCaps->accelCPUModels = models;
@@ -2391,7 +2397,7 @@ virQEMUCapsProbeQMPHostCPU(virQEMUCapsPtr qemuCaps,
if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_QUERY_CPU_MODEL_EXPANSION))
return 0;

- if (tcg || !virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM)) {
+ if (tcg || !virQEMUCapsHaveAccel(qemuCaps)) {
virtType = VIR_DOMAIN_VIRT_QEMU;
model = "max";
} else {
@@ -4495,7 +4501,7 @@ virQEMUCapsInitQMP(virQEMUCapsPtr qemuCaps,
if (virQEMUCapsInitQMPMonitor(qemuCaps, cmd->mon) < 0)
goto cleanup;

- if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM)) {
+ if (virQEMUCapsHaveAccel(qemuCaps)) {
virQEMUCapsInitQMPCommandAbort(cmd);
if ((rc = virQEMUCapsInitQMPCommandRun(cmd, true)) != 0) {
if (rc == 1)

[Roman Bolshakov]

Signed-off-by: Roman Bolshakov <***@yadro.com>
---
docs/schemas/domaincommon.rng | 1 +
1 file changed, 1 insertion(+)

diff --git a/docs/schemas/domaincommon.rng b/docs/schemas/domaincommon.rng
index 099a949cf8..2e1203f58e 100644
--- a/docs/schemas/domaincommon.rng
+++ b/docs/schemas/domaincommon.rng
@@ -213,6 +213,7 @@
<value>phyp</value>
<value>vz</value>
<value>bhyve</value>
+ <value>hvf</value>
</choice>
</attribute>
</define>

[Daniel P. Berrangé]

Post by Roman Bolshakov
---
docs/schemas/domaincommon.rng | 1 +
1 file changed, 1 insertion(+)
diff --git a/docs/schemas/domaincommon.rng b/docs/schemas/domaincommon.rng
index 099a949cf8..2e1203f58e 100644
--- a/docs/schemas/domaincommon.rng
+++ b/docs/schemas/domaincommon.rng
@@ -213,6 +213,7 @@
<value>phyp</value>
<value>vz</value>
<value>bhyve</value>
+ <value>hvf</value>
</choice>
</attribute>
</define>

This should be squashed into the first patch that adds the
config parameter in the code.

Also need a docs/formatdomain.html.in addition to mention
it.

Regards,
Daniel

[Roman Bolshakov]

The function is needed to support multiple accelerators without
cluttering codebase by conditionals.

At the first glance that might cause an issue related to the ordering
capabilities being checked on a system with many accelerators but in the
current code base it should be just fine because
virQEMUCapsGetHostCPUData is not interested in the exact type of
accelarator.

Signed-off-by: Roman Bolshakov <***@yadro.com>
---
src/qemu/qemu_capabilities.c | 16 +++++++++++-----
1 file changed, 11 insertions(+), 5 deletions(-)

diff --git a/src/qemu/qemu_capabilities.c b/src/qemu/qemu_capabilities.c
index 648e5bd585..02f05aef70 100644
--- a/src/qemu/qemu_capabilities.c
+++ b/src/qemu/qemu_capabilities.c
@@ -642,6 +642,15 @@ virQEMUCapsHaveAccel(virQEMUCapsPtr qemuCaps)
return virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM);
}

+static virDomainVirtType
+virQEMUCapsToVirtType(virQEMUCapsPtr qemuCaps)
+{
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM))
+ return VIR_DOMAIN_VIRT_KVM;
+ else
+ return VIR_DOMAIN_VIRT_QEMU;
+}
+
/* Checks whether a domain with @guest arch can run natively on @host.
*/
bool
@@ -2401,7 +2410,7 @@ virQEMUCapsProbeQMPHostCPU(virQEMUCapsPtr qemuCaps,
virtType = VIR_DOMAIN_VIRT_QEMU;
model = "max";
} else {
- virtType = VIR_DOMAIN_VIRT_KVM;
+ virtType = virQEMUCapsToVirtType(qemuCaps);
model = "host";
}

@@ -4935,10 +4944,7 @@ virQEMUCapsCacheLookupDefault(virFileCachePtr cache,
machine = virQEMUCapsGetPreferredMachine(qemuCaps);
}

- if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM))
- capsType = VIR_DOMAIN_VIRT_KVM;
- else
- capsType = VIR_DOMAIN_VIRT_QEMU;
+ capsType = virQEMUCapsToVirtType(qemuCaps);

if (virttype == VIR_DOMAIN_VIRT_NONE)
virttype = capsType;

[Roman Bolshakov]

QEMU supports Hypervisor.framework as hvf accel since 2.12.

Signed-off-by: Roman Bolshakov <***@yadro.com>
---
src/conf/domain_conf.c | 4 +++-
src/conf/domain_conf.h | 1 +
src/qemu/qemu_command.c | 4 ++++
3 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/src/conf/domain_conf.c b/src/conf/domain_conf.c
index e8e0adc819..e5995fc1c8 100644
--- a/src/conf/domain_conf.c
+++ b/src/conf/domain_conf.c
@@ -119,7 +119,8 @@ VIR_ENUM_IMPL(virDomainVirt, VIR_DOMAIN_VIRT_LAST,
"phyp",
"parallels",
"bhyve",
- "vz")
+ "vz",
+ "hvf")

VIR_ENUM_IMPL(virDomainOS, VIR_DOMAIN_OSTYPE_LAST,
"hvm",
@@ -14977,6 +14978,7 @@ virDomainVideoDefaultType(const virDomainDef *def)
case VIR_DOMAIN_VIRT_HYPERV:
case VIR_DOMAIN_VIRT_PHYP:
case VIR_DOMAIN_VIRT_NONE:
+ case VIR_DOMAIN_VIRT_HVF:
case VIR_DOMAIN_VIRT_LAST:
default:
return VIR_DOMAIN_VIDEO_TYPE_DEFAULT;
diff --git a/src/conf/domain_conf.h b/src/conf/domain_conf.h
index e30a4b2fe7..dac39539df 100644
--- a/src/conf/domain_conf.h
+++ b/src/conf/domain_conf.h
@@ -245,6 +245,7 @@ typedef enum {
VIR_DOMAIN_VIRT_PARALLELS,
VIR_DOMAIN_VIRT_BHYVE,
VIR_DOMAIN_VIRT_VZ,
+ VIR_DOMAIN_VIRT_HVF,

VIR_DOMAIN_VIRT_LAST
} virDomainVirtType;
diff --git a/src/qemu/qemu_command.c b/src/qemu/qemu_command.c
index 1ff593c657..9150c690e5 100644
--- a/src/qemu/qemu_command.c
+++ b/src/qemu/qemu_command.c
@@ -7130,6 +7130,10 @@ qemuBuildMachineCommandLine(virCommandPtr cmd,
virBufferAddLit(&buf, ",accel=kvm");
break;

+ case VIR_DOMAIN_VIRT_HVF:
+ virBufferAddLit(&buf, ",accel=hvf");
+ break;
+
case VIR_DOMAIN_VIRT_KQEMU:
case VIR_DOMAIN_VIRT_XEN:
case VIR_DOMAIN_VIRT_LXC:

[Daniel P. Berrangé]

Post by Roman Bolshakov
QEMU supports Hypervisor.framework as hvf accel since 2.12.
---
src/conf/domain_conf.c | 4 +++-
src/conf/domain_conf.h | 1 +
src/qemu/qemu_command.c | 4 ++++
3 files changed, 8 insertions(+), 1 deletion(-)
diff --git a/src/conf/domain_conf.c b/src/conf/domain_conf.c
index e8e0adc819..e5995fc1c8 100644
--- a/src/conf/domain_conf.c
+++ b/src/conf/domain_conf.c
@@ -119,7 +119,8 @@ VIR_ENUM_IMPL(virDomainVirt, VIR_DOMAIN_VIRT_LAST,
"phyp",
"parallels",
"bhyve",
- "vz")
+ "vz",
+ "hvf")
VIR_ENUM_IMPL(virDomainOS, VIR_DOMAIN_OSTYPE_LAST,
"hvm",
@@ -14977,6 +14978,7 @@ virDomainVideoDefaultType(const virDomainDef *def)
return VIR_DOMAIN_VIDEO_TYPE_DEFAULT;
diff --git a/src/conf/domain_conf.h b/src/conf/domain_conf.h
index e30a4b2fe7..dac39539df 100644
--- a/src/conf/domain_conf.h
+++ b/src/conf/domain_conf.h
@@ -245,6 +245,7 @@ typedef enum {
VIR_DOMAIN_VIRT_PARALLELS,
VIR_DOMAIN_VIRT_BHYVE,
VIR_DOMAIN_VIRT_VZ,
+ VIR_DOMAIN_VIRT_HVF,
VIR_DOMAIN_VIRT_LAST
} virDomainVirtType;
diff --git a/src/qemu/qemu_command.c b/src/qemu/qemu_command.c
index 1ff593c657..9150c690e5 100644
--- a/src/qemu/qemu_command.c
+++ b/src/qemu/qemu_command.c
@@ -7130,6 +7130,10 @@ qemuBuildMachineCommandLine(virCommandPtr cmd,
virBufferAddLit(&buf, ",accel=kvm");
break;
+ virBufferAddLit(&buf, ",accel=hvf");
+ break;
+

Should also add to tests/qemuxml2argvtest.c to illustrate the hvf
example.


Regards,
Daniel

[Roman Bolshakov]

There's no QMP command for querying if hvf is supported, therefore we
use sysctl interface that tells if Hypervisor.framwork works/available
on the host.

Signed-off-by: Roman Bolshakov <***@yadro.com>
---
src/qemu/qemu_capabilities.c | 28 ++++++++++++++++++++++++++++
1 file changed, 28 insertions(+)

diff --git a/src/qemu/qemu_capabilities.c b/src/qemu/qemu_capabilities.c
index 65cf5b5c03..8da0a8476b 100644
--- a/src/qemu/qemu_capabilities.c
+++ b/src/qemu/qemu_capabilities.c
@@ -54,6 +54,10 @@
#include <sys/wait.h>
#include <stdarg.h>
#include <sys/utsname.h>
+#ifdef __APPLE__
+#include <sys/types.h>
+#include <sys/sysctl.h>
+#endif

#define VIR_FROM_THIS VIR_FROM_QEMU

@@ -2577,6 +2581,27 @@ virQEMUCapsProbeQMPKVMState(virQEMUCapsPtr qemuCaps,
return 0;
}

+static int
+virQEMUCapsProbeHVF(virQEMUCapsPtr qemuCaps,
+ qemuMonitorPtr mon)
+{
+ (void)mon;
+ int hv_support = 0;
+#ifdef __APPLE__
+ size_t len = sizeof(hv_support);
+ if (sysctlbyname("kern.hv_support", &hv_support, &len, NULL, 0))
+ hv_support = 0;
+#endif
+
+ if (qemuCaps->version >= 2012000 &&
+ ARCH_IS_X86(qemuCaps->arch) &&
+ hv_support) {
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_HVF);
+ }
+
+ return 0;
+}
+
struct virQEMUCapsCommandLineProps {
const char *option;
const char *param;
@@ -4123,6 +4148,9 @@ virQEMUCapsInitQMPMonitor(virQEMUCapsPtr qemuCaps,
if (virQEMUCapsProbeQMPKVMState(qemuCaps, mon) < 0)
goto cleanup;

+ if (virQEMUCapsProbeHVF(qemuCaps, mon) < 0)
+ goto cleanup;
+
if (virQEMUCapsProbeQMPEvents(qemuCaps, mon) < 0)
goto cleanup;
if (virQEMUCapsProbeQMPDevices(qemuCaps, mon) < 0)

[Daniel P. Berrangé]

Post by Roman Bolshakov
There's no QMP command for querying if hvf is supported, therefore we
use sysctl interface that tells if Hypervisor.framwork works/available
on the host.
---
src/qemu/qemu_capabilities.c | 28 ++++++++++++++++++++++++++++
1 file changed, 28 insertions(+)
diff --git a/src/qemu/qemu_capabilities.c b/src/qemu/qemu_capabilities.c
index 65cf5b5c03..8da0a8476b 100644
--- a/src/qemu/qemu_capabilities.c
+++ b/src/qemu/qemu_capabilities.c
@@ -54,6 +54,10 @@
#include <sys/wait.h>
#include <stdarg.h>
#include <sys/utsname.h>
+#ifdef __APPLE__
+#include <sys/types.h>
+#include <sys/sysctl.h>
+#endif
#define VIR_FROM_THIS VIR_FROM_QEMU
@@ -2577,6 +2581,27 @@ virQEMUCapsProbeQMPKVMState(virQEMUCapsPtr qemuCaps,
return 0;
}
+static int
+virQEMUCapsProbeHVF(virQEMUCapsPtr qemuCaps,
+ qemuMonitorPtr mon)
+{
+ (void)mon;
+ int hv_support = 0;
+#ifdef __APPLE__

I think i'd prefer the ifdef to surround the entire
method, and then provide a separate impl that just
does 'return 0' for non-apple platforms, since none
of the code here is useful for non-apple

Post by Roman Bolshakov
+ size_t len = sizeof(hv_support);
+ if (sysctlbyname("kern.hv_support", &hv_support, &len, NULL, 0))
+ hv_support = 0;
+#endif
+
+ if (qemuCaps->version >= 2012000 &&
+ ARCH_IS_X86(qemuCaps->arch) &&
+ hv_support) {
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_HVF);
+ }
+
+ return 0;
+}

Regards,
Daniel

[Roman Bolshakov]

Signed-off-by: Roman Bolshakov <***@yadro.com>
---
src/qemu/qemu_capabilities.c | 11 +++++++++++
1 file changed, 11 insertions(+)

diff --git a/src/qemu/qemu_capabilities.c b/src/qemu/qemu_capabilities.c
index 8da0a8476b..b3bfe500e2 100644
--- a/src/qemu/qemu_capabilities.c
+++ b/src/qemu/qemu_capabilities.c
@@ -852,6 +852,17 @@ virQEMUCapsInitGuestFromBinary(virCapsPtr caps,
}
}

+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_HVF)) {
+ if (virCapabilitiesAddGuestDomain(guest,
+ VIR_DOMAIN_VIRT_HVF,
+ NULL,
+ NULL,
+ 0,
+ NULL) == NULL) {
+ goto cleanup;
+ }
+ }
+
if ((ARCH_IS_X86(guestarch) || guestarch == VIR_ARCH_AARCH64) &&
virCapabilitiesAddGuestFeature(guest, "acpi", true, true) == NULL) {
goto cleanup;

[Daniel P. Berrangé]

Post by Roman Bolshakov
---
src/qemu/qemu_capabilities.c | 11 +++++++++++
1 file changed, 11 insertions(+)

Reviewed-by: Daniel P. Berrangé <***@redhat.com>


Regards,
Daniel

[Roman Bolshakov]

QEMU supports a number of accelerators. It'd be good to have more
generic name for kvmCPUModels and kvmCPU.

Signed-off-by: Roman Bolshakov <***@yadro.com>
---
src/qemu/qemu_capabilities.c | 36 ++++++++++++++++++------------------
1 file changed, 18 insertions(+), 18 deletions(-)

diff --git a/src/qemu/qemu_capabilities.c b/src/qemu/qemu_capabilities.c
index b3bfe500e2..4dac040246 100644
--- a/src/qemu/qemu_capabilities.c
+++ b/src/qemu/qemu_capabilities.c
@@ -571,7 +571,7 @@ struct _virQEMUCaps {

virArch arch;

- virDomainCapsCPUModelsPtr kvmCPUModels;
+ virDomainCapsCPUModelsPtr accelCPUModels;
virDomainCapsCPUModelsPtr tcgCPUModels;

size_t nmachineTypes;
@@ -582,7 +582,7 @@ struct _virQEMUCaps {

virSEVCapability *sevCapabilities;

- virQEMUCapsHostCPUData kvmCPU;
+ virQEMUCapsHostCPUData accelCPU;
virQEMUCapsHostCPUData tcgCPU;
};

@@ -1546,9 +1546,9 @@ virQEMUCapsPtr virQEMUCapsNewCopy(virQEMUCapsPtr qemuCaps)

ret->arch = qemuCaps->arch;

- if (qemuCaps->kvmCPUModels) {
- ret->kvmCPUModels = virDomainCapsCPUModelsCopy(qemuCaps->kvmCPUModels);
- if (!ret->kvmCPUModels)
+ if (qemuCaps->accelCPUModels) {
+ ret->accelCPUModels = virDomainCapsCPUModelsCopy(qemuCaps->accelCPUModels);
+ if (!ret->accelCPUModels)
goto error;
}

@@ -1558,7 +1558,7 @@ virQEMUCapsPtr virQEMUCapsNewCopy(virQEMUCapsPtr qemuCaps)
goto error;
}

- if (virQEMUCapsHostCPUDataCopy(&ret->kvmCPU, &qemuCaps->kvmCPU) < 0 ||
+ if (virQEMUCapsHostCPUDataCopy(&ret->accelCPU, &qemuCaps->accelCPU) < 0 ||
virQEMUCapsHostCPUDataCopy(&ret->tcgCPU, &qemuCaps->tcgCPU) < 0)
goto error;

@@ -1605,7 +1605,7 @@ void virQEMUCapsDispose(void *obj)
}
VIR_FREE(qemuCaps->machineTypes);

- virObjectUnref(qemuCaps->kvmCPUModels);
+ virObjectUnref(qemuCaps->accelCPUModels);
virObjectUnref(qemuCaps->tcgCPUModels);

virBitmapFree(qemuCaps->flags);
@@ -1618,7 +1618,7 @@ void virQEMUCapsDispose(void *obj)

virSEVCapabilitiesFree(qemuCaps->sevCapabilities);

- virQEMUCapsHostCPUDataClear(&qemuCaps->kvmCPU);
+ virQEMUCapsHostCPUDataClear(&qemuCaps->accelCPU);
virQEMUCapsHostCPUDataClear(&qemuCaps->tcgCPU);
}

@@ -1772,8 +1772,8 @@ virQEMUCapsAddCPUDefinitions(virQEMUCapsPtr qemuCaps,
size_t i;
virDomainCapsCPUModelsPtr cpus = NULL;

- if (type == VIR_DOMAIN_VIRT_KVM && qemuCaps->kvmCPUModels)
- cpus = qemuCaps->kvmCPUModels;
+ if (type == VIR_DOMAIN_VIRT_KVM && qemuCaps->accelCPUModels)
+ cpus = qemuCaps->accelCPUModels;
else if (type == VIR_DOMAIN_VIRT_QEMU && qemuCaps->tcgCPUModels)
cpus = qemuCaps->tcgCPUModels;

@@ -1782,7 +1782,7 @@ virQEMUCapsAddCPUDefinitions(virQEMUCapsPtr qemuCaps,
return -1;

if (type == VIR_DOMAIN_VIRT_KVM)
- qemuCaps->kvmCPUModels = cpus;
+ qemuCaps->accelCPUModels = cpus;
else
qemuCaps->tcgCPUModels = cpus;
}
@@ -1801,7 +1801,7 @@ virQEMUCapsGetCPUDefinitions(virQEMUCapsPtr qemuCaps,
virDomainVirtType type)
{
if (type == VIR_DOMAIN_VIRT_KVM)
- return qemuCaps->kvmCPUModels;
+ return qemuCaps->accelCPUModels;
else
return qemuCaps->tcgCPUModels;
}
@@ -1812,7 +1812,7 @@ virQEMUCapsGetHostCPUData(virQEMUCapsPtr qemuCaps,
virDomainVirtType type)
{
if (type == VIR_DOMAIN_VIRT_KVM)
- return &qemuCaps->kvmCPU;
+ return &qemuCaps->accelCPU;
else
return &qemuCaps->tcgCPU;
}
@@ -1876,7 +1876,7 @@ virQEMUCapsIsCPUModeSupported(virQEMUCapsPtr qemuCaps,

case VIR_CPU_MODE_CUSTOM:
if (type == VIR_DOMAIN_VIRT_KVM)
- cpus = qemuCaps->kvmCPUModels;
+ cpus = qemuCaps->accelCPUModels;
else
cpus = qemuCaps->tcgCPUModels;
return cpus && cpus->nmodels > 0;
@@ -2363,7 +2363,7 @@ virQEMUCapsProbeQMPCPUDefinitions(virQEMUCapsPtr qemuCaps,
if (tcg || !virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM))
qemuCaps->tcgCPUModels = models;
else
- qemuCaps->kvmCPUModels = models;
+ qemuCaps->accelCPUModels = models;

return 0;
}
@@ -3204,7 +3204,7 @@ virQEMUCapsLoadCPUModels(virQEMUCapsPtr qemuCaps,
goto cleanup;

if (type == VIR_DOMAIN_VIRT_KVM)
- qemuCaps->kvmCPUModels = cpus;
+ qemuCaps->accelCPUModels = cpus;
else
qemuCaps->tcgCPUModels = cpus;

@@ -3679,7 +3679,7 @@ virQEMUCapsFormatCPUModels(virQEMUCapsPtr qemuCaps,

if (type == VIR_DOMAIN_VIRT_KVM) {
typeStr = "kvm";
- cpus = qemuCaps->kvmCPUModels;
+ cpus = qemuCaps->accelCPUModels;
} else {
typeStr = "tcg";
cpus = qemuCaps->tcgCPUModels;
@@ -5073,7 +5073,7 @@ virQEMUCapsFillDomainCPUCaps(virCapsPtr caps,
virDomainCapsCPUModelsPtr cpus;

if (domCaps->virttype == VIR_DOMAIN_VIRT_KVM)
- cpus = qemuCaps->kvmCPUModels;
+ cpus = qemuCaps->accelCPUModels;
else
cpus = qemuCaps->tcgCPUModels;

[Roman Bolshakov]

Signed-off-by: Roman Bolshakov <***@yadro.com>
---
docs/news.xml | 12 ++++++++++++
1 file changed, 12 insertions(+)

diff --git a/docs/news.xml b/docs/news.xml
index dc08c96352..81db0c9165 100644
--- a/docs/news.xml
+++ b/docs/news.xml
@@ -35,6 +35,18 @@
<libvirt>
<release version="v4.9.0" date="unreleased">
<section title="New features">
+ <change>
+ <summary>
+ qemu: Add hvf domain type for Hypervisor.framework
+ </summary>
+ <description>
+ QEMU introduced experimental support of Hypervisor.framework
+ since 2.12.
+
+ It's supported on machines with Intel VT-x feature set that includes
+ Extended Page Tables (EPT) and Unrestricted Mode since macOS 10.10.
+ </description>
+ </change>
</section>
<section title="Improvements">
</section>

[Roman Bolshakov]

conf: Define hvf domain type
qemu: Define hvf capability
qemu: Query hvf capability on macOS
qemu: Expose hvf domain type if hvf is supported
qemu: Rename kvmCPU to accelCPU
qemu: Introduce virQEMUCapsTypeIsAccelerated
qemu: Introduce virQEMUCapsHaveAccel
qemu: Introduce virQEMUCapsToVirtType
qemu: Introduce virQEMUCapsAccelStr
qemu: Make error message accel-agnostic
qemu: Correct CPU capabilities probing for hvf
schema: Add hvf domain type
news: Mention hvf domain type

After a rebase I broke the build in the patch 6. I'll fix it in v2.
And there's a redundant argument in patch 3. I can fix it too.

-
Roman

[Daniel P. Berrangé]

Post by Roman Bolshakov
---
src/qemu/qemu_capabilities.c | 1 +
src/qemu/qemu_capabilities.h | 1 +
2 files changed, 2 insertions(+)
diff --git a/src/qemu/qemu_capabilities.c b/src/qemu/qemu_capabilities.c
index e228f52ec0..65cf5b5c03 100644
--- a/src/qemu/qemu_capabilities.c
+++ b/src/qemu/qemu_capabilities.c
@@ -508,6 +508,7 @@ VIR_ENUM_IMPL(virQEMUCaps, QEMU_CAPS_LAST,
/* 315 */
"vfio-pci.display",
"blockdev",
+ "hvf",
);
diff --git a/src/qemu/qemu_capabilities.h b/src/qemu/qemu_capabilities.h
index 934620ed31..e61f1e78a9 100644
--- a/src/qemu/qemu_capabilities.h
+++ b/src/qemu/qemu_capabilities.h
@@ -492,6 +492,7 @@ typedef enum { /* virQEMUCapsFlags grouping marker for syntax-check */
/* 315 */
QEMU_CAPS_VFIO_PCI_DISPLAY, /* -device vfio-pci.display */
QEMU_CAPS_BLOCKDEV, /* -blockdev and blockdev-add are supported */
+ QEMU_CAPS_HVF, /* Whether Hypervisor.framework is available */
QEMU_CAPS_LAST /* this must always be the last item */
} virQEMUCapsFlags;

I expect this addition would have broken the 'make check' tests
for the capabilities, so they likely need an update.


Regards,
Daniel

[Roman Bolshakov]

Post by Daniel P. Berrangé

Post by Roman Bolshakov
---
src/qemu/qemu_capabilities.c | 1 +
src/qemu/qemu_capabilities.h | 1 +
2 files changed, 2 insertions(+)
diff --git a/src/qemu/qemu_capabilities.c b/src/qemu/qemu_capabilities.c
index e228f52ec0..65cf5b5c03 100644
--- a/src/qemu/qemu_capabilities.c
+++ b/src/qemu/qemu_capabilities.c
@@ -508,6 +508,7 @@ VIR_ENUM_IMPL(virQEMUCaps, QEMU_CAPS_LAST,
/* 315 */
"vfio-pci.display",
"blockdev",
+ "hvf",
);
diff --git a/src/qemu/qemu_capabilities.h b/src/qemu/qemu_capabilities.h
index 934620ed31..e61f1e78a9 100644
--- a/src/qemu/qemu_capabilities.h
+++ b/src/qemu/qemu_capabilities.h
@@ -492,6 +492,7 @@ typedef enum { /* virQEMUCapsFlags grouping marker for syntax-check */
/* 315 */
QEMU_CAPS_VFIO_PCI_DISPLAY, /* -device vfio-pci.display */
QEMU_CAPS_BLOCKDEV, /* -blockdev and blockdev-add are supported */
+ QEMU_CAPS_HVF, /* Whether Hypervisor.framework is available */
QEMU_CAPS_LAST /* this must always be the last item */
} virQEMUCapsFlags;

I expect this addition would have broken the 'make check' tests
for the capabilities, so they likely need an update.

Hi Daniel,

Indeed, that's true. It broke all but 4 capabilities tests on PATCH 11
(https://www.redhat.com/archives/libvir-list/2018-October/msg01098.html)
including the ones I didn't expect, like tests for s390x. I wonder what
could be the reason?

I have looked at the recent additions of capabilities. Most of them just
add a flag for related platform and that's it. That doesn't work for me
though. May be that's because I should add CPU definitions for hvf
domain type? Still, that doesn't explain how hvf cpu appeared in actual
output of s390x capabilities test:

<hostCPU type='hvf' model='z14-base' migratability='no'>

May be a cross-product of all domain types and all
CPUs is checked.

I've attached test log file.

The code can be checked out of hvf-domain branch in the repo:
https://github.com/roolebo/libvirt.git

--
Best regards,
Roman