Enable Architectural LBR for guest
cover Enable Architectural LBR for guest
Architectural LBR (Arch LBR) is the enhancement for previous non-Architectural LBR (Legacy LBR). This feature is introduced in Intel Architecture Instruction Set Extensions and Future Features Programming Reference[0]. The advantages of Arch LBR can be referred to in native patch series[1].
Since Arch LBR relies on XSAVES/XRSTORS to boost memory save/ restore, QEMU needs to enable the support for XSS first. Similar as Legacy LBR, QEMU uses lbr-fmt=0x3f parameter to advertise Arch LBR feature to guest.
Note, the depth MSR has following side-effects: 1)On write to the MSR, it'll reset all Arch LBR recording MSRs to 0s. 2) XRSTORS resets all record MSRs to 0s if the saved depth mismatches MSR_ARCH_LBR_DEPTH. As the first step, the Arch LBR virtulization solution only supports guest depth == host depth to simplify the implementation.
During live migration, before put Arch LBR msrs, it'll check the depth setting of destination host, the LBR records are written to destination only if both source and destination host depth MSR settings match.
This patch series should be built with AMX QEMU patches in order to set proper xsave area size.
[0]https://software.intel.com/sites/default/files/managed/c5/15/architecture-instruction-set-extensions-programming-reference.pdf [1]https://lore.kernel.org/lkml/[email protected]/
QEMU base-commit: ad38520bde
patch 1~2: The support patches for legacy LBR.
patch 3: Add a helper function to clean up code and it'll be
used by Arch LBR patch too.
patch 4~5: Enable XSAVES support for Arch LBR. patch 6~7: Enable Arch LBR live migration support.
patch 8: Advertise Arch LBR feature.
Yang Weijiang (8):
qdev-properties: Add a new macro with bitmask check for uint64_t
property
target/i386: Add lbr-fmt vPMU option to support guest LBR target/i386: Add kvm_get_one_msr helper
target/i386: Enable support for XSAVES based features target/i386: Add XSAVES support for Arch LBR target/i386: Add MSR access interface for Arch LBR target/i386: Enable Arch LBR migration states in vmstate target/i386: Support Arch LBR in CPUID enumeration
hw/core/qdev-properties.c | 19 ++++ include/hw/qdev-properties.h | 12 +++ target/i386/cpu.c | 169 +++++++++++++++++++++++++++++------ target/i386/cpu.h | 56 +++++++++++- target/i386/kvm/kvm.c | 115 +++++++++++++++++++----- target/i386/machine.c | 38 ++++++++ 6 files changed, 361 insertions(+), 48 deletions(-)
Signature · 1 line
2.27.0
PATCH 1/8 qdev-properties: Add a new macro with bitmask check for uint64_t property
The DEFINE_PROP_UINT64_CHECKMASK maro applies certain mask check agaist user-supplied property value, reject the value if it violates the bitmask.
--- hw/core/qdev-properties.c | 19 +++++++++++++++++++ include/hw/qdev-properties.h | 12 ++++++++++++ 2 files changed, 31 insertions(+)
hw/core/qdev-properties.c +19 -0
@@ -428,6 +428,25 @@ const PropertyInfo qdev_prop_int64 = { .set_default_value = qdev_propinfo_set_default_value_int, }; +static void set_uint64_checkmask (Object *obj,Visitor *v,const char *name, +void *opaque,Error **errp) +{ +Property *prop = opaque; +uint64_t *ptr =object_field_prop_ptr (obj, prop); + +visit_type_uint64 (v, name, ptr, errp); +if (*ptr & ~prop->bitmask) { +error_setg (errp,"Property value for '%s' violates bitmask '0x%lx'" , + name, prop->bitmask); + } +} + +const PropertyInfo qdev_prop_uint64_checkmask = { + .name ="uint64" , + .get = get_uint64, + .set = set_uint64_checkmask, +}; +/* --- string --- */ static void release_string (Object *obj,const char *name,void *opaque)
include/hw/qdev-properties.h +12 -0
@@ -17,6 +17,7 @@ struct Property {const PropertyInfo *info;ptrdiff_t offset;uint8_t bitnr; +uint64_t bitmask;bool set_default;union {int64_t i;
@@ -54,6 +55,7 @@ extern const PropertyInfo qdev_prop_uint16;extern const PropertyInfo qdev_prop_uint32;extern const PropertyInfo qdev_prop_int32;extern const PropertyInfo qdev_prop_uint64; +extern const PropertyInfo qdev_prop_uint64_checkmask;extern const PropertyInfo qdev_prop_int64;extern const PropertyInfo qdev_prop_size;extern const PropertyInfo qdev_prop_string;
@@ -103,6 +105,16 @@ extern const PropertyInfo qdev_prop_link; .set_default = true, \ .defval.u = (bool)_defval) +/** +* The DEFINE_PROP_UINT64_CHECKMASK macro checks a user-supplied value +* against corresponding bitmask, rejects the value if it violates. +* The default value is set in instance_init(). +*/ +#define DEFINE_PROP_UINT64_CHECKMASK (_name, _state, _field, _bitmask) \ + DEFINE_PROP(_name, _state, _field, qdev_prop_uint64_checkmask, uint64_t, \ + .bitmask = (_bitmask), \ + .set_default = false) +#define PROP_ARRAY_LEN_PREFIX "len-"/**
Signature · 1 line
2.27.0
PATCH 2/8 target/i386: Add lbr-fmt vPMU option to support guest LBR
In reply to Yang WeijiangThe Last Branch Recording (LBR) is a performance monitor unit (PMU) feature on Intel processors which records a running trace of the most recent branches taken by the processor in the LBR stack. This option indicates the LBR format to enable for guest perf.
The LBR feature is enabled if below conditions are met:
1) KVM is enabled and the PMU is enabled.
2) msr-based-feature IA32_PERF_CAPABILITIES is supporterd on KVM.
3) Supported returned value for lbr_fmt from above msr is non-zero.
4) Guest vcpu model does support FEAT_1_ECX.CPUID_EXT_PDCM.
5) User-provided lbr-fmt value doesn't violate its bitmask (0x3f).
6) Target guest LBR format matches that of host.
--- target/i386/cpu.c | 40 ++++++++++++++++++++++++++++++++++++++++ target/i386/cpu.h | 10 ++++++++++ 2 files changed, 50 insertions(+)
target/i386/cpu.c +40 -0
@@ -6370,6 +6370,7 @@ static void x86_cpu_realizefn(DeviceState *dev, Error **errp)CPUX86State *env = &cpu->env;Error *local_err =NULL ;static bool ht_warned; +uint64_t requested_lbr_fmt;if (cpu->apic_id ==UNASSIGNED_APIC_ID ) {error_setg (errp,"apic-id property was not initialized properly" );
@@ -6387,6 +6388,42 @@ static void x86_cpu_realizefn(DeviceState *dev, Error **errp) goto out; } +/* +* Override env->features[FEAT_PERF_CAPABILITIES].LBR_FMT +* with user-provided setting. +*/ +if (cpu->lbr_fmt != ~PERF_CAP_LBR_FMT ) { +if ((cpu->lbr_fmt &PERF_CAP_LBR_FMT ) != cpu->lbr_fmt) { +error_setg (errp,"invalid lbr-fmt" ); +return ; + } + env->features[FEAT_PERF_CAPABILITIES ] &= ~PERF_CAP_LBR_FMT ; + env->features[FEAT_PERF_CAPABILITIES ] |= cpu->lbr_fmt; + } + +/* +* vPMU LBR is supported when 1) KVM is enabled 2) Option pmu=on and +* 3)vPMU LBR format matches that of host setting. +*/ + requested_lbr_fmt = + env->features[FEAT_PERF_CAPABILITIES ] &PERF_CAP_LBR_FMT ; +if (requested_lbr_fmt &&kvm_enabled ()) { +uint64_t host_perf_cap = +x86_cpu_get_supported_feature_word (FEAT_PERF_CAPABILITIES , false); +uint64_t host_lbr_fmt = host_perf_cap &PERF_CAP_LBR_FMT ; + +if (!cpu->enable_pmu) { +error_setg (errp,"vPMU: LBR is unsupported without pmu=on" ); +return ; + } +if (requested_lbr_fmt != host_lbr_fmt) { +error_setg (errp,"vPMU: the lbr-fmt value (0x%lx) mismatches " +"the host supported value (0x%lx)." , + requested_lbr_fmt, host_lbr_fmt); +return ; + } + } +x86_cpu_filter_features (cpu, cpu->check_cpuid || cpu->enforce_cpuid);if (cpu->enforce_cpuid &&x86_cpu_have_filtered_features (cpu)) {
@@ -6739,6 +6776,8 @@ static void x86_cpu_initfn(Object *obj)object_property_add_alias (obj,"sse4_2" , obj,"sse4.2" );object_property_add_alias (obj,"hv-apicv" , obj,"hv-avic" ); + cpu->lbr_fmt = ~PERF_CAP_LBR_FMT ; +object_property_add_alias (obj,"lbr_fmt" , obj,"lbr-fmt" );if (xcc->model) {x86_cpu_load_model (cpu, xcc->model);
@@ -6894,6 +6933,7 @@ static Property x86_cpu_properties[] = {#endif DEFINE_PROP_INT32 ("node-id" ,X86CPU , node_id,CPU_UNSET_NUMA_NODE_ID ),DEFINE_PROP_BOOL ("pmu" ,X86CPU , enable_pmu, false), +DEFINE_PROP_UINT64_CHECKMASK ("lbr-fmt" ,X86CPU , lbr_fmt,PERF_CAP_LBR_FMT ),DEFINE_PROP_UINT32 ("hv-spinlocks" ,X86CPU , hyperv_spinlock_attempts, HYPERV_SPINLOCK_NEVER_NOTIFY),
target/i386/cpu.h +10 -0
@@ -383,6 +383,7 @@ typedef enum X86Seg {#define ARCH_CAP_TSX_CTRL_MSR (1<<7)#define MSR_IA32_PERF_CAPABILITIES 0x345 +#define PERF_CAP_LBR_FMT 0x3f#define MSR_IA32_TSX_CTRL 0x122#define MSR_IA32_TSCDEADLINE 0x6e0
@@ -1819,6 +1820,15 @@ struct X86CPU {*/ bool enable_pmu; +/* +* Enable LBR_FMT bits of IA32_PERF_CAPABILITIES MSR. +* This can't be initialized with a default because it doesn't have +* stable ABI support yet. It is only allowed to pass all LBR_FMT bits +* returned by kvm_arch_get_supported_msr_feature()(which depends on both +* host CPU and kernel capabilities) to the guest. +*/ +uint64_t lbr_fmt; +/* LMCE support can be enabled/disabled via cpu option 'lmce=on/off'. It is * disabled by default to avoid breaking migration between QEMU with * different LMCE configurations.
Signature · 1 line
2.27.0
PATCH 3/8 target/i386: Add kvm_get_one_msr helper
In reply to Yang WeijiangWhen try to get one msr from KVM, I found there's no such kind of existing interface while kvm_put_one_msr() is there. So here comes the patch. It'll remove redundant preparation code before finally call KVM_GET_MSRS IOCTL.
No functional change intended.
--- target/i386/kvm/kvm.c | 48 ++++++++++++++++++++++++------------------- 1 file changed, 27 insertions(+), 21 deletions(-)
target/i386/kvm/kvm.c +27 -21
@@ -136,6 +136,7 @@ static struct kvm_msr_list *kvm_feature_msrs;#define BUS_LOCK_SLICE_TIME 1000000000ULL/* ns */ static RateLimit bus_lock_ratelimit_ctrl; +static int kvm_get_one_msr (X86CPU *cpu,int index,uint64_t *value);int kvm_has_pit_state2 (void ) {
@@ -206,28 +207,21 @@ static int kvm_get_tsc(CPUState *cs) {X86CPU *cpu =X86_CPU (cs);CPUX86State *env = &cpu->env; -struct { -struct kvm_msrs info; -struct kvm_msr_entry entries[1 ]; - } msr_data = {}; +uint64_t value;int ret;if (env->tsc_valid) {return 0 ; } -memset (&msr_data,0 ,sizeof (msr_data)); - msr_data.info.nmsrs =1 ; - msr_data.entries[0 ].index =MSR_IA32_TSC ; env->tsc_valid = !runstate_is_running (); - ret =kvm_vcpu_ioctl (CPU (cpu),KVM_GET_MSRS , &msr_data); + ret =kvm_get_one_msr (cpu,MSR_IA32_TSC , &value);if (ret <0 ) {return ret; } -assert (ret ==1 ); - env->tsc = msr_data.entries[0 ].data; + env->tsc = value;return 0 ; }
@@ -1485,21 +1479,14 @@ static int hyperv_init_vcpu(X86CPU *cpu)* the kernel doesn't support setting vp_index; assert that its value * is in sync */ -struct { -struct kvm_msrs info; -struct kvm_msr_entry entries[1 ]; - } msr_data = { - .info.nmsrs =1 , - .entries[0 ].index =HV_X64_MSR_VP_INDEX , - }; - - ret =kvm_vcpu_ioctl (cs,KVM_GET_MSRS , &msr_data); +uint64_t value; + + ret =kvm_get_one_msr (cpu,HV_X64_MSR_VP_INDEX , &value);if (ret <0 ) {return ret; } -assert (ret ==1 ); -if (msr_data.entries[0 ].data !=hyperv_vp_index (CPU (cpu))) { +if (value !=hyperv_vp_index (CPU (cpu))) {error_report ("kernel's vp_index != QEMU's vp_index" );return -ENXIO ; }
@@ -2752,6 +2739,25 @@ static int kvm_put_one_msr(X86CPU *cpu, int index, uint64_t value)return kvm_vcpu_ioctl (CPU (cpu),KVM_SET_MSRS , cpu->kvm_msr_buf); } +static int kvm_get_one_msr (X86CPU *cpu,int index,uint64_t *value) +{ +int ret; +struct { +struct kvm_msrs info; +struct kvm_msr_entry entries[1 ]; + } msr_data = { + .info.nmsrs =1 , + .entries[0 ].index = index, + }; + + ret =kvm_vcpu_ioctl (CPU (cpu),KVM_GET_MSRS , &msr_data); +if (ret <0 ) { +return ret; + } +assert (ret ==1 ); + *value = msr_data.entries[0 ].data; +return ret; +}void kvm_put_apicbase (X86CPU *cpu,uint64_t value) {int ret;
Signature · 1 line
2.27.0
PATCH 4/8 target/i386: Enable support for XSAVES based features
In reply to Yang WeijiangThere're some new features, including Arch LBR, depending on XSAVES/XRSTORS support, the new instructions will save/restore data based on feature bits enabled in XCR0 | XSS. This patch adds the basic support for related CPUID enumeration and meanwhile changes the name from FEAT_XSAVE_COMP_{LO|HI} to FEAT_XSAVE_XCR0_{LO|HI} to differentiate clearly the feature bits in XCR0 and those in XSS.
--- target/i386/cpu.c | 104 +++++++++++++++++++++++++++++++++++----------- target/i386/cpu.h | 13 +++++- 2 files changed, 91 insertions(+), 26 deletions(-)
target/i386/cpu.c +80 -24
@@ -940,6 +940,34 @@ FeatureWordInfo feature_word_info[FEATURE_WORDS] = { }, .tcg_features = TCG_XSAVE_FEATURES, }, + [FEAT_XSAVE_XSS_LO] = { + .type = CPUID_FEATURE_WORD, + .feat_names = { +NULL ,NULL ,NULL ,NULL , +NULL ,NULL ,NULL ,NULL , +NULL ,NULL ,NULL ,NULL , +NULL ,NULL ,NULL ,NULL , +NULL ,NULL ,NULL ,NULL , +NULL ,NULL ,NULL ,NULL , +NULL ,NULL ,NULL ,NULL , + NULL, NULL, NULL, NULL, + }, + .cpuid = { + .eax =0xD , + .needs_ecx = true, + .ecx = 1, + .reg = R_ECX, + }, + }, + [FEAT_XSAVE_XSS_HI] = { + .type =CPUID_FEATURE_WORD , + .cpuid = { + .eax =0xD , + .needs_ecx = true, + .ecx = 1, + .reg = R_EDX + }, + }, [FEAT_6_EAX] = { .type =CPUID_FEATURE_WORD , .feat_names = {
@@ -955,7 +983,7 @@ FeatureWordInfo feature_word_info[FEATURE_WORDS] = { .cpuid = { .eax = 6, .reg = R_EAX, }, .tcg_features = TCG_6_EAX_FEATURES, }, - [FEAT_XSAVE_COMP_LO] = { + [FEAT_XSAVE_XCR0_LO] = { .type = CPUID_FEATURE_WORD, .cpuid = { .eax = 0xD,
@@ -968,7 +996,7 @@ FeatureWordInfo feature_word_info[FEATURE_WORDS] = {XSTATE_OPMASK_MASK | XSTATE_ZMM_Hi256_MASK | XSTATE_Hi16_ZMM_MASK | XSTATE_PKRU_MASK, }, - [FEAT_XSAVE_COMP_HI] = { + [FEAT_XSAVE_XCR0_HI] = { .type = CPUID_FEATURE_WORD, .cpuid = { .eax = 0xD,
@@ -1385,6 +1413,9 @@ static const X86RegisterInfo32 x86_reg_info_32[CPU_NB_REGS32] = { };#undef REGISTER +/* CPUID feature bits available in XSS */ +#define CPUID_XSTATE_XSS_MASK (0) +ExtSaveArea x86_ext_save_areas[XSAVE_STATE_AREA_COUNT ] = { [XSTATE_FP_BIT ] = {/* x87 FP state component is always enabled if XSAVE is supported */
@@ -1427,15 +1458,18 @@ ExtSaveArea x86_ext_save_areas[XSAVE_STATE_AREA_COUNT] = { }, }; -static uint32_t xsave_area_size (uint64_t mask) +static uint32_t xsave_area_size (uint64_t mask,bool compacted) { +uint64_t ret = x86_ext_save_areas[0 ].size; +const ExtSaveArea *esa; +uint32_t offset =0 ;int i; -uint64_t ret =0 ; -for (i =0 ; i <ARRAY_SIZE (x86_ext_save_areas); i++) { -const ExtSaveArea *esa = &x86_ext_save_areas[i]; +for (i =2 ; i <ARRAY_SIZE (x86_ext_save_areas); i++) { + esa = &x86_ext_save_areas[i];if ((mask >> i) &1 ) { - ret =MAX (ret, esa->offset + esa->size); + offset = compacted ? ret : esa->offset; + ret =MAX (ret, offset + esa->size); } }return ret;
@@ -1446,10 +1480,10 @@ static inline bool accel_uses_host_cpuid(void)return kvm_enabled () ||hvf_enabled (); } -static inline uint64_t x86_cpu_xsave_components (X86CPU *cpu) +static inline uint64_t x86_cpu_xsave_xcr0_components (X86CPU *cpu) { -return ((uint64_t )cpu->env.features[FEAT_XSAVE_COMP_HI ]) <<32 | - cpu->env.features[FEAT_XSAVE_COMP_LO ]; +return ((uint64_t )cpu->env.features[FEAT_XSAVE_XCR0_HI ]) <<32 | + cpu->env.features[FEAT_XSAVE_XCR0_LO ]; }/* Return name of 32-bit register, from a R_* constant */
@@ -1461,6 +1495,12 @@ static const char *get_register_name_32(unsigned int reg)return x86_reg_info_32[reg].name; } +static inline uint64_t x86_cpu_xsave_xss_components (X86CPU *cpu) +{ +return ((uint64_t )cpu->env.features[FEAT_XSAVE_XSS_HI ]) <<32 | + cpu->env.features[FEAT_XSAVE_XSS_LO ]; +} +/* * Returns the set of feature flags that are supported and migratable by * QEMU, for a given FeatureWord.
@@ -4628,8 +4668,8 @@ static const char *x86_cpu_feature_name(FeatureWord w, int bitnr)/* XSAVE components are automatically enabled by other features, * so return the original feature name instead */ -if (w ==FEAT_XSAVE_COMP_LO || w ==FEAT_XSAVE_COMP_HI ) { -int comp = (w ==FEAT_XSAVE_COMP_HI ) ? bitnr +32 : bitnr; +if (w ==FEAT_XSAVE_XCR0_LO || w ==FEAT_XSAVE_XCR0_HI ) { +int comp = (w ==FEAT_XSAVE_XCR0_HI ) ? bitnr +32 : bitnr;if (comp <ARRAY_SIZE (x86_ext_save_areas) && x86_ext_save_areas[comp].bits) {
@@ -5494,25 +5534,36 @@ void cpu_x86_cpuid(CPUX86State *env, uint32_t index, uint32_t count, }if (count ==0 ) { - *ecx =xsave_area_size (x86_cpu_xsave_components (cpu)); - *eax = env->features[FEAT_XSAVE_COMP_LO ]; - *edx = env->features[FEAT_XSAVE_COMP_HI ]; + *ecx =xsave_area_size (x86_cpu_xsave_xcr0_components (cpu), false); + *eax = env->features[FEAT_XSAVE_XCR0_LO ]; + *edx = env->features[FEAT_XSAVE_XCR0_HI ];/* * The initial value of xcr0 and ebx == 0, On host without kvm * commit 412a3c41(e.g., CentOS 6), the ebx's value always == 0 * even through guest update xcr0, this will crash some legacy guest * (e.g., CentOS 6), So set ebx == ecx to workaroud it. */ - *ebx =kvm_enabled () ? *ecx :xsave_area_size (env->xcr0); + *ebx =kvm_enabled () ? *ecx :xsave_area_size (env->xcr0, false); }else if (count ==1 ) { +uint64_t xstate =x86_cpu_xsave_xcr0_components (cpu) | +x86_cpu_xsave_xss_components (cpu); + *eax = env->features[FEAT_XSAVE ]; + *ebx =xsave_area_size (xstate, true); + *ecx = env->features[FEAT_XSAVE_XSS_LO ]; + *edx = env->features[FEAT_XSAVE_XSS_HI ]; }else if (count <ARRAY_SIZE (x86_ext_save_areas)) { -if ((x86_cpu_xsave_components (cpu) >> count) &1 ) { -const ExtSaveArea *esa = &x86_ext_save_areas[count]; +const ExtSaveArea *esa = &x86_ext_save_areas[count]; + +if ((x86_cpu_xsave_xcr0_components (cpu) >> count) &1 ) { *eax = esa->size; *ebx = esa->offset; *ecx = (esa->ecx &ESA_FEATURE_ALIGN64_MASK ) | (esa->ecx &ESA_FEATURE_XFD_MASK ); + }else if ((x86_cpu_xsave_xss_components (cpu) >> count) &1 ) { + *eax = esa->size; + *ebx =0 ; + *ecx =1 ; } }break ;
@@ -5563,8 +5614,8 @@ void cpu_x86_cpuid(CPUX86State *env, uint32_t index, uint32_t count, }else { *eax &= env->features[FEAT_SGX_12_1_EAX ]; *ebx &=0 ;/* ebx reserve */ - *ecx &= env->features[FEAT_XSAVE_COMP_LO ]; - *edx &= env->features[FEAT_XSAVE_COMP_HI ]; + *ecx &= env->features[FEAT_XSAVE_XSS_LO ]; + *edx &= env->features[FEAT_XSAVE_XSS_HI ];/* FP and SSE are always allowed regardless of XSAVE/XCR0. */ *ecx |=XSTATE_FP_MASK |XSTATE_SSE_MASK ;
@@ -5947,6 +5998,9 @@ static void x86_cpu_reset(DeviceState *dev) }for (i =2 ; i <ARRAY_SIZE (x86_ext_save_areas); i++) {const ExtSaveArea *esa = &x86_ext_save_areas[i]; +if (!((1 << i) &CPUID_XSTATE_XCR0_MASK )) { +continue ; + }if (env->features[esa->feature] & esa->bits) { xcr0 |=1ull << i; }
@@ -6083,8 +6137,8 @@ static void x86_cpu_enable_xsave_components(X86CPU *cpu)uint64_t mask;if (!(env->features[FEAT_1_ECX ] &CPUID_EXT_XSAVE )) { - env->features[FEAT_XSAVE_COMP_LO ] =0 ; - env->features[FEAT_XSAVE_COMP_HI ] =0 ; + env->features[FEAT_XSAVE_XCR0_LO ] =0 ; + env->features[FEAT_XSAVE_XCR0_HI ] =0 ;return ; }
@@ -6102,8 +6156,10 @@ static void x86_cpu_enable_xsave_components(X86CPU *cpu) request_perm = true; } - env->features[FEAT_XSAVE_COMP_LO ] = mask; - env->features[FEAT_XSAVE_COMP_HI ] = mask >>32 ; + env->features[FEAT_XSAVE_XCR0_LO ] = mask &CPUID_XSTATE_XCR0_MASK ; + env->features[FEAT_XSAVE_XCR0_HI ] = mask >>32 ; + env->features[FEAT_XSAVE_XSS_LO ] = mask &CPUID_XSTATE_XSS_MASK ; + env->features[FEAT_XSAVE_XSS_HI ] = mask >>32 ; }/***** Steps involved on loading and filtering CPUID data
target/i386/cpu.h +11 -2
@@ -568,6 +568,13 @@ typedef enum X86Seg {#define ESA_FEATURE_XFD_MASK (1U << ESA_FEATURE_XFD_BIT) +/* CPUID feature bits available in XCR0 */ +#define CPUID_XSTATE_XCR0_MASK (XSTATE_FP_MASK | XSTATE_SSE_MASK | \ + XSTATE_YMM_MASK | XSTATE_BNDREGS_MASK | \ + XSTATE_BNDCSR_MASK | XSTATE_OPMASK_MASK | \ + XSTATE_ZMM_Hi256_MASK | \ + XSTATE_Hi16_ZMM_MASK | XSTATE_PKRU_MASK) +/* CPUID feature words */ typedef enum FeatureWord { FEAT_1_EDX, /* CPUID[1].EDX */
@@ -586,8 +593,8 @@ typedef enum FeatureWord {FEAT_SVM ,/* CPUID[8000_000A].EDX */ FEAT_XSAVE ,/* CPUID[EAX=0xd,ECX=1].EAX */ FEAT_6_EAX ,/* CPUID[6].EAX */ -FEAT_XSAVE_COMP_LO ,/* CPUID[EAX=0xd,ECX=0].EAX */ -FEAT_XSAVE_COMP_HI ,/* CPUID[EAX=0xd,ECX=0].EDX */ +FEAT_XSAVE_XCR0_LO ,/* CPUID[EAX=0xd,ECX=0].EAX */ +FEAT_XSAVE_XCR0_HI ,/* CPUID[EAX=0xd,ECX=0].EDX */ FEAT_ARCH_CAPABILITIES ,FEAT_CORE_CAPABILITY , FEAT_PERF_CAPABILITIES,
@@ -604,6 +611,8 @@ typedef enum FeatureWord {FEAT_SGX_12_0_EAX ,/* CPUID[EAX=0x12,ECX=0].EAX (SGX) */ FEAT_SGX_12_0_EBX ,/* CPUID[EAX=0x12,ECX=0].EBX (SGX MISCSELECT[31:0]) */ FEAT_SGX_12_1_EAX ,/* CPUID[EAX=0x12,ECX=1].EAX (SGX ATTRIBUTES[31:0]) */ +FEAT_XSAVE_XSS_LO ,/* CPUID[EAX=0xd,ECX=1].ECX */ +FEAT_XSAVE_XSS_HI ,/* CPUID[EAX=0xd,ECX=1].EDX */ FEATURE_WORDS , } FeatureWord;
Signature · 1 line
2.27.0
PATCH 5/8 target/i386: Add XSAVES support for Arch LBR
In reply to Yang WeijiangDefine Arch LBR bit in XSS and save/restore structure for XSAVE area size calculation.
--- target/i386/cpu.c | 6 +++++- target/i386/cpu.h | 23 +++++++++++++++++++++++ 2 files changed, 28 insertions(+), 1 deletion(-)
target/i386/cpu.c +5 -1
@@ -1414,7 +1414,7 @@ static const X86RegisterInfo32 x86_reg_info_32[CPU_NB_REGS32] = {#undef REGISTER/* CPUID feature bits available in XSS */ -#define CPUID_XSTATE_XSS_MASK (0) +#define CPUID_XSTATE_XSS_MASK (XSTATE_ARCH_LBR_MASK)ExtSaveArea x86_ext_save_areas[XSAVE_STATE_AREA_COUNT ] = { [XSTATE_FP_BIT ] = {
@@ -1448,6 +1448,10 @@ ExtSaveArea x86_ext_save_areas[XSAVE_STATE_AREA_COUNT] = { [XSTATE_PKRU_BIT] = { .feature = FEAT_7_0_ECX, .bits = CPUID_7_0_ECX_PKU, .size = sizeof(XSavePKRU) }, + [XSTATE_ARCH_LBR_BIT] = { + .feature = FEAT_7_0_EDX, .bits = CPUID_7_0_EDX_ARCH_LBR, + .offset = 0 /*supervisor mode component, offset = 0 */, + .size = sizeof(XSavesArchLBR) }, [XSTATE_XTILE_CFG_BIT] = { .feature = FEAT_7_0_EDX, .bits = CPUID_7_0_EDX_AMX_TILE, .size = sizeof(XSaveXTILECFG),
target/i386/cpu.h +23 -0
@@ -541,6 +541,7 @@ typedef enum X86Seg {#define XSTATE_ZMM_Hi256_BIT 6#define XSTATE_Hi16_ZMM_BIT 7#define XSTATE_PKRU_BIT 9 +#define XSTATE_ARCH_LBR_BIT 15#define XSTATE_XTILE_CFG_BIT 17#define XSTATE_XTILE_DATA_BIT 18
@@ -553,6 +554,7 @@ typedef enum X86Seg {#define XSTATE_ZMM_Hi256_MASK (1ULL << XSTATE_ZMM_Hi256_BIT)#define XSTATE_Hi16_ZMM_MASK (1ULL << XSTATE_Hi16_ZMM_BIT)#define XSTATE_PKRU_MASK (1ULL << XSTATE_PKRU_BIT) +#define XSTATE_ARCH_LBR_MASK (1ULL << XSTATE_ARCH_LBR_BIT)#define XSTATE_XTILE_CFG_MASK (1ULL << XSTATE_XTILE_CFG_BIT)#define XSTATE_XTILE_DATA_MASK (1ULL << XSTATE_XTILE_DATA_BIT)#define XFEATURE_XTILE_MASK (XSTATE_XTILE_CFG_MASK \
@@ -867,6 +869,8 @@ typedef uint64_t FeatureWordArray[FEATURE_WORDS];#define CPUID_7_0_EDX_SERIALIZE (1U << 14)/* TSX Suspend Load Address Tracking instruction */ #define CPUID_7_0_EDX_TSX_LDTRK (1U << 16) +/* Architectural LBRs */ +#define CPUID_7_0_EDX_ARCH_LBR (1U << 19)/* AVX512_FP16 instruction */ #define CPUID_7_0_EDX_AVX512_FP16 (1U << 23)/* AMX tile (two-dimensional register) */
@@ -1386,6 +1390,24 @@ typedef struct XSaveXTILEDATA {uint8_t xtiledata[8 ][1024 ]; } XSaveXTILEDATA; +typedef struct { +uint64_t from; +uint64_t to; +uint64_t info; +}LBR_ENTRY ; + +#define ARCH_LBR_NR_ENTRIES 32 + +/* Ext. save area 19: Supervisor mode Arch LBR state */ +typedef struct XSavesArchLBR { +uint64_t lbr_ctl; +uint64_t lbr_depth; +uint64_t ler_from; +uint64_t ler_to; +uint64_t ler_info; +LBR_ENTRY lbr_records[ARCH_LBR_NR_ENTRIES ]; +}XSavesArchLBR ; +QEMU_BUILD_BUG_ON (sizeof (XSaveAVX) !=0x100 );QEMU_BUILD_BUG_ON (sizeof (XSaveBNDREG) !=0x40 );QEMU_BUILD_BUG_ON (sizeof (XSaveBNDCSR) !=0x40 );
@@ -1395,6 +1417,7 @@ QEMU_BUILD_BUG_ON(sizeof(XSaveHi16_ZMM) != 0x400);QEMU_BUILD_BUG_ON (sizeof (XSavePKRU) !=0x8 );QEMU_BUILD_BUG_ON (sizeof (XSaveXTILECFG) !=0x40 );QEMU_BUILD_BUG_ON (sizeof (XSaveXTILEDATA) !=0x2000 ); +QEMU_BUILD_BUG_ON (sizeof (XSavesArchLBR) !=0x328 ); typedef struct ExtSaveArea { uint32_t feature, bits;
Signature · 1 line
2.27.0
PATCH 6/8 target/i386: Add MSR access interface for Arch LBR
In reply to Yang WeijiangIn the first generation of Arch LBR, the max support Arch LBR depth is 32, both host and guest use the value to set depth MSR. This can simplify the implementation of patch given the side-effect of mismatch of host/guest depth MSR: XRSTORS will reset all recording MSRs to 0s if the saved depth mismatches MSR_ARCH_LBR_DEPTH.
In most of the cases Arch LBR is not in active status, so check the control bit before save/restore the big chunck of Arch LBR MSRs.
--- target/i386/cpu.h | 10 +++++++ target/i386/kvm/kvm.c | 67 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 77 insertions(+)
target/i386/cpu.h +10 -0
@@ -388,6 +388,11 @@ typedef enum X86Seg {#define MSR_IA32_TSX_CTRL 0x122#define MSR_IA32_TSCDEADLINE 0x6e0#define MSR_IA32_PKRS 0x6e1 +#define MSR_ARCH_LBR_CTL 0x000014ce +#define MSR_ARCH_LBR_DEPTH 0x000014cf +#define MSR_ARCH_LBR_FROM_0 0x00001500 +#define MSR_ARCH_LBR_TO_0 0x00001600 +#define MSR_ARCH_LBR_INFO_0 0x00001200#define FEATURE_CONTROL_LOCKED (1<<0)#define FEATURE_CONTROL_VMXON_ENABLED_INSIDE_SMX (1ULL << 1)
@@ -1659,6 +1664,11 @@ typedef struct CPUX86State {uint64_t msr_xfd;uint64_t msr_xfd_err; +/* Per-VCPU Arch LBR MSRs */ +uint64_t msr_lbr_ctl; +uint64_t msr_lbr_depth; +LBR_ENTRY lbr_records[ARCH_LBR_NR_ENTRIES ]; +/* exception/interrupt handling */ int error_code;int exception_is_int;
target/i386/kvm/kvm.c +67 -0
85 lines not on this page · raw message
Signature · 1 line
2.27.0
PATCH 7/8 target/i386: Enable Arch LBR migration states in vmstate
In reply to Yang WeijiangThe Arch LBR record MSRs and control MSRs will be migrated to destination guest if the vcpus were running with Arch LBR active.
--- target/i386/machine.c | 38 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+)
target/i386/machine.c +38 -0
@@ -136,6 +136,22 @@ static const VMStateDescription vmstate_mtrr_var = {#define VMSTATE_MTRR_VARS (_field, _state, _n, _v) \ VMSTATE_STRUCT_ARRAY(_field, _state, _n, _v, vmstate_mtrr_var, MTRRVar) +static const VMStateDescription vmstate_lbr_records_var = { + .name ="lbr_records_var" , + .version_id =1 , + .minimum_version_id =1 , + .fields = (VMStateField []) { +VMSTATE_UINT64 (from,LBR_ENTRY ), +VMSTATE_UINT64 (to,LBR_ENTRY ), +VMSTATE_UINT64 (info,LBR_ENTRY ), +VMSTATE_END_OF_LIST () + } +}; + +#define VMSTATE_LBR_VARS (_field, _state, _n, _v) \ + VMSTATE_STRUCT_ARRAY(_field, _state, _n, _v, vmstate_lbr_records_var, \ + LBR_ENTRY) + typedef struct x86_FPReg_tmp { FPReg *parent; uint64_t tmp_mant;
@@ -1523,6 +1539,27 @@ static const VMStateDescription vmstate_amx_xtile = { } }; +static bool arch_lbr_needed (void *opaque) +{ +X86CPU *cpu = opaque; +CPUX86State *env = &cpu->env; + +return !!(env->features[FEAT_7_0_EDX ] &CPUID_7_0_EDX_ARCH_LBR ); +} + +static const VMStateDescription vmstate_arch_lbr = { + .name ="cpu/arch_lbr" , + .version_id =1 , + .minimum_version_id =1 , + .needed = arch_lbr_needed, + .fields = (VMStateField []) { +VMSTATE_UINT64 (env.msr_lbr_ctl,X86CPU ), +VMSTATE_UINT64 (env.msr_lbr_depth,X86CPU ), +VMSTATE_LBR_VARS (env.lbr_records,X86CPU ,ARCH_LBR_NR_ENTRIES ,1 ), +VMSTATE_END_OF_LIST () + } +}; +const VMStateDescription vmstate_x86_cpu = { .name ="cpu" , .version_id =12 ,
@@ -1664,6 +1701,7 @@ const VMStateDescription vmstate_x86_cpu = { &vmstate_pdptrs, &vmstate_msr_xfd, &vmstate_amx_xtile, + &vmstate_arch_lbr, NULL } };
Signature · 1 line
2.27.0
PATCH 8/8 target/i386: Support Arch LBR in CPUID enumeration
In reply to Yang WeijiangIf CPUID.(EAX=07H, ECX=0):EDX[19] is set to 1, the processor supports Architectural LBRs. In this case, CPUID leaf 01CH indicates details of the Architectural LBRs capabilities. XSAVE support for Architectural LBRs is enumerated in CPUID.(EAX=0DH, ECX=0FH).
--- target/i386/cpu.c | 21 ++++++++++++++++++++- 1 file changed, 20 insertions(+), 1 deletion(-)
target/i386/cpu.c +20 -1
@@ -858,7 +858,7 @@ FeatureWordInfo feature_word_info[FEATURE_WORDS] = {"fsrm" ,NULL ,NULL ,NULL ,"avx512-vp2intersect" ,NULL ,"md-clear" ,NULL ,NULL ,NULL ,"serialize" ,NULL , -"tsx-ldtrk" ,NULL ,NULL /* pconfig */ ,NULL , +"tsx-ldtrk" ,NULL ,NULL /* pconfig */ ,"arch-lbr" ,NULL ,NULL ,"amx-bf16" ,"avx512-fp16" ,"amx-tile" ,"amx-int8" ,"spec-ctrl" ,"stibp" , NULL, "arch-capabilities", "core-capability", "ssbd",
@@ -5494,6 +5494,12 @@ void cpu_x86_cpuid(CPUX86State *env, uint32_t index, uint32_t count,assert (!(*eax & ~0x1f )); *ebx &=0xffff ;/* The count doesn't need to be reliable. */ break ; +case 0x1C : + *eax =kvm_arch_get_supported_cpuid (cs->kvm_state,0x1C ,0 ,R_EAX ); + *ebx =kvm_arch_get_supported_cpuid (cs->kvm_state,0x1C ,0 ,R_EBX ); + *ecx =kvm_arch_get_supported_cpuid (cs->kvm_state,0x1C ,0 ,R_ECX ); + *edx =0 ; +break ;case 0x1F :/* V2 Extended Topology Enumeration Leaf */ if (env->nr_dies <2 ) {
@@ -5556,6 +5562,19 @@ void cpu_x86_cpuid(CPUX86State *env, uint32_t index, uint32_t count, *ebx =xsave_area_size (xstate, true); *ecx = env->features[FEAT_XSAVE_XSS_LO ]; *edx = env->features[FEAT_XSAVE_XSS_HI ]; +if (kvm_enabled () && cpu->enable_pmu && + (env->features[FEAT_7_0_EDX ] &CPUID_7_0_EDX_ARCH_LBR ) && + (*eax &CPUID_XSAVE_XSAVES )) { + *ecx |=XSTATE_ARCH_LBR_MASK ; + }else { + *ecx &= ~XSTATE_ARCH_LBR_MASK ; + } + }else if (count ==0xf &&kvm_enabled () && cpu->enable_pmu && + (env->features[FEAT_7_0_EDX ] &CPUID_7_0_EDX_ARCH_LBR )) { + *eax =kvm_arch_get_supported_cpuid (cs->kvm_state,0xD ,0xf ,R_EAX ); + *ebx =kvm_arch_get_supported_cpuid (cs->kvm_state,0xD ,0xf ,R_EBX ); + *ecx =kvm_arch_get_supported_cpuid (cs->kvm_state,0xD ,0xf ,R_ECX ); + *edx =kvm_arch_get_supported_cpuid (cs->kvm_state,0xD ,0xf ,R_EDX ); }else if (count <ARRAY_SIZE (x86_ext_save_areas)) {const ExtSaveArea *esa = &x86_ext_save_areas[count];
Signature · 1 line
2.27.0