arm: enable MTE for QEMU + kvm
v4 cover arm: enable MTE for QEMU + kvm
Here's another repost of my kvm/mte series; no substantial changes.
Changes v3->v4:
- rebase to current master
- tweak message when specifying "mte=on" for the virt machine for non-tcg
- added Thomas' ack for the qtests patch
Cornelia Huck (2):
arm/kvm: add support for MTE
qtests/arm: add some mte tests
docs/system/arm/cpu-features.rst | 21 +++++ hw/arm/virt.c | 2 +- target/arm/cpu.c | 18 ++--- target/arm/cpu.h | 1 + target/arm/cpu64.c | 133 +++++++++++++++++++++++++++++++ target/arm/internals.h | 1 + target/arm/kvm64.c | 5 ++ target/arm/kvm_arm.h | 12 +++ target/arm/monitor.c | 1 + tests/qtest/arm-cpu-features.c | 76 ++++++++++++++++++ 10 files changed, 257 insertions(+), 13 deletions(-)
Signature · 1 line
2.39.0
PATCH v4 1/2 arm/kvm: add support for MTE
Introduce a new cpu feature flag to control MTE support. To preserve backwards compatibility for tcg, MTE will continue to be enabled as long as tag memory has been provided.
If MTE has been enabled, we need to disable migration, as we do not yet have a way to migrate the tags as well. Therefore, MTE will stay off with KVM unless requested explicitly.
--- docs/system/arm/cpu-features.rst | 21 +++++ hw/arm/virt.c | 2 +- target/arm/cpu.c | 18 ++--- target/arm/cpu.h | 1 + target/arm/cpu64.c | 133 +++++++++++++++++++++++++++++++ target/arm/internals.h | 1 + target/arm/kvm64.c | 5 ++ target/arm/kvm_arm.h | 12 +++ target/arm/monitor.c | 1 + 9 files changed, 181 insertions(+), 13 deletions(-)
docs/system/arm/cpu-features.rst +21 -0
@@ -443,3 +443,24 @@ As with ``sve-default-vector-length``, if the default length is larger than the maximum vector length enabled, the actual vector length will be reduced. If this property is set to ``-1`` then the default vector length is set to the maximum possible length. + +MTE CPU Property +================ + +The ``mte`` property controls the Memory Tagging Extension. For TCG, it requires +presence of tag memory (which can be turned on for the ``virt`` machine via +``mte=on``). For KVM, it requires the ``KVM_CAP_ARM_MTE`` capability; until +proper migration support is implemented, enabling MTE will install a migration +blocker. + +If not specified explicitly via ``on`` or ``off``, MTE will be available +according to the following rules: + +* When TCG is used, MTE will be available iff tag memory is available; i.e. it + preserves the behaviour prior to introduction of the feature. + +* When KVM is used, MTE will default to off, so that migration will not + unintentionally be blocked. + +* Other accelerators currently don't support MTE. +
hw/arm/virt.c +1 -1
@@ -2136,7 +2136,7 @@ static void machvirt_init(MachineState *machine)if (vms->mte && (kvm_enabled () ||hvf_enabled ())) {error_report ("mach-virt: %s does not support providing " -"MTE to the guest CPU" , +"emulated MTE to the guest CPU" ,kvm_enabled () ?"KVM" :"HVF" );exit (1 ); }
target/arm/cpu.c +6 -12
@@ -1529,6 +1529,11 @@ void arm_cpu_finalize_features(ARMCPU *cpu, Error **errp)error_propagate (errp, local_err); return; } +arm_cpu_mte_finalize (cpu, &local_err); +if (local_err !=NULL ) { +error_propagate (errp, local_err); +return ; + } }#endif
@@ -1605,7 +1610,7 @@ static void arm_cpu_realizefn(DeviceState *dev, Error **errp) }if (cpu->tag_memory) {error_setg (errp, -"Cannot enable %s when guest CPUs has MTE enabled" , +"Cannot enable %s when guest CPUs has tag memory enabled" ,current_accel_name ());return ; }
@@ -1984,17 +1989,6 @@ static void arm_cpu_realizefn(DeviceState *dev, Error **errp) ID_PFR1, VIRTUALIZATION, 0); } -#ifndef CONFIG_USER_ONLY -if (cpu->tag_memory ==NULL &&cpu_isar_feature (aa64_mte, cpu)) { -/* -* Disable the MTE feature bits if we do not have tag-memory -* provided by the machine. -*/ - cpu->isar.id_aa64pfr1 = -FIELD_DP64 (cpu->isar.id_aa64pfr1,ID_AA64PFR1 ,MTE ,0 ); - } -#endif -if (tcg_enabled ()) {/* * Don't report the Statistical Profiling Extension in the ID
target/arm/cpu.h +1 -0
@@ -1038,6 +1038,7 @@ struct ArchCPU {bool prop_pauth;bool prop_pauth_impdef;bool prop_lpa2; +OnOffAuto prop_mte;/* DCZ blocksize, in log_2(words), ie low 4 bits of DCZID_EL0 */ uint32_t dcz_blocksize;
target/arm/cpu64.c +133 -0
157 lines not on this page · raw message
target/arm/internals.h +1 -0
@@ -1348,6 +1348,7 @@ void arm_cpu_sve_finalize(ARMCPU *cpu, Error **errp);void arm_cpu_sme_finalize (ARMCPU *cpu,Error **errp);void arm_cpu_pauth_finalize (ARMCPU *cpu,Error **errp);void arm_cpu_lpa2_finalize (ARMCPU *cpu,Error **errp); +void arm_cpu_mte_finalize (ARMCPU *cpu,Error **errp);#endif #ifdef CONFIG_USER_ONLY
target/arm/kvm64.c +5 -0
@@ -764,6 +764,11 @@ bool kvm_arm_steal_time_supported(void)return kvm_check_extension (kvm_state,KVM_CAP_STEAL_TIME ); } +bool kvm_arm_mte_supported (void ) +{ +return kvm_check_extension (kvm_state,KVM_CAP_ARM_MTE ); +} +QEMU_BUILD_BUG_ON (KVM_ARM64_SVE_VQ_MIN !=1 );uint32_t kvm_arm_sve_get_vls (CPUState *cs)
target/arm/kvm_arm.h +12 -0
@@ -305,6 +305,13 @@ bool kvm_arm_pmu_supported(void);*/ bool kvm_arm_sve_supported (void ); +/** +* kvm_arm_mte_supported: +* +* Returns: true if KVM can enable MTE, and false otherwise. +*/ +bool kvm_arm_mte_supported (void ); +/** * kvm_arm_get_max_vm_ipa_size: * @ms: Machine state handle
@@ -395,6 +402,11 @@ static inline bool kvm_arm_steal_time_supported(void)return false; } +static inline bool kvm_arm_mte_supported (void ) +{ +return false; +} +/* * These functions should never actually be called without KVM support. */
target/arm/monitor.c +1 -0
@@ -96,6 +96,7 @@ static const char *cpu_model_advertised_features[] = {"sve1408" ,"sve1536" ,"sve1664" ,"sve1792" ,"sve1920" ,"sve2048" ,"kvm-no-adjvtime" ,"kvm-steal-time" ,"pauth" ,"pauth-impdef" , +"mte" ,NULL };
Signature · 1 line
2.39.0
Re: [PATCH v4 1/2] arm/kvm: add support for MTE
Quoted 40 lines · Cornelia Huck
Introduce a new cpu feature flag to control MTE support. To preserve backwards compatibility for tcg, MTE will continue to be enabled as long as tag memory has been provided.
If MTE has been enabled, we need to disable migration, as we do not yet have a way to migrate the tags as well. Therefore, MTE will stay off with KVM unless requested explicitly.
Signed-off-by Cornelia Huck <[email protected]>--- docs/system/arm/cpu-features.rst | 21 +++++ hw/arm/virt.c | 2 +- target/arm/cpu.c | 18 ++--- target/arm/cpu.h | 1 + target/arm/cpu64.c | 133 +++++++++++++++++++++++++++++++ target/arm/internals.h | 1 + target/arm/kvm64.c | 5 ++ target/arm/kvm_arm.h | 12 +++ target/arm/monitor.c | 1 + 9 files changed, 181 insertions(+), 13 deletions(-)docs/system/arm/cpu-features.rst +10
-0@@ -443,3 +443,24 @@ As with ``sve-default-vector-length``, if the default length is larger than the maximum vector length enabled, the actual vector length will be reduced. If this property is set to ``-1`` then the default vector length is set to the maximum possible length. + +MTE CPU Property +================ + +The ``mte`` property controls the Memory Tagging Extension. For TCG, it requires +presence of tag memory (which can be turned on for the ``virt`` machine via +``mte=on``). For KVM, it requires the ``KVM_CAP_ARM_MTE`` capability; until +proper migration support is implemented, enabling MTE will install a migration +blocker. +
docs/system/arm/cpu-features.rst As with ``sve-default-vector-length``, if the default length is larger · line 465
Quoted 10 lines
docs/system/arm/cpu-features.rst +10
-0+If not specified explicitly via ``on`` or ``off``, MTE will be available +according to the following rules: + +* When TCG is used, MTE will be available iff tag memory is available; i.e. it + preserves the behaviour prior to introduction of the feature. + +* When KVM is used, MTE will default to off, so that migration will not + unintentionally be blocked. + +* Other accelerators currently don't support MTE.
Minor nits for the documentation:
we should expand out "if and only if" -- not everybody recognizes "iff", especially if they're not native English speakers or not mathematicians.
Should we write specifically that in a future QEMU version KVM might change to defaulting to "on if available" when migration support is implemented?
thanks
-- PMM
Re: [PATCH v4 1/2] arm/kvm: add support for MTE
Quoted 57 lines · * Peter Maydell ([email protected]) wrote:
Quoted 40 lines · Cornelia Huck
Introduce a new cpu feature flag to control MTE support. To preserve backwards compatibility for tcg, MTE will continue to be enabled as long as tag memory has been provided.
If MTE has been enabled, we need to disable migration, as we do not yet have a way to migrate the tags as well. Therefore, MTE will stay off with KVM unless requested explicitly.
Signed-off-by Cornelia Huck <[email protected]>--- docs/system/arm/cpu-features.rst | 21 +++++ hw/arm/virt.c | 2 +- target/arm/cpu.c | 18 ++--- target/arm/cpu.h | 1 + target/arm/cpu64.c | 133 +++++++++++++++++++++++++++++++ target/arm/internals.h | 1 + target/arm/kvm64.c | 5 ++ target/arm/kvm_arm.h | 12 +++ target/arm/monitor.c | 1 + 9 files changed, 181 insertions(+), 13 deletions(-)docs/system/arm/cpu-features.rst +10
-0@@ -443,3 +443,24 @@ As with ``sve-default-vector-length``, if the default length is larger than the maximum vector length enabled, the actual vector length will be reduced. If this property is set to ``-1`` then the default vector length is set to the maximum possible length. + +MTE CPU Property +================ + +The ``mte`` property controls the Memory Tagging Extension. For TCG, it requires +presence of tag memory (which can be turned on for the ``virt`` machine via +``mte=on``). For KVM, it requires the ``KVM_CAP_ARM_MTE`` capability; until +proper migration support is implemented, enabling MTE will install a migration +blocker. +docs/system/arm/cpu-features.rst As with ``sve-default-vector-length``, if the default length is larger · line 465
Quoted 10 lines
docs/system/arm/cpu-features.rst +10
-0+If not specified explicitly via ``on`` or ``off``, MTE will be available +according to the following rules: + +* When TCG is used, MTE will be available iff tag memory is available; i.e. it + preserves the behaviour prior to introduction of the feature. + +* When KVM is used, MTE will default to off, so that migration will not + unintentionally be blocked. + +* Other accelerators currently don't support MTE.Minor nits for the documentation:
we should expand out "if and only if" -- not everybody recognizes "iff", especially if they're not native English speakers or not mathematicians.
Quoted 3 lines
Should we write specifically that in a future QEMU version KVM might change to defaulting to "on if available" when migration support is implemented?
Please make sure if you do something like that, that the failure is obious; 'on if available' gets messy for things like libvirt and higher level tools detecting features that are available and machines they can migrate to.
Dave
Quoted 3 lines
thanks
-- PMM
Signature · 1 line
Dr. David Alan Gilbert / [email protected] / Manchester, UK
Re: [PATCH v4 1/2] arm/kvm: add support for MTE
Quoted 28 lines · Dr. David Alan Gilbert
Quoted 26 lines · * Peter Maydell ([email protected]) wrote:
Quoted 9 lines · Cornelia Huck
docs/system/arm/cpu-features.rst +9
-0+MTE CPU Property +================ + +The ``mte`` property controls the Memory Tagging Extension. For TCG, it requires +presence of tag memory (which can be turned on for the ``virt`` machine via +``mte=on``). For KVM, it requires the ``KVM_CAP_ARM_MTE`` capability; until +proper migration support is implemented, enabling MTE will install a migration +blocker. +docs/system/arm/cpu-features.rst As with ``sve-default-vector-length``, if the default length is larger · line 465
Quoted 10 lines
docs/system/arm/cpu-features.rst +10
-0+If not specified explicitly via ``on`` or ``off``, MTE will be available +according to the following rules: + +* When TCG is used, MTE will be available iff tag memory is available; i.e. it + preserves the behaviour prior to introduction of the feature. + +* When KVM is used, MTE will default to off, so that migration will not + unintentionally be blocked. + +* Other accelerators currently don't support MTE.Minor nits for the documentation:
we should expand out "if and only if" -- not everybody recognizes "iff", especially if they're not native English speakers or not mathematicians.
Quoted 8 lines
Quoted 3 lines
Should we write specifically that in a future QEMU version KVM might change to defaulting to "on if available" when migration support is implemented?
Please make sure if you do something like that, that the failure is obious; 'on if available' gets messy for things like libvirt and higher level tools detecting features that are available and machines they can migrate to.
If we have a plan for how this ought to work when we eventually implement migration support that's great and we should document it. My point is really "we should make sure we don't box ourselves into a set of defaults that we regret in the future, eg where TCG and KVM always have different defaults forever". If we don't have a plan for what the future is, then I'd rather we delayed adding MTE-without-migration-support until we've determined that plan.
Though the default for the CPU property is a bit moot, because at the machine level we only implement tag memory on the virt board, and there we disable it at the machine level (ie the machine property 'mte' defaults to 'false').
thanks
-- PMM
Re: [PATCH v4 1/2] arm/kvm: add support for MTE
Quoted 48 lines · * Peter Maydell ([email protected]) wrote:
Quoted 28 lines · Dr. David Alan Gilbert
Quoted 26 lines · * Peter Maydell ([email protected]) wrote:
Quoted 9 lines · Cornelia Huck
docs/system/arm/cpu-features.rst +9
-0+MTE CPU Property +================ + +The ``mte`` property controls the Memory Tagging Extension. For TCG, it requires +presence of tag memory (which can be turned on for the ``virt`` machine via +``mte=on``). For KVM, it requires the ``KVM_CAP_ARM_MTE`` capability; until +proper migration support is implemented, enabling MTE will install a migration +blocker. +docs/system/arm/cpu-features.rst As with ``sve-default-vector-length``, if the default length is larger · line 465
Quoted 10 lines
docs/system/arm/cpu-features.rst +10
-0+If not specified explicitly via ``on`` or ``off``, MTE will be available +according to the following rules: + +* When TCG is used, MTE will be available iff tag memory is available; i.e. it + preserves the behaviour prior to introduction of the feature. + +* When KVM is used, MTE will default to off, so that migration will not + unintentionally be blocked. + +* Other accelerators currently don't support MTE.Minor nits for the documentation:
we should expand out "if and only if" -- not everybody recognizes "iff", especially if they're not native English speakers or not mathematicians.Quoted 8 lines
Quoted 3 lines
Should we write specifically that in a future QEMU version KVM might change to defaulting to "on if available" when migration support is implemented?
Please make sure if you do something like that, that the failure is obious; 'on if available' gets messy for things like libvirt and higher level tools detecting features that are available and machines they can migrate to.
If we have a plan for how this ought to work when we eventually implement migration support that's great and we should document it. My point is really "we should make sure we don't box ourselves into a set of defaults that we regret in the future, eg where TCG and KVM always have different defaults forever". If we don't have a plan for what the future is, then I'd rather we delayed adding MTE-without-migration-support until we've determined that plan.
Quoted 4 lines
Though the default for the CPU property is a bit moot, because at the machine level we only implement tag memory on the virt board, and there we disable it at the machine level (ie the machine property 'mte' defaults to 'false').
Oh, if you're disabling it at the machine level that's fine; with versioned machine types the answer then is to turn it on at the machine level when it all works, and that keeps the old machine types with it off, and then VMs migrating with the old machine type don't get confused.
(Having said that, there are always odd rules around CPU flags and machine types and what libvirt thinks of them, but I'd ask a libvirt person (jdenemar) for more details if needed).
Dave
Quoted 3 lines
thanks
-- PMM
Signature · 1 line
Dr. David Alan Gilbert / [email protected] / Manchester, UK
Re: [PATCH v4 1/2] arm/kvm: add support for MTE
In reply to Dr. David Alan GilbertQuoted 58 lines · Dr. David Alan Gilbert
Quoted 57 lines · * Peter Maydell ([email protected]) wrote:
Quoted 40 lines · Cornelia Huck
Introduce a new cpu feature flag to control MTE support. To preserve backwards compatibility for tcg, MTE will continue to be enabled as long as tag memory has been provided.
If MTE has been enabled, we need to disable migration, as we do not yet have a way to migrate the tags as well. Therefore, MTE will stay off with KVM unless requested explicitly.
Signed-off-by Cornelia Huck <[email protected]>--- docs/system/arm/cpu-features.rst | 21 +++++ hw/arm/virt.c | 2 +- target/arm/cpu.c | 18 ++--- target/arm/cpu.h | 1 + target/arm/cpu64.c | 133 +++++++++++++++++++++++++++++++ target/arm/internals.h | 1 + target/arm/kvm64.c | 5 ++ target/arm/kvm_arm.h | 12 +++ target/arm/monitor.c | 1 + 9 files changed, 181 insertions(+), 13 deletions(-)docs/system/arm/cpu-features.rst +10
-0@@ -443,3 +443,24 @@ As with ``sve-default-vector-length``, if the default length is larger than the maximum vector length enabled, the actual vector length will be reduced. If this property is set to ``-1`` then the default vector length is set to the maximum possible length. + +MTE CPU Property +================ + +The ``mte`` property controls the Memory Tagging Extension. For TCG, it requires +presence of tag memory (which can be turned on for the ``virt`` machine via +``mte=on``). For KVM, it requires the ``KVM_CAP_ARM_MTE`` capability; until +proper migration support is implemented, enabling MTE will install a migration +blocker. +docs/system/arm/cpu-features.rst As with ``sve-default-vector-length``, if the default length is larger · line 465
Quoted 10 lines
docs/system/arm/cpu-features.rst +10
-0+If not specified explicitly via ``on`` or ``off``, MTE will be available +according to the following rules: + +* When TCG is used, MTE will be available iff tag memory is available; i.e. it + preserves the behaviour prior to introduction of the feature. + +* When KVM is used, MTE will default to off, so that migration will not + unintentionally be blocked. + +* Other accelerators currently don't support MTE.Minor nits for the documentation:
we should expand out "if and only if" -- not everybody recognizes "iff", especially if they're not native English speakers or not mathematicians.
Quoted 8 lines
Quoted 3 lines
Should we write specifically that in a future QEMU version KVM might change to defaulting to "on if available" when migration support is implemented?
Please make sure if you do something like that, that the failure is obious; 'on if available' gets messy for things like libvirt and higher level tools detecting features that are available and machines they can migrate to.
I guess we can just keep the door open but decline walking through it if we fail to come up with a good solution...
Re: [PATCH v4 1/2] arm/kvm: add support for MTE
Quoted 64 lines · * Cornelia Huck ([email protected]) wrote:
Quoted 62 lines · Dr. David Alan Gilbert
Quoted 60 lines · * Peter Maydell ([email protected]) wrote:
Quoted 40 lines · Cornelia Huck
Introduce a new cpu feature flag to control MTE support. To preserve backwards compatibility for tcg, MTE will continue to be enabled as long as tag memory has been provided.
If MTE has been enabled, we need to disable migration, as we do not yet have a way to migrate the tags as well. Therefore, MTE will stay off with KVM unless requested explicitly.
Signed-off-by Cornelia Huck <[email protected]>--- docs/system/arm/cpu-features.rst | 21 +++++ hw/arm/virt.c | 2 +- target/arm/cpu.c | 18 ++--- target/arm/cpu.h | 1 + target/arm/cpu64.c | 133 +++++++++++++++++++++++++++++++ target/arm/internals.h | 1 + target/arm/kvm64.c | 5 ++ target/arm/kvm_arm.h | 12 +++ target/arm/monitor.c | 1 + 9 files changed, 181 insertions(+), 13 deletions(-)docs/system/arm/cpu-features.rst +10
-0@@ -443,3 +443,24 @@ As with ``sve-default-vector-length``, if the default length is larger than the maximum vector length enabled, the actual vector length will be reduced. If this property is set to ``-1`` then the default vector length is set to the maximum possible length. + +MTE CPU Property +================ + +The ``mte`` property controls the Memory Tagging Extension. For TCG, it requires +presence of tag memory (which can be turned on for the ``virt`` machine via +``mte=on``). For KVM, it requires the ``KVM_CAP_ARM_MTE`` capability; until +proper migration support is implemented, enabling MTE will install a migration +blocker. +docs/system/arm/cpu-features.rst As with ``sve-default-vector-length``, if the default length is larger · line 465
Quoted 10 lines
docs/system/arm/cpu-features.rst +10
-0+If not specified explicitly via ``on`` or ``off``, MTE will be available +according to the following rules: + +* When TCG is used, MTE will be available iff tag memory is available; i.e. it + preserves the behaviour prior to introduction of the feature. + +* When KVM is used, MTE will default to off, so that migration will not + unintentionally be blocked. + +* Other accelerators currently don't support MTE.Minor nits for the documentation:
we should expand out "if and only if" -- not everybody recognizes "iff", especially if they're not native English speakers or not mathematicians.Should we write specifically that in a future QEMU version KVM might change to defaulting to "on if available" when migration support is implemented?
Quoted 7 lines
Quoted 4 lines
Please make sure if you do something like that, that the failure is obious; 'on if available' gets messy for things like libvirt and higher level tools detecting features that are available and machines they can migrate to.
I guess we can just keep the door open but decline walking through it if we fail to come up with a good solution...
Yeh; at least make sure that any migration failure gives an obvious message in the log.
Dave
Signature · 1 line
Dr. David Alan Gilbert / [email protected] / Manchester, UK
Re: [PATCH v4 1/2] arm/kvm: add support for MTE
In reply to Peter MaydellQuoted 48 lines · Peter Maydell
Quoted 47 lines · Cornelia Huck
Introduce a new cpu feature flag to control MTE support. To preserve backwards compatibility for tcg, MTE will continue to be enabled as long as tag memory has been provided.
If MTE has been enabled, we need to disable migration, as we do not yet have a way to migrate the tags as well. Therefore, MTE will stay off with KVM unless requested explicitly.
Signed-off-by Cornelia Huck <[email protected]>--- docs/system/arm/cpu-features.rst | 21 +++++ hw/arm/virt.c | 2 +- target/arm/cpu.c | 18 ++--- target/arm/cpu.h | 1 + target/arm/cpu64.c | 133 +++++++++++++++++++++++++++++++ target/arm/internals.h | 1 + target/arm/kvm64.c | 5 ++ target/arm/kvm_arm.h | 12 +++ target/arm/monitor.c | 1 + 9 files changed, 181 insertions(+), 13 deletions(-)docs/system/arm/cpu-features.rst +17
-0@@ -443,3 +443,24 @@ As with ``sve-default-vector-length``, if the default length is larger than the maximum vector length enabled, the actual vector length will be reduced. If this property is set to ``-1`` then the default vector length is set to the maximum possible length. + +MTE CPU Property +================ + +The ``mte`` property controls the Memory Tagging Extension. For TCG, it requires +presence of tag memory (which can be turned on for the ``virt`` machine via +``mte=on``). For KVM, it requires the ``KVM_CAP_ARM_MTE`` capability; until +proper migration support is implemented, enabling MTE will install a migration +blocker. + +If not specified explicitly via ``on`` or ``off``, MTE will be available +according to the following rules: + +* When TCG is used, MTE will be available iff tag memory is available; i.e. it + preserves the behaviour prior to introduction of the feature. + +* When KVM is used, MTE will default to off, so that migration will not
Quoted 8 lines
docs/system/arm/cpu-features.rst As with ``sve-default-vector-length``, if the default length is larger · line 465
Quoted 3 lines
docs/system/arm/cpu-features.rst +3
-0+ unintentionally be blocked. + +* Other accelerators currently don't support MTE.Minor nits for the documentation:
we should expand out "if and only if" -- not everybody recognizes "iff", especially if they're not native English speakers or not mathematicians.
Ok, will change that.
Quoted 4 lines
Should we write specifically that in a future QEMU version KVM might change to defaulting to "on if available" when migration support is implemented?
I can certainly add "Future QEMU versions might change that behaviour." We should be able to add compat handling for that.
Re: [PATCH v4 1/2] arm/kvm: add support for MTE
In reply to Cornelia Huckhw/arm/virt.c static void machvirt_init(MachineState *machine) · line 2140
Quoted 7 lines · Cornelia Huck
hw/arm/virt.c +1
-1@@ -2136,7 +2136,7 @@ static void machvirt_init(MachineState *machine)if (vms->mte && (kvm_enabled () ||hvf_enabled ())) {error_report ("mach-virt: %s does not support providing " -"MTE to the guest CPU" , +"emulated MTE to the guest CPU" ,kvm_enabled () ?"KVM" :"HVF" );
Not your bug, but noticing this should use current_accel_name().
Quoted 4 lines
target/arm/cpu64.c +4
-0+static inline bool arm_machine_has_tag_memory (void ) +{ +#ifndef CONFIG_USER_ONLY +Object *obj =object_dynamic_cast (qdev_get_machine (),TYPE_VIRT_MACHINE );
target/arm/cpu64.c static void aarch64_neoverse_n1_initfn(Object *obj) · line 1150
Quoted 10 lines
target/arm/cpu64.c +10
-0+ +/* so far, only the virt machine has support for tag memory */ +if (obj) { +VirtMachineState *vms =VIRT_MACHINE (obj); + +return vms->mte; + } +#endif +return false; +}
True for CONFIG_USER_ONLY, via page_get_target_data(). You should have seen check-tcg test failures...
target/arm/cpu64.c static void aarch64_neoverse_n1_initfn(Object *obj) · line 1161
Quoted 10 lines
target/arm/cpu64.c +10
-0+void arm_cpu_mte_finalize (ARMCPU *cpu,Error **errp) +{ +bool enable_mte; + +switch (cpu->prop_mte) { +case ON_OFF_AUTO_OFF : + enable_mte = false; +break ; +case ON_OFF_AUTO_ON : +if (!kvm_enabled ()) {
tcg_enabled(), here and everywhere else you test for !kvm.
target/arm/cpu64.c static void aarch64_neoverse_n1_initfn(Object *obj) · line 1173
Quoted 2 lines
target/arm/cpu64.c +2
-0+#ifdef CONFIG_KVM +if (kvm_enabled () && !kvm_arm_mte_supported ()) {
kvm_arm.h should get a stub inline returning false, so that the ifdef is removed. See e.g. kvm_arm_sve_supported().
target/arm/cpu64.c static void aarch64_neoverse_n1_initfn(Object *obj) · line 1181
Quoted 2 lines
target/arm/cpu64.c +2
-0+default :/* AUTO */ +if (!kvm_enabled ()) {
tcg_enabled.
target/arm/cpu64.c static void aarch64_neoverse_n1_initfn(Object *obj) · line 1213
Quoted 5 lines
target/arm/cpu64.c +5
-0+/* accelerator-specific enablement */ +if (kvm_enabled ()) { +#ifdef CONFIG_KVM +if (kvm_vm_enable_cap (kvm_state,KVM_CAP_ARM_MTE ,0 )) { +error_setg (errp,"Failed to enable KVM_CAP_ARM_MTE" );
Ideally this ifdef could go away as well.
target/arm/cpu64.c static void aarch64_neoverse_n1_initfn(Object *obj) · line 1216
Quoted 3 lines
target/arm/cpu64.c +3
-0+ }else { +/* TODO: add proper migration support with MTE enabled */ +if (!mte_migration_blocker) {
Move the global variable here, as a local static?
I guess this check is to avoid adding one blocker per cpu? I would guess the cap doesn't need enabling more than once either?
target/arm/cpu64.c static void aarch64_neoverse_n1_initfn(Object *obj) · line 1219
Quoted 3 lines
target/arm/cpu64.c +3
-0+error_setg (&mte_migration_blocker, +"Live migration disabled due to MTE enabled" ); +if (migrate_add_blocker (mte_migration_blocker,NULL )) {
You pass NULL to the migrate_add_blocker errp argument...
Quoted 1 line
+
error_setg(errp, "Failed to add MTE migration blocker");
... then make up your own generic reason for why it failed.
In this case it seems only related to another command-line option: --only-migratable.
Anyway, I wonder about hiding all of this in target/arm/kvm.c:
bool kvm_arm_enable_mte(Error *errp)
{
static bool once = false;
Error *blocker;
if (once) {
return;
}
once = true;
if (kvm_vm_enable_cap(kvm_state, KVM_CAP_ARM_MTE, 0)) {
error_setg_errno(errp, "Failed to enable KVM_CAP_ARM_MTE");
return false;
}
blocker = g_new0(Error);
error_setg(blocker, "Live migration disabled....");
return !migrate_add_blocker(blocker, errp);
}with
static inline bool kvm_arm_enable_mte(Error *errp)
{
g_assert_not_reached();
}in the !CONFIG_KVM block in kvm_arm.h.
Re: [PATCH v4 1/2] arm/kvm: add support for MTE
Quoted 10 lines · Richard Henderson
hw/arm/virt.c static void machvirt_init(MachineState *machine) · line 2140
Quoted 7 lines · Cornelia Huck
hw/arm/virt.c +1
-1@@ -2136,7 +2136,7 @@ static void machvirt_init(MachineState *machine)if (vms->mte && (kvm_enabled () ||hvf_enabled ())) {error_report ("mach-virt: %s does not support providing " -"MTE to the guest CPU" , +"emulated MTE to the guest CPU" ,kvm_enabled () ?"KVM" :"HVF" );Not your bug, but noticing this should use
current_accel_name().
I can fix it as I'm touching the code anyway.
(Hm... two more of these right above. Maybe better in a separate patch.)
Quoted 10 lines
Quoted 10 lines
target/arm/cpu64.c +9
-0+static inline bool arm_machine_has_tag_memory (void ) +{ +#ifndef CONFIG_USER_ONLY +Object *obj =object_dynamic_cast (qdev_get_machine (),TYPE_VIRT_MACHINE ); + +/* so far, only the virt machine has support for tag memory */ +if (obj) { +VirtMachineState *vms =VIRT_MACHINE (obj); +
Quoted 8 lines
target/arm/cpu64.c static void aarch64_neoverse_n1_initfn(Object *obj) · line 1150
Quoted 5 lines
target/arm/cpu64.c +5
-0+ return vms->mte; + } +#endif +return false; +}True for
CONFIG_USER_ONLY, viapage_get_target_data(). You should have seen check-tcg test failures...
Weird, let me check my setup...
Quoted 14 lines
target/arm/cpu64.c static void aarch64_neoverse_n1_initfn(Object *obj) · line 1161
Quoted 11 lines
target/arm/cpu64.c +10
-0+void arm_cpu_mte_finalize (ARMCPU *cpu,Error **errp) +{ +bool enable_mte; + +switch (cpu->prop_mte) { +case ON_OFF_AUTO_OFF : + enable_mte = false; +break ; +case ON_OFF_AUTO_ON : +if (!kvm_enabled ()) {
tcg_enabled(), here and everywhere else you test for !kvm.
Quoted 5 lines
target/arm/cpu64.c static void aarch64_neoverse_n1_initfn(Object *obj) · line 1173
Quoted 2 lines
target/arm/cpu64.c +2
-0+#ifdef CONFIG_KVM +if (kvm_enabled () && !kvm_arm_mte_supported ()) {
kvm_arm.hshould get a stub inline returning false, so that the ifdef is removed. See e.g.kvm_arm_sve_supported().
Oh, I actually did add it already...
Quoted 14 lines
target/arm/cpu64.c static void aarch64_neoverse_n1_initfn(Object *obj) · line 1181
Quoted 3 lines
target/arm/cpu64.c +2
-0+default :/* AUTO */ +if (!kvm_enabled ()) {
tcg_enabled.target/arm/cpu64.c static void aarch64_neoverse_n1_initfn(Object *obj) · line 1213
Quoted 5 lines
target/arm/cpu64.c +5
-0+/* accelerator-specific enablement */ +if (kvm_enabled ()) { +#ifdef CONFIG_KVM +if (kvm_vm_enable_cap (kvm_state,KVM_CAP_ARM_MTE ,0 )) { +error_setg (errp,"Failed to enable KVM_CAP_ARM_MTE" );Ideally this ifdef could go away as well.
Quoted 8 lines
target/arm/cpu64.c static void aarch64_neoverse_n1_initfn(Object *obj) · line 1216
Quoted 3 lines
target/arm/cpu64.c +3
-0+ }else { +/* TODO: add proper migration support with MTE enabled */ +if (!mte_migration_blocker) {Move the global variable here, as a local static?
I guess this check is to avoid adding one blocker per cpu? I would guess the cap doesn't need enabling more than once either?
Indeed, it's a VM cap. (I only tested this on a single-cpu FVP setup.)
Quoted 36 lines
target/arm/cpu64.c static void aarch64_neoverse_n1_initfn(Object *obj) · line 1219
Quoted 5 lines
target/arm/cpu64.c +3
-0+error_setg (&mte_migration_blocker, +"Live migration disabled due to MTE enabled" ); +if (migrate_add_blocker (mte_migration_blocker,NULL )) {You pass NULL to the
migrate_add_blockererrp argument...Quoted 1 line
+
error_setg(errp, "Failed to add MTE migration blocker");... then make up your own generic reason for why it failed.
In this case it seems only related to another command-line option: --only-migratable.Anyway, I wonder about hiding all of this in
target/arm/kvm.c:bool
kvm_arm_enable_mte(Error *errp){ static bool once = false; Error *blocker; if (once) { return; } once = true; if (kvm_vm_enable_cap(kvm_state, KVM_CAP_ARM_MTE, 0)) { error_setg_errno(errp, "Failed to enable KVM_CAP_ARM_MTE"); return false; } blocker = g_new0(Error); error_setg(blocker, "Live migration disabled...."); return !migrate_add_blocker(blocker, errp); }
Quoted 8 lines
with
static inline bool
kvm_arm_enable_mte(Error *errp){ g_assert_not_reached(); }in the !CONFIG_KVM block in
kvm_arm.h.
Good suggestion, I'll give that one a try.
Thanks for the feedback!
Re: [PATCH v4 1/2] arm/kvm: add support for MTE
In reply to Cornelia HuckHi Connie,
Quoted 5 lines · Cornelia Huck
Introduce a new cpu feature flag to control MTE support. To preserve backwards compatibility for tcg, MTE will continue to be enabled as long as tag memory has been provided.
If MTE has been enabled, we need to disable migration, as we do not
this only applies to KVM acceleration
Quoted 23 lines
yet have a way to migrate the tags as well. Therefore, MTE will stay off with KVM unless requested explicitly.
Signed-off-by Cornelia Huck <[email protected]>--- docs/system/arm/cpu-features.rst | 21 +++++ hw/arm/virt.c | 2 +- target/arm/cpu.c | 18 ++--- target/arm/cpu.h | 1 + target/arm/cpu64.c | 133 +++++++++++++++++++++++++++++++ target/arm/internals.h | 1 + target/arm/kvm64.c | 5 ++ target/arm/kvm_arm.h | 12 +++ target/arm/monitor.c | 1 + 9 files changed, 181 insertions(+), 13 deletions(-)docs/system/arm/cpu-features.rst +0
-0@@ -443,3 +443,24 @@ As with ``sve-default-vector-length``, if the default length is larger than the maximum vector length enabled, the actual vector length will be reduced. If this property is set to ``-1`` then the default vector
docs/system/arm/cpu-features.rst As with ``sve-default-vector-length``, if the default length is larger · line 454
Quoted 10 lines
docs/system/arm/cpu-features.rst +9
-0length is set to the maximum possible length. + +MTE CPU Property +================ + +The ``mte`` property controls the Memory Tagging Extension. For TCG, it requires +presence of tag memory (which can be turned on for the ``virt`` machine via +``mte=on``). For KVM, it requires the ``KVM_CAP_ARM_MTE`` capability; until +proper migration support is implemented, enabling MTE will install a migration +blocker.
maybe re-emphasize: when KVM is enabled
docs/system/arm/cpu-features.rst As with ``sve-default-vector-length``, if the default length is larger · line 459
Quoted 5 lines
docs/system/arm/cpu-features.rst +5
-0+ +If not specified explicitly via ``on`` or ``off``, MTE will be available +according to the following rules: + +* When TCG is used, MTE will be available iff tag memory is available; i.e. it
suggestion: is available at machine level
docs/system/arm/cpu-features.rst As with ``sve-default-vector-length``, if the default length is larger · line 460
Quoted 1 line
docs/system/arm/cpu-features.rst +1
-0+ preserves the behaviour prior to introduction of the feature.
s/prior to/prior to the ?
Quoted 11 lines
docs/system/arm/cpu-features.rst +6
-0+ +* When KVM is used, MTE will default to off, so that migration will not + unintentionally be blocked. + +* Other accelerators currently don't support MTE. +hw/arm/virt.c +0
-0
hw/arm/virt.c static void machvirt_init(MachineState *machine) · line 2139
Quoted 5 lines
hw/arm/virt.c +1
-1@@ -2136,7 +2136,7 @@ static void machvirt_init(MachineState *machine)if (vms->mte && (kvm_enabled () ||hvf_enabled ())) { error_report("mach-virt: %s does not support providing " - "MTE to the guest CPU", + "emulated MTE to the guest CPU",
each time I read this message I feel difficult to understand it. Why not replacing by
"mach-virt does not support tag memory with %s acceleration" or something alike?
Quoted 86 lines
hw/arm/virt.c +0
-0kvm_enabled() ? "KVM" : "HVF");exit (1 ); }target/arm/cpu.c +6
-12@@ -1529,6 +1529,11 @@ void arm_cpu_finalize_features(ARMCPU *cpu, Error **errp)error_propagate (errp, local_err); return; } +arm_cpu_mte_finalize (cpu, &local_err); +if (local_err !=NULL ) { +error_propagate (errp, local_err); +return ; + } }#endif @@ -1605,7 +1610,7 @@ static void arm_cpu_realizefn(DeviceState *dev, Error **errp) }if (cpu->tag_memory) {error_setg (errp, -"Cannot enable %s when guest CPUs has MTE enabled" , +"Cannot enable %s when guest CPUs has tag memory enabled" ,current_accel_name ());return ; }@@ -1984,17 +1989,6 @@ static void arm_cpu_realizefn(DeviceState *dev, Error **errp) ID_PFR1, VIRTUALIZATION, 0); } -#ifndef CONFIG_USER_ONLY -if (cpu->tag_memory ==NULL &&cpu_isar_feature (aa64_mte, cpu)) { -/* -* Disable the MTE feature bits if we do not have tag-memory -* provided by the machine. -*/ - cpu->isar.id_aa64pfr1 = -FIELD_DP64 (cpu->isar.id_aa64pfr1,ID_AA64PFR1 ,MTE ,0 ); - } -#endif -if (tcg_enabled ()) {/* * Don't report the Statistical Profiling Extension in the ID target/arm/cpu.h +1
-0@@ -1038,6 +1038,7 @@ struct ArchCPU {bool prop_pauth;bool prop_pauth_impdef;bool prop_lpa2; +OnOffAuto prop_mte;/* DCZ blocksize, in log_2(words), ie low 4 bits of DCZID_EL0 */ uint32_t dcz_blocksize;target/arm/cpu64.c +13
-0@@ -29,6 +29,13 @@#include "qapi/visitor.h" #include "hw/qdev-properties.h" #include "internals.h" +#include "migration/blocker.h" +#include "qapi/qapi-visit-common.h" +#include "hw/arm/virt.h" + +#ifdef CONFIG_KVM +static Error *mte_migration_blocker; +#endif static void aarch64_a35_initfn (Object *obj) {@@ -1096,6 +1103,130 @@ static void aarch64_neoverse_n1_initfn(Object *obj) cpu->isar.reset_pmcr_el0 =0x410c3000 ; } +static void aarch64_cpu_get_mte (Object *obj,Visitor *v,const char *name, +void *opaque,Error **errp) +{ +ARMCPU *cpu =ARM_CPU (obj); +OnOffAuto mte = cpu->prop_mte; +
target/arm/cpu64.c static void aarch64_neoverse_n1_initfn(Object *obj) · line 1121
Quoted 10 lines
target/arm/cpu64.c +10
-0+visit_type_OnOffAuto (v, name, &mte, errp); +} + +static void aarch64_cpu_set_mte (Object *obj,Visitor *v,const char *name, +void *opaque,Error **errp) +{ +ARMCPU *cpu =ARM_CPU (obj); + +visit_type_OnOffAuto (v, name, &cpu->prop_mte, errp); +
nit: spare void line
Quoted 37 lines
target/arm/cpu64.c +37
-0+} + +static void aarch64_add_mte_properties (Object *obj) +{ +/* +* For tcg, "AUTO" means turn on mte if tag memory has been provided, and +* turn it off (without error) if not. +* For kvm, "AUTO" currently means mte off, as migration is not supported +* yet. +* For all others, "AUTO" means mte off. +*/ +object_property_add (obj,"mte" ,"OnOffAuto" , aarch64_cpu_get_mte, + aarch64_cpu_set_mte,NULL ,NULL ); +} + +static inline bool arm_machine_has_tag_memory (void ) +{ +#ifndef CONFIG_USER_ONLY +Object *obj =object_dynamic_cast (qdev_get_machine (),TYPE_VIRT_MACHINE ); + +/* so far, only the virt machine has support for tag memory */ +if (obj) { +VirtMachineState *vms =VIRT_MACHINE (obj); + +return vms->mte; + } +#endif +return false; +} + +void arm_cpu_mte_finalize (ARMCPU *cpu,Error **errp) +{ +bool enable_mte; + +switch (cpu->prop_mte) { +case ON_OFF_AUTO_OFF : + enable_mte = false;
target/arm/cpu64.c static void aarch64_neoverse_n1_initfn(Object *obj) · line 1168
Quoted 10 lines
target/arm/cpu64.c +10
-0+break ; +case ON_OFF_AUTO_ON : +if (!kvm_enabled ()) { +if (cpu_isar_feature (aa64_mte, cpu)) { +if (!arm_machine_has_tag_memory ()) { +error_setg (errp,"mte=on requires tag memory" ); +return ; + } + }else { +error_setg (errp,"mte not provided" );
mte not supported by this CPU type?
target/arm/cpu64.c static void aarch64_neoverse_n1_initfn(Object *obj) · line 1173
Quoted 5 lines
target/arm/cpu64.c +5
-0+return ; + } + } +#ifdef CONFIG_KVM +if (kvm_enabled () && !kvm_arm_mte_supported ()) {
as you have stubs for both, is the #ifdef needed?
Quoted 30 lines
target/arm/cpu64.c +30
-0+error_setg (errp,"mte not supported by kvm" ); + return; + } +#endif + enable_mte = true; +break ; +default :/* AUTO */ +if (!kvm_enabled ()) { +if (cpu_isar_feature (aa64_mte, cpu)) { +/* +* Tie mte enablement to presence of tag memory, in order to +* preserve pre-existing behaviour. +*/ + enable_mte =arm_machine_has_tag_memory (); + }else { + enable_mte = false; + } +break ; + }else { +/* +* This cannot yet be +* enable_mte = kvm_arm_mte_supported(); +* as we don't support migration yet. +*/ + enable_mte = false; + } + } + +if (!enable_mte) { +/* Disable MTE feature bits. */
target/arm/cpu64.c static void aarch64_neoverse_n1_initfn(Object *obj) · line 1213
Quoted 10 lines
target/arm/cpu64.c +10
-0+ cpu->isar.id_aa64pfr1 = +FIELD_DP64 (cpu->isar.id_aa64pfr1,ID_AA64PFR1 ,MTE ,0 ); +return ; + } + +/* accelerator-specific enablement */ +if (kvm_enabled ()) { +#ifdef CONFIG_KVM +if (kvm_vm_enable_cap (kvm_state,KVM_CAP_ARM_MTE ,0 )) { +error_setg (errp,"Failed to enable KVM_CAP_ARM_MTE" );
nit: return and remove the else?
target/arm/cpu64.c static void aarch64_neoverse_n1_initfn(Object *obj) · line 1219
Quoted 6 lines
target/arm/cpu64.c +6
-0+ }else { +/* TODO: add proper migration support with MTE enabled */ +if (!mte_migration_blocker) { +error_setg (&mte_migration_blocker, +"Live migration disabled due to MTE enabled" ); +if (migrate_add_blocker (mte_migration_blocker,NULL )) {
Can't you pass the erro directly to migrate_add_blocker. Also in arm_gicv3_its_kvm.c or virtio-gpu-pci, < 0 is checked. Maybe worth to double check the rationale.
Quoted 92 lines
target/arm/cpu64.c +12
-0+error_setg (errp,"Failed to add MTE migration blocker" ); +error_free (mte_migration_blocker); + mte_migration_blocker = NULL; + } + } + } +#endif + } +} +static void aarch64_host_initfn (Object *obj) {#if defined(CONFIG_KVM )@@ -1104,6 +1235,7 @@ static void aarch64_host_initfn(Object *obj)if (arm_feature (&cpu->env,ARM_FEATURE_AARCH64 )) {aarch64_add_sve_properties (obj);aarch64_add_pauth_properties (obj); +aarch64_add_mte_properties (obj); }#elif defined(CONFIG_HVF )ARMCPU *cpu =ARM_CPU (obj);@@ -1300,6 +1432,7 @@ static void aarch64_max_initfn(Object *obj)object_property_add (obj,"sve-max-vq" ,"uint32" , cpu_max_get_sve_max_vq, cpu_max_set_sve_max_vq,NULL ,NULL );qdev_property_add_static (DEVICE (obj), &arm_cpu_lpa2_property); +aarch64_add_mte_properties (obj); }static const ARMCPUInfo aarch64_cpus[] = {target/arm/internals.h +1
-0@@ -1348,6 +1348,7 @@ void arm_cpu_sve_finalize(ARMCPU *cpu, Error **errp);void arm_cpu_sme_finalize (ARMCPU *cpu,Error **errp);void arm_cpu_pauth_finalize (ARMCPU *cpu,Error **errp);void arm_cpu_lpa2_finalize (ARMCPU *cpu,Error **errp); +void arm_cpu_mte_finalize (ARMCPU *cpu,Error **errp);#endif #ifdef CONFIG_USER_ONLY target/arm/kvm64.c +5
-0@@ -764,6 +764,11 @@ bool kvm_arm_steal_time_supported(void)return kvm_check_extension (kvm_state,KVM_CAP_STEAL_TIME ); } +bool kvm_arm_mte_supported (void ) +{ +return kvm_check_extension (kvm_state,KVM_CAP_ARM_MTE ); +} +QEMU_BUILD_BUG_ON (KVM_ARM64_SVE_VQ_MIN !=1 );uint32_t kvm_arm_sve_get_vls (CPUState *cs)target/arm/kvm_arm.h +12
-0@@ -305,6 +305,13 @@ bool kvm_arm_pmu_supported(void);*/ bool kvm_arm_sve_supported (void ); +/** +* kvm_arm_mte_supported: +* +* Returns: true if KVM can enable MTE, and false otherwise. +*/ +bool kvm_arm_mte_supported (void ); +/** * kvm_arm_get_max_vm_ipa_size: * @ms: Machine state handle @@ -395,6 +402,11 @@ static inline bool kvm_arm_steal_time_supported(void)return false; } +static inline bool kvm_arm_mte_supported (void ) +{ +return false; +} +/* * These functions should never actually be called without KVM support. */ target/arm/monitor.c +0
-0
target/arm/monitor.c static const char *cpu_model_advertised_features[] = { · line 102
Quoted 7 lines
target/arm/monitor.c +1
-0@@ -96,6 +96,7 @@ static const char *cpu_model_advertised_features[] = {"sve1408" ,"sve1536" ,"sve1664" ,"sve1792" ,"sve1920" ,"sve2048" ,"kvm-no-adjvtime" ,"kvm-steal-time" ,"pauth" ,"pauth-impdef" , +"mte" ,NULL };
Thanks
Eric
Re: [PATCH v4 1/2] arm/kvm: add support for MTE
Quoted 8 lines · Eric Auger
Hi Connie,
Quoted 5 lines · Cornelia Huck
Introduce a new cpu feature flag to control MTE support. To preserve backwards compatibility for tcg, MTE will continue to be enabled as long as tag memory has been provided.
If MTE has been enabled, we need to disable migration, as we do not
this only applies to KVM acceleration
"If MTE has been enabled with KVM," ...
Quoted 26 lines
Quoted 26 lines
yet have a way to migrate the tags as well. Therefore, MTE will stay off with KVM unless requested explicitly.
Signed-off-by Cornelia Huck <[email protected]>--- docs/system/arm/cpu-features.rst | 21 +++++ hw/arm/virt.c | 2 +- target/arm/cpu.c | 18 ++--- target/arm/cpu.h | 1 + target/arm/cpu64.c | 133 +++++++++++++++++++++++++++++++ target/arm/internals.h | 1 + target/arm/kvm64.c | 5 ++ target/arm/kvm_arm.h | 12 +++ target/arm/monitor.c | 1 + 9 files changed, 181 insertions(+), 13 deletions(-)docs/system/arm/cpu-features.rst +2
-0@@ -443,3 +443,24 @@ As with ``sve-default-vector-length``, if the default length is larger than the maximum vector length enabled, the actual vector length will be reduced. If this property is set to ``-1`` then the default vector length is set to the maximum possible length. + +MTE CPU Property
Quoted 8 lines
docs/system/arm/cpu-features.rst As with ``sve-default-vector-length``, if the default length is larger · line 454
Quoted 7 lines
docs/system/arm/cpu-features.rst +7
-0+================ + +The ``mte`` property controls the Memory Tagging Extension. For TCG, it requires +presence of tag memory (which can be turned on for the ``virt`` machine via +``mte=on``). For KVM, it requires the ``KVM_CAP_ARM_MTE`` capability; until +proper migration support is implemented, enabling MTE will install a migration +blocker.maybe re-emphasize: when KVM is enabled
I think it's explicit enough, since it is in the "For KVM" phrase?
Quoted 6 lines
docs/system/arm/cpu-features.rst As with ``sve-default-vector-length``, if the default length is larger · line 459
Quoted 5 lines
docs/system/arm/cpu-features.rst +5
-0+ +If not specified explicitly via ``on`` or ``off``, MTE will be available +according to the following rules: + +* When TCG is used, MTE will be available iff tag memory is available; i.e. itsuggestion: is available at machine level
It's only configured at machine level, not sure if that clarifies anything?
Quoted 2 lines
docs/system/arm/cpu-features.rst As with ``sve-default-vector-length``, if the default length is larger · line 460
Quoted 1 line
docs/system/arm/cpu-features.rst +1
-0+ preserves the behaviour prior to introduction of the feature.s/prior to/prior to the ?
ok
Quoted 12 lines
Quoted 12 lines
docs/system/arm/cpu-features.rst +6
-0+ +* When KVM is used, MTE will default to off, so that migration will not + unintentionally be blocked. + +* Other accelerators currently don't support MTE. +hw/arm/virt.c +0
-0@@ -2136,7 +2136,7 @@ static void machvirt_init(MachineState *machine)
Quoted 8 lines
hw/arm/virt.c static void machvirt_init(MachineState *machine) · line 2139
Quoted 4 lines
hw/arm/virt.c +1
-1if (vms->mte && (kvm_enabled () ||hvf_enabled ())) { error_report("mach-virt: %s does not support providing " - "MTE to the guest CPU", + "emulated MTE to the guest CPU",each time I read this message I feel difficult to understand it. Why not replacing by
"mach-virt does not support tag memory with %s acceleration" or something alike?
Hmm... well, it does not support tag memory with kvm/hvf, and the consequence of this is that kvm/hvf cannot provide support for emulated mte... what about
"mach-virt: tag memory not supported with %s, emulated MTE cannot be provided to the guest CPU"
Might be a bit long, though.
Quoted 3 lines
Quoted 3 lines
hw/arm/virt.c +0
-0kvm_enabled() ? "KVM" : "HVF");exit (1 ); }
(...)
Quoted 8 lines
hw/arm/virt.c
Quoted 7 lines
hw/arm/virt.c +7
-0+static void aarch64_cpu_set_mte (Object *obj,Visitor *v,const char *name, +void *opaque,Error **errp) +{ +ARMCPU *cpu =ARM_CPU (obj); + +visit_type_OnOffAuto (v, name, &cpu->prop_mte, errp); +nit: spare void line
will drop
Quoted 40 lines
Quoted 40 lines
hw/arm/virt.c +40
-0+} + +static void aarch64_add_mte_properties (Object *obj) +{ +/* +* For tcg, "AUTO" means turn on mte if tag memory has been provided, and +* turn it off (without error) if not. +* For kvm, "AUTO" currently means mte off, as migration is not supported +* yet. +* For all others, "AUTO" means mte off. +*/ +object_property_add (obj,"mte" ,"OnOffAuto" , aarch64_cpu_get_mte, + aarch64_cpu_set_mte,NULL ,NULL ); +} + +static inline bool arm_machine_has_tag_memory (void ) +{ +#ifndef CONFIG_USER_ONLY +Object *obj =object_dynamic_cast (qdev_get_machine (),TYPE_VIRT_MACHINE ); + +/* so far, only the virt machine has support for tag memory */ +if (obj) { +VirtMachineState *vms =VIRT_MACHINE (obj); + +return vms->mte; + } +#endif +return false; +} + +void arm_cpu_mte_finalize (ARMCPU *cpu,Error **errp) +{ +bool enable_mte; + +switch (cpu->prop_mte) { +case ON_OFF_AUTO_OFF : + enable_mte = false; +break ; +case ON_OFF_AUTO_ON : +if (!kvm_enabled ()) {
Quoted 8 lines
hw/arm/virt.c
Quoted 7 lines
hw/arm/virt.c +7
-0+if (cpu_isar_feature (aa64_mte, cpu)) { +if (!arm_machine_has_tag_memory ()) { +error_setg (errp,"mte=on requires tag memory" ); +return ; + } + }else { +error_setg (errp,"mte not provided" );mte not supported by this CPU type?
yes, probably better
Quoted 6 lines
hw/arm/virt.c
Quoted 5 lines
hw/arm/virt.c +5
-0+return ; + } + } +#ifdef CONFIG_KVM +if (kvm_enabled () && !kvm_arm_mte_supported ()) {as you have stubs for both, is the #ifdef needed?
see prior discussion :) Doesn't look like it.
Quoted 33 lines
Quoted 33 lines
hw/arm/virt.c +33
-0+error_setg (errp,"mte not supported by kvm" ); + return; + } +#endif + enable_mte = true; +break ; +default :/* AUTO */ +if (!kvm_enabled ()) { +if (cpu_isar_feature (aa64_mte, cpu)) { +/* +* Tie mte enablement to presence of tag memory, in order to +* preserve pre-existing behaviour. +*/ + enable_mte =arm_machine_has_tag_memory (); + }else { + enable_mte = false; + } +break ; + }else { +/* +* This cannot yet be +* enable_mte = kvm_arm_mte_supported(); +* as we don't support migration yet. +*/ + enable_mte = false; + } + } + +if (!enable_mte) { +/* Disable MTE feature bits. */ + cpu->isar.id_aa64pfr1 = +FIELD_DP64 (cpu->isar.id_aa64pfr1,ID_AA64PFR1 ,MTE ,0 ); +return ;
Quoted 8 lines
hw/arm/virt.c
Quoted 7 lines
hw/arm/virt.c +7
-0+ } + +/* accelerator-specific enablement */ +if (kvm_enabled ()) { +#ifdef CONFIG_KVM +if (kvm_vm_enable_cap (kvm_state,KVM_CAP_ARM_MTE ,0 )) { +error_setg (errp,"Failed to enable KVM_CAP_ARM_MTE" );nit: return and remove the else?
I've reworked that anyway (no need to enable a vm cap for every cpu.)
Quoted 9 lines
hw/arm/virt.c
Quoted 6 lines
hw/arm/virt.c +6
-0+ }else { +/* TODO: add proper migration support with MTE enabled */ +if (!mte_migration_blocker) { +error_setg (&mte_migration_blocker, +"Live migration disabled due to MTE enabled" ); +if (migrate_add_blocker (mte_migration_blocker,NULL )) {Can't you pass the erro directly to
migrate_add_blocker. Also inarm_gicv3_its_kvm.cor virtio-gpu-pci, < 0 is checked. Maybe worth to double check the rationale.
I've rewritten that in the meanwhile as well :)
Quoted 9 lines
Quoted 9 lines
hw/arm/virt.c +9
-0+error_setg (errp,"Failed to add MTE migration blocker" ); +error_free (mte_migration_blocker); + mte_migration_blocker = NULL; + } + } + } +#endif + } +}
Re: [PATCH v4 1/2] arm/kvm: add support for MTE
Quoted 13 lines · Cornelia Huck
Quoted 10 lines · Eric Auger
Hi Connie,
hw/arm/virt.c static void machvirt_init(MachineState *machine) · line 2139
Quoted 4 lines · Cornelia Huck
if (
vms->mte&& (kvm_enabled()||hvf_enabled())) {
error_report("mach-virt: %s does not support providing "hw/arm/virt.c +1
-1- "MTE to the guest CPU", + "emulated MTE to the guest CPU",each time I read this message I feel difficult to understand it. Why not replacing by
"mach-virt does not support tag memory with %s acceleration" or something alike?
Quoted 8 lines
Hmm... well, it does not support tag memory with kvm/hvf, and the consequence of this is that kvm/hvf cannot provide support for emulated mte... what about
"mach-virt: tag memory not supported with %s, emulated MTE cannot be provided to the guest CPU"
Might be a bit long, though.
"mach-virt: %s does not support providing emulated MTE to the guest CPU (tag memory not supported)" seems to align better with the other error messages in that function.
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
kvm_enabled() ? "KVM" : "HVF"); exit(1); }
PATCH v4 2/2 qtests/arm: add some mte tests
In reply to Cornelia Huck--- tests/qtest/arm-cpu-features.c | 76 ++++++++++++++++++++++++++++++++++ 1 file changed, 76 insertions(+)
tests/qtest/arm-cpu-features.c +76 -0
@@ -22,6 +22,7 @@#define MACHINE "-machine virt,gic-version=max -accel tcg "#define MACHINE_KVM "-machine virt,gic-version=max -accel kvm -accel tcg " +#define MACHINE_MTE "-machine virt,gic-version=max,mte=on -accel tcg "#define QUERY_HEAD "{ 'execute': 'query-cpu-model-expansion', " \ " 'arguments': { 'type': 'full', "#define QUERY_TAIL "}}"
@@ -155,6 +156,18 @@ static bool resp_get_feature(QDict *resp, const char *feature)g_assert (qdict_get_bool (_props, feature) == (expected_value)); \ }) +#define resp_assert_feature_str (resp, feature, expected_value) \ +({ \ + QDict *_props; \ + \ + g_assert(_resp); \ + g_assert(resp_has_props(_resp)); \ + _props = resp_get_props(_resp); \ + g_assert(qdict_get(_props, feature)); \ + g_assert_cmpstr(qdict_get_try_str(_props, feature), ==, \ + expected_value); \ +}) +#define assert_feature (qts, cpu_type, feature, expected_value) \ ({ \ QDict *_resp; \
@@ -165,6 +178,16 @@ static bool resp_get_feature(QDict *resp, const char *feature)qobject_unref (_resp); \ }) +#define assert_feature_str (qts, cpu_type, feature, expected_value) \ +({ \ + QDict *_resp; \ + \ + _resp = do_query_no_props(qts, cpu_type); \ + g_assert(_resp); \ + resp_assert_feature_str(_resp, feature, expected_value); \ + qobject_unref(_resp); \ +}) +#define assert_set_feature (qts, cpu_type, feature, value) \ ({ \ const char *_fmt = (value) ? "{ %s: true }" : "{ %s: false }"; \
@@ -176,6 +199,16 @@ static bool resp_get_feature(QDict *resp, const char *feature)qobject_unref (_resp); \ }) +#define assert_set_feature_str (qts, cpu_type, feature, value, _fmt) \ +({ \ + QDict *_resp; \ + \ + _resp = do_query(qts, cpu_type, _fmt, feature); \ + g_assert(_resp); \ + resp_assert_feature_str(_resp, feature, value); \ + qobject_unref(_resp); \ +}) +#define assert_has_feature_enabled (qts, cpu_type, feature) \ assert_feature(qts, cpu_type, feature, true)
@@ -412,6 +445,24 @@ static void sve_tests_sve_off_kvm(const void *data)qtest_quit (qts); } +static void mte_tests_tag_memory_on (const void *data) +{ +QTestState *qts; + + qts =qtest_init (MACHINE_MTE "-cpu max" ); + +/* +* With tag memory, "mte" should default to on, and explicitly specifying +* either on or off should be fine. +*/ +assert_has_feature (qts,"max" ,"mte" ); + +assert_set_feature_str (qts,"max" ,"mte" ,"off" ,"{ 'mte': 'off' }" ); +assert_set_feature_str (qts,"max" ,"mte" ,"on" ,"{ 'mte': 'on' }" ); + +qtest_quit (qts); +} +static void pauth_tests_default (QTestState *qts,const char *cpu_type) {assert_has_feature_enabled (qts, cpu_type,"pauth" );
@@ -424,6 +475,21 @@ static void pauth_tests_default(QTestState *qts, const char *cpu_type) "{ 'pauth': false, 'pauth-impdef': true }"); } +static void mte_tests_default (QTestState *qts,const char *cpu_type) +{ +assert_has_feature (qts, cpu_type,"mte" ); + +/* +* Without tag memory, mte will be off under tcg. +* Explicitly enabling it yields an error. +*/ +assert_has_feature (qts, cpu_type,"mte" ); + +assert_set_feature_str (qts,"max" ,"mte" ,"off" ,"{ 'mte': 'off' }" ); +assert_error (qts, cpu_type,"mte=on requires tag memory" , +"{ 'mte': 'on' }" ); +} +static void test_query_cpu_model_expansion (const void *data) {QTestState *qts;
@@ -473,6 +539,7 @@ static void test_query_cpu_model_expansion(const void *data)sve_tests_default (qts,"max" );pauth_tests_default (qts,"max" ); +mte_tests_default (qts,"max" );/* Test that features that depend on KVM generate errors without. */ assert_error(qts, "max",
@@ -516,6 +583,13 @@ static void test_query_cpu_model_expansion_kvm(const void *data)assert_set_feature (qts,"host" ,"pmu" , false);assert_set_feature (qts,"host" ,"pmu" , true); +/* +* Unfortunately, there's no easy way to test whether this instance +* of KVM supports MTE. So we can only assert that the feature +* is present, but not whether it can be toggled. +*/ +assert_has_feature (qts,"host" ,"mte" ); +/* * Some features would be enabled by default, but they're disabled * because this instance of KVM doesn't support them. Test that the
@@ -630,6 +704,8 @@ int main(int argc, char **argv) NULL, sve_tests_sve_off);qtest_add_data_func ("/arm/kvm/query-cpu-model-expansion/sve-off" ,NULL , sve_tests_sve_off_kvm); +qtest_add_data_func ("/arm/max/query-cpu-model-expansion/tag-memory" , +NULL , mte_tests_tag_memory_on); }return g_test_run ();
Signature · 1 line
2.39.0
Re: [PATCH v4 2/2] qtests/arm: add some mte tests
Quoted 5 lines · Cornelia Huck
Acked-by Thomas Huth <[email protected]>Signed-off-by Cornelia Huck <[email protected]>--- tests/qtest/arm-cpu-features.c | 76 ++++++++++++++++++++++++++++++++++ 1 file changed, 76 insertions(+)
Re: [PATCH v4 2/2] qtests/arm: add some mte tests
In reply to Cornelia HuckHi Connie,
Quoted 2 lines · Cornelia Huck
Acked-by Thomas Huth <[email protected]>Signed-off-by Cornelia Huck <[email protected]>
Maybe add some extra information about what tests are run. Also you could add an example of test invocation so that any people interested in can easily run those new tests?
Quoted 97 lines
--- tests/qtest/arm-cpu-features.c | 76 ++++++++++++++++++++++++++++++++++ 1 file changed, 76 insertions(+)tests/qtest/arm-cpu-features.c +51
-0@@ -22,6 +22,7 @@#define MACHINE "-machine virt,gic-version=max -accel tcg "#define MACHINE_KVM "-machine virt,gic-version=max -accel kvm -accel tcg " +#define MACHINE_MTE "-machine virt,gic-version=max,mte=on -accel tcg "#define QUERY_HEAD "{ 'execute': 'query-cpu-model-expansion', " \ " 'arguments': { 'type': 'full', "#define QUERY_TAIL "}}"@@ -155,6 +156,18 @@ static bool resp_get_feature(QDict *resp, const char *feature)g_assert (qdict_get_bool (_props, feature) == (expected_value)); \ }) +#define resp_assert_feature_str (resp, feature, expected_value) \ +({ \ + QDict *_props; \ + \ + g_assert(_resp); \ + g_assert(resp_has_props(_resp)); \ + _props = resp_get_props(_resp); \ + g_assert(qdict_get(_props, feature)); \ + g_assert_cmpstr(qdict_get_try_str(_props, feature), ==, \ + expected_value); \ +}) +#define assert_feature (qts, cpu_type, feature, expected_value) \ ({ \ QDict *_resp; \@@ -165,6 +178,16 @@ static bool resp_get_feature(QDict *resp, const char *feature)qobject_unref (_resp); \ }) +#define assert_feature_str (qts, cpu_type, feature, expected_value) \ +({ \ + QDict *_resp; \ + \ + _resp = do_query_no_props(qts, cpu_type); \ + g_assert(_resp); \ + resp_assert_feature_str(_resp, feature, expected_value); \ + qobject_unref(_resp); \ +}) +#define assert_set_feature (qts, cpu_type, feature, value) \ ({ \ const char *_fmt = (value) ? "{ %s: true }" : "{ %s: false }"; \@@ -176,6 +199,16 @@ static bool resp_get_feature(QDict *resp, const char *feature)qobject_unref (_resp); \ }) +#define assert_set_feature_str (qts, cpu_type, feature, value, _fmt) \ +({ \ + QDict *_resp; \ + \ + _resp = do_query(qts, cpu_type, _fmt, feature); \ + g_assert(_resp); \ + resp_assert_feature_str(_resp, feature, value); \ + qobject_unref(_resp); \ +}) +#define assert_has_feature_enabled (qts, cpu_type, feature) \ assert_feature(qts, cpu_type, feature, true)@@ -412,6 +445,24 @@ static void sve_tests_sve_off_kvm(const void *data)qtest_quit (qts); } +static void mte_tests_tag_memory_on (const void *data) +{ +QTestState *qts; + + qts =qtest_init (MACHINE_MTE "-cpu max" ); + +/* +* With tag memory, "mte" should default to on, and explicitly specifying +* either on or off should be fine. +*/ +assert_has_feature (qts,"max" ,"mte" ); + +assert_set_feature_str (qts,"max" ,"mte" ,"off" ,"{ 'mte': 'off' }" ); +assert_set_feature_str (qts,"max" ,"mte" ,"on" ,"{ 'mte': 'on' }" ); + +qtest_quit (qts); +} +static void pauth_tests_default (QTestState *qts,const char *cpu_type) {assert_has_feature_enabled (qts, cpu_type,"pauth" );@@ -424,6 +475,21 @@ static void pauth_tests_default(QTestState *qts, const char *cpu_type) "{ 'pauth': false, 'pauth-impdef': true }"); }
tests/qtest/arm-cpu-features.c static void pauth_tests_default(QTestState *qts, const char *cpu_type) · line 486
Quoted 10 lines
tests/qtest/arm-cpu-features.c +9
-0+static void mte_tests_default (QTestState *qts,const char *cpu_type) +{ +assert_has_feature (qts, cpu_type,"mte" ); + +/* +* Without tag memory, mte will be off under tcg. +* Explicitly enabling it yields an error. +*/ +assert_has_feature (qts, cpu_type,"mte" );
called twice
tests/qtest/arm-cpu-features.c static void pauth_tests_default(QTestState *qts, const char *cpu_type) · line 490
Quoted 4 lines
tests/qtest/arm-cpu-features.c +4
-0+ +assert_set_feature_str (qts,"max" ,"mte" ,"off" ,"{ 'mte': 'off' }" ); +assert_error (qts, cpu_type,"mte=on requires tag memory" , +"{ 'mte': 'on' }" );
nit. with pauth_tests_default form: cannot enable mte without tag memory
Quoted 14 lines
tests/qtest/arm-cpu-features.c +3
-0+} +static void test_query_cpu_model_expansion (const void *data) {QTestState *qts;@@ -473,6 +539,7 @@ static void test_query_cpu_model_expansion(const void *data)sve_tests_default (qts,"max" );pauth_tests_default (qts,"max" ); +mte_tests_default (qts,"max" );/* Test that features that depend on KVM generate errors without. */ assert_error(qts, "max",
tests/qtest/arm-cpu-features.c static void test_query_cpu_model_expansion_kvm(const void *data) · line 591
Quoted 9 lines
tests/qtest/arm-cpu-features.c +6
-0@@ -516,6 +583,13 @@ static void test_query_cpu_model_expansion_kvm(const void *data)assert_set_feature (qts,"host" ,"pmu" , false);assert_set_feature (qts,"host" ,"pmu" , true); +/* +* Unfortunately, there's no easy way to test whether this instance +* of KVM supports MTE. So we can only assert that the feature +* is present, but not whether it can be toggled. +*/ +assert_has_feature (qts,"host" ,"mte" );
why isn't it possible to implement something like
kvm_supports_steal_time = resp_get_feature(resp, "kvm-steal-time");
Could you elaborate?
tests/qtest/arm-cpu-features.c int main(int argc, char **argv) · line 711
Quoted 13 lines
tests/qtest/arm-cpu-features.c +3
-0+/* * Some features would be enabled by default, but they're disabled * because this instance of KVM doesn't support them. Test that the @@ -630,6 +704,8 @@ int main(int argc, char **argv) NULL, sve_tests_sve_off);qtest_add_data_func ("/arm/kvm/query-cpu-model-expansion/sve-off" ,NULL , sve_tests_sve_off_kvm); +qtest_add_data_func ("/arm/max/query-cpu-model-expansion/tag-memory" , +NULL , mte_tests_tag_memory_on); }return g_test_run ();
Thanks
Eric
Re: [PATCH v4 2/2] qtests/arm: add some mte tests
Quoted 7 lines · Eric Auger
Hi Connie,
Quoted 2 lines · Cornelia Huck
Acked-by Thomas Huth <[email protected]>Signed-off-by Cornelia Huck <[email protected]>Maybe add some extra information about what tests are run. Also you could add an example of test invocation so that any people interested in can easily run those new tests?
Hm, it's just a part of the normal, standard qtests -- not sure what I should add there?
Quoted 4 lines
Quoted 4 lines
--- tests/qtest/arm-cpu-features.c | 76 ++++++++++++++++++++++++++++++++++ 1 file changed, 76 insertions(+)
(...)
Quoted 10 lines
tests/qtest/arm-cpu-features.c static void pauth_tests_default(QTestState *qts, const char *cpu_type) · line 486
Quoted 9 lines
tests/qtest/arm-cpu-features.c +9
-0+static void mte_tests_default (QTestState *qts,const char *cpu_type) +{ +assert_has_feature (qts, cpu_type,"mte" ); + +/* +* Without tag memory, mte will be off under tcg. +* Explicitly enabling it yields an error. +*/ +assert_has_feature (qts, cpu_type,"mte" );called twice
Ok, that's probably some kind of rebase artifact.
Quoted 5 lines
tests/qtest/arm-cpu-features.c static void pauth_tests_default(QTestState *qts, const char *cpu_type) · line 490
Quoted 4 lines
tests/qtest/arm-cpu-features.c +4
-0+ +assert_set_feature_str (qts,"max" ,"mte" ,"off" ,"{ 'mte': 'off' }" ); +assert_error (qts, cpu_type,"mte=on requires tag memory" , +"{ 'mte': 'on' }" );nit. with
pauth_tests_defaultform: cannot enable mte without tag memory
Not sure what you mean here?
Quoted 24 lines
Quoted 14 lines
tests/qtest/arm-cpu-features.c +3
-0+} +static void test_query_cpu_model_expansion (const void *data) {QTestState *qts;@@ -473,6 +539,7 @@ static void test_query_cpu_model_expansion(const void *data)sve_tests_default (qts,"max" );pauth_tests_default (qts,"max" ); +mte_tests_default (qts,"max" );/* Test that features that depend on KVM generate errors without. */ assert_error(qts, "max",tests/qtest/arm-cpu-features.c static void test_query_cpu_model_expansion_kvm(const void *data) · line 591
Quoted 9 lines
tests/qtest/arm-cpu-features.c +6
-0@@ -516,6 +583,13 @@ static void test_query_cpu_model_expansion_kvm(const void *data)assert_set_feature (qts,"host" ,"pmu" , false);assert_set_feature (qts,"host" ,"pmu" , true); +/* +* Unfortunately, there's no easy way to test whether this instance +* of KVM supports MTE. So we can only assert that the feature +* is present, but not whether it can be toggled. +*/ +assert_has_feature (qts,"host" ,"mte" );why isn't it possible to implement something like
Quoted 2 lines
kvm_supports_steal_time = resp_get_feature(resp, "kvm-steal-time");Could you elaborate?
I really should have written that down in detail, but I _think_ that's because of OnOffAuto... if the prop is not set explicitly, we don't know what is supported. Unless someone has an idea how to work around that?