Intel Hardware P-States (HWP) support
v6 cover Intel Hardware P-States (HWP) support
Hi,
This patch series adds Hardware-Controlled Performance States (HWP) for Intel processors to Xen.
v2 was only partially reviewed, so v3 is mostly a reposting of v2. In v2 & v3, I think I addressed all comments for v1. I kept patch 11 "xenpm:
Factor out a non-fatal cpuid_parse variant", with a v2 comment explaining why I keep it.
v3 adds "xen/x86: Tweak PDC bits when using HWP". Qubes testing revealed an issue where enabling HWP can crash firwmare code (maybe SMM). This requires a Linux change to get the PDC bits from Xen and pass them to ACPI. Roger has a patch [0] to set the PDC bits. Roger's 3 patch series was tested with "xen/x86: Tweak PDC bits when using HWP" on affected hardware and allowed proper operation.
v4:
There is a large amount or renaming from HWP/hwp to CPPC/cppc in the series. The driver remains hwp_ prefixed since it is dealing with the hardware interface. The sysctl, xc and xenpm interfaces were renamed to cppc to be the generic ACPI CPPC (Collaborative Processor Performance Control) interface.
struct xen_get_cpufreq_para was re-organized in a binary compatible fashion to nest scaling governor options. This allows the cppc support to use uint32_t's for its parameters.
HWP is now enabled with a top-level cpufreq=hwp option. It will fallback to cpufreq=xen if hwp is unavailable. This seems like the most user-friendly option. Since the user was trying to specify *some* cpufreq, we should give them the best that we can instead of disabling the functionality.
"xenpm: Factor out a non-fatal cpuid_parse variant" was dropped. set-cpufreq-cppc expects either a cpu number or none specified, which implies all.
Some patches were re-arrange - "xen/x86: Tweak PDC bits when using HWP" now comes immediately after "cpufreq: Add Hardware P-State (HWP) driver"
The implementation of "cpufreq: Allow restricting to internal governors only " changed, so I removed Jan's Ack.
v5:
HWP is enabled with a toplevel cpufreq=hwp option. There is no fallback by default, but a cpufreq=hwp;xen syntax is now supported. That tries hwp first. If HWP registration is unsuccessful, then xen registration is performed as a fallback.
More changes from Jan's feedback. They are typically minor and documented in individual patches.
v6:
After some discussion, the cpufreq=hwp;xen syntax is retained, with the global applicability of "verbose" mention in docs. Minor tweaks elsewhere as documented in individual patches.
Previous cover letter:
With HWP, the processor makes its own determinations for frequency selection, though users can set some parameters and preferences. There is also Turbo Boost which dynamically pushes the max frequency if possible.
The existing governors don't work with HWP since they select frequencies and HWP doesn't expose those. Therefore a dummy hwp-interal governor is used that doesn't do anything.
xenpm get-cpufreq-para is extended to show HWP parameters, and set-cpufreq-cppc is added to set them.
A lightly loaded OpenXT laptop showed ~1W power savings according to powertop. A mostly idle Fedora system (dom0 only) showed a more modest power savings.
This is for a 10th gen 6-core 1600 MHz base 4900 MHZ max cpu. In the default balance mode, Turbo Boost doesn't exceed 4GHz. Tweaking the energy_perf preference with xenpm set-cpufreq-para balance ene:64, I've seen the CPU hit 4.7GHz before throttling down and bouncing around between 4.3 and 4.5 GHz. Curiously the other cores read ~4GHz when turbo boost takes affect. This was done after pinning all dom0 cores, and using taskset to pin to vCPU/pCPU 11 and running a bash tightloop.
HWP defaults to disabled and running with the existing HWP configuration
- it doesn't reconfigure by default. It can be enabled with cpufreq=hwp.
Hardware Duty Cycling (HDC) is another feature to autonomously powerdown things. It defaults to enabled when HWP is enabled, but HDC can be disabled on the command line. cpufreq=xen:hwp,no-hdc
I've only tested on 8th gen and 10th gen systems with activity window and energy_perf support. So the pathes for CPUs lacking those features are untested.
Fast MSR support was removed in v2. The model specific checking was not done properly, and I don't have hardware to test with. Since writes are expected to be infrequent, I just removed the code.
This changes the systcl_pm_op hypercall, so that wants review.
Regards,
Jason
[0] https://lore.kernel.org/xen-devel/[email protected]/
Jason Andryuk (15):
cpufreq: Allow restricting to internal governors only
cpufreq: Add perf_freq to cpuinfo
cpufreq: Export intel_feature_detect xen/sysctl: Nest cpufreq scaling options pmstat&xenpm: Re-arrage for cpufreq union
cpufreq: Add Hardware P-State (HWP) driver xen/x86: Tweak PDC bits when using HWP
xenpm: Change get-cpufreq-para output for hwp
cpufreq: Export HWP parameters to userspace as CPPC
libxc: Include cppc_para in definitions
xenpm: Print HWP/CPPC parameters
xen: Add SET_CPUFREQ_HWP xen_sysctl_pm_op
libxc: Add xc_set_cpufreq_cppc
xenpm: Add set-cpufreq-cppc subcommand
CHANGELOG: Add Intel HWP entry
CHANGELOG.md | 2 +- docs/misc/xen-command-line.pandoc | 20 +- tools/include/xenctrl.h | 28 +- tools/libs/ctrl/xc_pm.c | 42 +- tools/misc/xenpm.c | 392 ++++++++++- xen/arch/x86/acpi/cpufreq/Makefile | 1 + xen/arch/x86/acpi/cpufreq/cpufreq.c | 31 +- xen/arch/x86/acpi/cpufreq/hwp.c | 654 +++++++++++++++++++ xen/arch/x86/acpi/lib.c | 5 + xen/arch/x86/cpu/mcheck/mce_intel.c | 6 + xen/arch/x86/include/asm/cpufeature.h | 12 +- xen/arch/x86/include/asm/msr-index.h | 16 +- xen/drivers/acpi/pmstat.c | 100 +-- xen/drivers/cpufreq/cpufreq.c | 60 +- xen/drivers/cpufreq/cpufreq_misc_governors.c | 9 + xen/drivers/cpufreq/cpufreq_ondemand.c | 3 + xen/drivers/cpufreq/utility.c | 1 + xen/include/acpi/cpufreq/cpufreq.h | 22 + xen/include/acpi/pdc_intel.h | 1 + xen/include/public/sysctl.h | 144 +++- 20 files changed, 1428 insertions(+), 121 deletions(-) create mode 100644 xen/arch/x86/acpi/cpufreq/hwp.c
Signature · 1 line
2.41.0
PATCH v6 1/15 cpufreq: Allow restricting to internal governors only
For hwp, the standard governors are not usable, and only the internal one is applicable. Add the cpufreq_governor_internal boolean to indicate when an internal governor, like hwp, will be used. This is set during presmp_initcall, and governor registration can be skipped when called during initcall.
This way unusable governors are not registered, and only compatible governors are advertised to userspace.
---
v6:
Add Jan's Ack
v5:
Check cpufreq_governor_internal and skip registration as applicable Remove internal flag
v4:
Rework to use an internal flag
Removed Jan's Ack since the approach is different.
v3:
Switch to initdata
Add Jan Acked-by
Commit message s/they/the/ typo
Don't register hwp-internal when running non-hwp - Marek
v2:
Switch to "-internal"
Add blank line in header
--- xen/drivers/cpufreq/cpufreq.c | 1 + xen/drivers/cpufreq/cpufreq_misc_governors.c | 9 +++++++++ xen/drivers/cpufreq/cpufreq_ondemand.c | 3 +++ xen/include/acpi/cpufreq/cpufreq.h | 2 ++ 4 files changed, 15 insertions(+)
xen/drivers/cpufreq/cpufreq.c +1 -0
@@ -56,6 +56,7 @@ struct cpufreq_dom { };static LIST_HEAD_READ_MOSTLY (cpufreq_dom_list_head); +bool __initdata cpufreq_governor_internal;struct cpufreq_governor *__read_mostly cpufreq_opt_governor;LIST_HEAD_READ_MOSTLY (cpufreq_governor_list);
xen/drivers/cpufreq/cpufreq_misc_governors.c +9 -0
@@ -120,6 +120,9 @@ static int __init cf_check cpufreq_gov_userspace_init(void) {unsigned int cpu; +if ( cpufreq_governor_internal ) +return 0 ; +for_each_online_cpu (cpu)per_cpu (cpu_set_freq, cpu) = userspace_cmdline_freq;register_cpu_notifier (&cpufreq_userspace_cpu_nfb);
@@ -162,6 +165,9 @@ struct cpufreq_governor cpufreq_gov_performance = { static int __init cf_check cpufreq_gov_performance_init(void) { +if ( cpufreq_governor_internal ) +return 0 ; +return cpufreq_register_governor (&cpufreq_gov_performance); }__initcall (cpufreq_gov_performance_init);
@@ -201,6 +207,9 @@ struct cpufreq_governor cpufreq_gov_powersave = { static int __init cf_check cpufreq_gov_powersave_init(void) { +if ( cpufreq_governor_internal ) +return 0 ; +return cpufreq_register_governor (&cpufreq_gov_powersave); }__initcall (cpufreq_gov_powersave_init);
xen/drivers/cpufreq/cpufreq_ondemand.c +3 -0
@@ -360,6 +360,9 @@ struct cpufreq_governor cpufreq_gov_dbs = { static int __init cf_check cpufreq_gov_dbs_init(void) { +if ( cpufreq_governor_internal ) +return 0 ; +return cpufreq_register_governor (&cpufreq_gov_dbs); }__initcall (cpufreq_gov_dbs_init);
xen/include/acpi/cpufreq/cpufreq.h +2 -0
@@ -116,6 +116,8 @@ extern struct cpufreq_governor cpufreq_gov_powersave;extern struct list_head cpufreq_governor_list; +extern bool cpufreq_governor_internal; +extern int cpufreq_register_governor (struct cpufreq_governor *governor);extern struct cpufreq_governor *__find_governor (const char *governor);#define CPUFREQ_DEFAULT_GOVERNOR &cpufreq_gov_dbs
Signature · 1 line
2.41.0
PATCH v6 2/15 cpufreq: Add perf_freq to cpuinfo
In reply to Jason Andryukacpi-cpufreq scales the aperf/mperf measurements by max_freq, but HWP needs to scale by base frequency. Settings max_freq to base_freq "works" but the code is not obvious, and returning values to userspace is tricky. Add an additonal perf_freq member which is used for scaling aperf/mperf measurements.
---
v3:
Add Jan's Ack
I don't like this, but it seems the best way to re-use the common aperf/mperf code. The other option would be to add wrappers that then do the acpi vs. hwp scaling.
--- xen/arch/x86/acpi/cpufreq/cpufreq.c | 2 +- xen/drivers/cpufreq/utility.c | 1 + xen/include/acpi/cpufreq/cpufreq.h | 3 +++ 3 files changed, 5 insertions(+), 1 deletion(-)
xen/arch/x86/acpi/cpufreq/cpufreq.c +1 -1
@@ -316,7 +316,7 @@ unsigned int get_measured_perf(unsigned int cpu, unsigned int flag)else perf_percent =0 ; -return policy->cpuinfo.max_freq * perf_percent /100 ; +return policy->cpuinfo.perf_freq * perf_percent /100 ; } static unsigned int cf_check get_cur_freq_on_cpu(unsigned int cpu)
xen/drivers/cpufreq/utility.c +1 -0
@@ -236,6 +236,7 @@ int cpufreq_frequency_table_cpuinfo(struct cpufreq_policy *policy, policy->min = policy->cpuinfo.min_freq = min_freq; policy->max = policy->cpuinfo.max_freq = max_freq; + policy->cpuinfo.perf_freq = max_freq; policy->cpuinfo.second_max_freq = second_max_freq;if (policy->min == ~0 )
xen/include/acpi/cpufreq/cpufreq.h +3 -0
@@ -37,6 +37,9 @@ extern struct acpi_cpufreq_data *cpufreq_drv_data[NR_CPUS];struct cpufreq_cpuinfo {unsigned int max_freq;unsigned int second_max_freq;/* P1 if Turbo Mode is on */ +unsigned int perf_freq;/* Scaling freq for aperf/mpref. +acpi-cpufreq uses max_freq, but HWP uses +base_freq.*/ unsigned int min_freq;unsigned int transition_latency;/* in 10^(-9) s = nanoseconds */ };
Signature · 1 line
2.41.0
PATCH v6 3/15 cpufreq: Export intel_feature_detect
In reply to Jason AndryukExport feature_detect as intel_feature_detect so it can be re-used by HWP.
---
v4:
Add Jan's Ack
v3:
Remove void * cast when calling intel_feature_detect
v2:
export intel_feature_detect with typed pointer
Move intel_feature_detect to acpi/cpufreq/cpufreq.h since the declaration now contains struct cpufreq_policy *.
--- xen/arch/x86/acpi/cpufreq/cpufreq.c | 8 ++++++-- xen/include/acpi/cpufreq/cpufreq.h | 2 ++ 2 files changed, 8 insertions(+), 2 deletions(-)
xen/arch/x86/acpi/cpufreq/cpufreq.c +6 -2
@@ -339,9 +339,8 @@ static unsigned int cf_check get_cur_freq_on_cpu(unsigned int cpu)return extract_freq (get_cur_val (cpumask_of (cpu)), data); } -static void cf_check feature_detect(void *info) +void intel_feature_detect (struct cpufreq_policy *policy) { -struct cpufreq_policy *policy = info;unsigned int eax; eax =cpuid_eax (6 );
@@ -353,6 +352,11 @@ static void cf_check feature_detect(void *info) } } +static void cf_check feature_detect(void *info) +{ +intel_feature_detect (info); +} +static unsigned int check_freqs (const cpumask_t *mask,unsigned int freq,struct acpi_cpufreq_data *data) {
xen/include/acpi/cpufreq/cpufreq.h +2 -0
@@ -243,4 +243,6 @@ int write_userspace_scaling_setspeed(unsigned int cpu, unsigned int freq);void cpufreq_dbs_timer_suspend (void );void cpufreq_dbs_timer_resume (void ); +void intel_feature_detect (struct cpufreq_policy *policy); +#endif /* __XEN_CPUFREQ_PM_H__ */
Signature · 1 line
2.41.0
PATCH v6 4/15 xen/sysctl: Nest cpufreq scaling options
In reply to Jason AndryukAdd a union and struct so that most of the scaling variables of struct xen_get_cpufreq_para are within in a binary-compatible layout. This allows cppc_para to live in the larger union and use uint32_ts - struct xen_cppc_para will be 10 uint32_t's.
The new scaling struct is 3 * uint32_t + 16 bytes CPUFREQ_NAME_LEN + 4 * uint32_t for xen_ondemand = 11 uint32_t. That means the old size is retained, int32_t turbo_enabled doesn't move and it's binary compatible.
The out-of-context memcpy() in xc_get_cpufreq_para() now handles the copying of the fields removed there.
---
v6:
Add Jan's Reviewed-by
v5:
Expand commit message
Change comment to driver/governor
--- tools/include/xenctrl.h | 22 +++++++++++++--------- tools/libs/ctrl/xc_pm.c | 7 +------ tools/misc/xenpm.c | 24 ++++++++++++------------ xen/drivers/acpi/pmstat.c | 27 ++++++++++++++------------- xen/include/public/sysctl.h | 22 +++++++++++++--------- 5 files changed, 53 insertions(+), 49 deletions(-)
tools/include/xenctrl.h +13 -9
@@ -1909,16 +1909,20 @@ struct xc_get_cpufreq_para {uint32_t cpuinfo_cur_freq;uint32_t cpuinfo_max_freq;uint32_t cpuinfo_min_freq; -uint32_t scaling_cur_freq; - -char scaling_governor[CPUFREQ_NAME_LEN ]; -uint32_t scaling_max_freq; -uint32_t scaling_min_freq; - -/* for specific governor */ union { -xc_userspace_t userspace; -xc_ondemand_t ondemand; +struct { +uint32_t scaling_cur_freq; + +char scaling_governor[CPUFREQ_NAME_LEN ]; +uint32_t scaling_max_freq; +uint32_t scaling_min_freq; + +/* for specific governor */ +union { +xc_userspace_t userspace; +xc_ondemand_t ondemand; + } u; + } s; } u;int32_t turbo_enabled;
tools/libs/ctrl/xc_pm.c +1 -6
@@ -265,17 +265,12 @@ int xc_get_cpufreq_para(xc_interface *xch, int cpuid, user_para->cpuinfo_cur_freq = sys_para->cpuinfo_cur_freq; user_para->cpuinfo_max_freq = sys_para->cpuinfo_max_freq; user_para->cpuinfo_min_freq = sys_para->cpuinfo_min_freq; - user_para->scaling_cur_freq = sys_para->scaling_cur_freq; - user_para->scaling_max_freq = sys_para->scaling_max_freq; - user_para->scaling_min_freq = sys_para->scaling_min_freq; user_para->turbo_enabled = sys_para->turbo_enabled;memcpy (user_para->scaling_driver, sys_para->scaling_driver,CPUFREQ_NAME_LEN ); -memcpy (user_para->scaling_governor, - sys_para->scaling_governor,CPUFREQ_NAME_LEN ); -/* copy to user_para no matter what cpufreq governor */ +/* copy to user_para no matter what cpufreq driver/governor */ BUILD_BUG_ON (sizeof (((struct xc_get_cpufreq_para *)0 )->u) !=sizeof (((struct xen_get_cpufreq_para *)0 )->u));
tools/misc/xenpm.c +12 -12
@@ -730,39 +730,39 @@ static void print_cpufreq_para(int cpuid, struct xc_get_cpufreq_para *p_cpufreq)printf ("scaling_avail_gov : %s\n" , p_cpufreq->scaling_available_governors); -printf ("current_governor : %s\n" , p_cpufreq->scaling_governor); -if ( !strncmp (p_cpufreq->scaling_governor, +printf ("current_governor : %s\n" , p_cpufreq->u.s.scaling_governor); +if ( !strncmp (p_cpufreq->u.s.scaling_governor,"userspace" ,CPUFREQ_NAME_LEN ) ) {printf (" userspace specific :\n" );printf (" scaling_setspeed : %u\n" , - p_cpufreq->u.userspace.scaling_setspeed); + p_cpufreq->u.s.u.userspace.scaling_setspeed); } -else if ( !strncmp (p_cpufreq->scaling_governor, +else if ( !strncmp (p_cpufreq->u.s.scaling_governor,"ondemand" ,CPUFREQ_NAME_LEN ) ) {printf (" ondemand specific :\n" );printf (" sampling_rate : max [%u] min [%u] cur [%u]\n" , - p_cpufreq->u.ondemand.sampling_rate_max, - p_cpufreq->u.ondemand.sampling_rate_min, - p_cpufreq->u.ondemand.sampling_rate); + p_cpufreq->u.s.u.ondemand.sampling_rate_max, + p_cpufreq->u.s.u.ondemand.sampling_rate_min, + p_cpufreq->u.s.u.ondemand.sampling_rate);printf (" up_threshold : %u\n" , - p_cpufreq->u.ondemand.up_threshold); + p_cpufreq->u.s.u.ondemand.up_threshold); }printf ("scaling_avail_freq :" );for ( i =0 ; i < p_cpufreq->freq_num; i++ )if ( p_cpufreq->scaling_available_frequencies[i] == - p_cpufreq->scaling_cur_freq ) + p_cpufreq->u.s.scaling_cur_freq )printf (" *%d" , p_cpufreq->scaling_available_frequencies[i]);else printf (" %d" , p_cpufreq->scaling_available_frequencies[i]);printf ("\n" );printf ("scaling frequency : max [%u] min [%u] cur [%u]\n" , - p_cpufreq->scaling_max_freq, - p_cpufreq->scaling_min_freq, - p_cpufreq->scaling_cur_freq); + p_cpufreq->u.s.scaling_max_freq, + p_cpufreq->u.s.scaling_min_freq, + p_cpufreq->u.s.scaling_cur_freq);printf ("turbo mode : %s\n" , p_cpufreq->turbo_enabled ?"enabled" :"disabled or n/a" );
xen/drivers/acpi/pmstat.c +14 -13
@@ -258,37 +258,38 @@ static int get_cpufreq_para(struct xen_sysctl_pm_op *op) cpufreq_driver.get ? cpufreq_driver.get (op->cpuid) : policy->cur; op->u.get_para.cpuinfo_max_freq = policy->cpuinfo.max_freq; op->u.get_para.cpuinfo_min_freq = policy->cpuinfo.min_freq; - op->u.get_para.scaling_cur_freq = policy->cur; - op->u.get_para.scaling_max_freq = policy->max; - op->u.get_para.scaling_min_freq = policy->min; + + op->u.get_para.u.s.scaling_cur_freq = policy->cur; + op->u.get_para.u.s.scaling_max_freq = policy->max; + op->u.get_para.u.s.scaling_min_freq = policy->min;if ( cpufreq_driver.name[0 ] ) -strlcpy (op->u.get_para.scaling_driver, +strlcpy (op->u.get_para.scaling_driver, cpufreq_driver.name,CPUFREQ_NAME_LEN );else strlcpy (op->u.get_para.scaling_driver,"Unknown" ,CPUFREQ_NAME_LEN );if ( policy->governor->name[0 ] ) -strlcpy (op->u.get_para.scaling_governor, +strlcpy (op->u.get_para.u.s.scaling_governor, policy->governor->name,CPUFREQ_NAME_LEN );else -strlcpy (op->u.get_para.scaling_governor,"Unknown" ,CPUFREQ_NAME_LEN ); +strlcpy (op->u.get_para.u.s.scaling_governor,"Unknown" ,CPUFREQ_NAME_LEN );/* governor specific para */ -if ( !strncasecmp (op->u.get_para.scaling_governor, +if ( !strncasecmp (op->u.get_para.u.s.scaling_governor,"userspace" ,CPUFREQ_NAME_LEN ) ) { - op->u.get_para.u.userspace.scaling_setspeed = policy->cur; + op->u.get_para.u.s.u.userspace.scaling_setspeed = policy->cur; } -if ( !strncasecmp (op->u.get_para.scaling_governor, +if ( !strncasecmp (op->u.get_para.u.s.scaling_governor,"ondemand" ,CPUFREQ_NAME_LEN ) ) { ret =get_cpufreq_ondemand_para ( - &op->u.get_para.u.ondemand.sampling_rate_max, - &op->u.get_para.u.ondemand.sampling_rate_min, - &op->u.get_para.u.ondemand.sampling_rate, - &op->u.get_para.u.ondemand.up_threshold); + &op->u.get_para.u.s.u.ondemand.sampling_rate_max, + &op->u.get_para.u.s.u.ondemand.sampling_rate_min, + &op->u.get_para.u.s.u.ondemand.sampling_rate, + &op->u.get_para.u.s.u.ondemand.up_threshold); } op->u.get_para.turbo_enabled =cpufreq_get_turbo_status (op->cpuid);
xen/include/public/sysctl.h +13 -9
@@ -317,16 +317,20 @@ struct xen_get_cpufreq_para {uint32_t cpuinfo_cur_freq;uint32_t cpuinfo_max_freq;uint32_t cpuinfo_min_freq; -uint32_t scaling_cur_freq; - -char scaling_governor[CPUFREQ_NAME_LEN ]; -uint32_t scaling_max_freq; -uint32_t scaling_min_freq; - -/* for specific governor */ union { -struct xen_userspace userspace; -struct xen_ondemand ondemand; +struct { +uint32_t scaling_cur_freq; + +char scaling_governor[CPUFREQ_NAME_LEN ]; +uint32_t scaling_max_freq; +uint32_t scaling_min_freq; + +/* for specific governor */ +union { +struct xen_userspace userspace; +struct xen_ondemand ondemand; + } u; + } s; } u;int32_t turbo_enabled;
Signature · 1 line
2.41.0
PATCH v6 5/15 pmstat&xenpm: Re-arrage for cpufreq union
In reply to Jason AndryukRearrange code now that xen_sysctl_pm_op's get_para fields has the nested union and struct. In particular, the scaling governor information like scaling_available_governors is inside the union, so it is not always available. Move those fields (op->u.get_para.u.s.u.*) together as well as the common fields (ones outside the union like op->u.get_para.turbo_enabled).
With that, gov_num may be 0, so bounce buffer handling needs to be modified.
scaling_governor and other fields inside op->u.get_para.u.s.u.* won't be used for hwp, so this will simplify the change when hwp support is introduced and re-indents these lines all together.
---
v6:
Add Jan's Ack
v5:
Remove some formatting changes
Expand commit message
--- tools/libs/ctrl/xc_pm.c | 12 ++++++++---- tools/misc/xenpm.c | 3 ++- xen/drivers/acpi/pmstat.c | 24 ++++++++++++------------ 3 files changed, 22 insertions(+), 17 deletions(-)
tools/libs/ctrl/xc_pm.c +8 -4
@@ -221,7 +221,7 @@ int xc_get_cpufreq_para(xc_interface *xch, int cpuid, {if ( (!user_para->affected_cpus) || (!user_para->scaling_available_frequencies) || - (!user_para->scaling_available_governors) ) + (user_para->gov_num && !user_para->scaling_available_governors) ) { errno =EINVAL ;return -1 ;
@@ -230,12 +230,15 @@ int xc_get_cpufreq_para(xc_interface *xch, int cpuid, goto unlock_1;if (xc_hypercall_bounce_pre (xch, scaling_available_frequencies) ) goto unlock_2; -if (xc_hypercall_bounce_pre (xch, scaling_available_governors) ) +if ( user_para->gov_num && +xc_hypercall_bounce_pre (xch, scaling_available_governors) ) goto unlock_3;set_xen_guest_handle (sys_para->affected_cpus, affected_cpus);set_xen_guest_handle (sys_para->scaling_available_frequencies, scaling_available_frequencies); -set_xen_guest_handle (sys_para->scaling_available_governors, scaling_available_governors); +if ( user_para->gov_num ) +set_xen_guest_handle (sys_para->scaling_available_governors, + scaling_available_governors); } sysctl.cmd = XEN_SYSCTL_pm_op;
@@ -278,7 +281,8 @@ int xc_get_cpufreq_para(xc_interface *xch, int cpuid, } unlock_4: -xc_hypercall_bounce_post (xch, scaling_available_governors); +if ( user_para->gov_num ) +xc_hypercall_bounce_post (xch, scaling_available_governors); unlock_3:xc_hypercall_bounce_post (xch, scaling_available_frequencies); unlock_2:
tools/misc/xenpm.c +2 -1
@@ -811,7 +811,8 @@ static int show_cpufreq_para_by_cpuid(xc_interface *xc_handle, int cpuid) ret = -ENOMEM ; goto out; } -if (!(p_cpufreq->scaling_available_governors = +if (p_cpufreq->gov_num && + !(p_cpufreq->scaling_available_governors =malloc (p_cpufreq->gov_num *CPUFREQ_NAME_LEN *sizeof (char )))) { fprintf(stderr,
xen/drivers/acpi/pmstat.c +12 -12
@@ -239,6 +239,18 @@ static int get_cpufreq_para(struct xen_sysctl_pm_op *op)if ( ret )return ret; + op->u.get_para.cpuinfo_cur_freq = + cpufreq_driver.get ? cpufreq_driver.get (op->cpuid) : policy->cur; + op->u.get_para.cpuinfo_max_freq = policy->cpuinfo.max_freq; + op->u.get_para.cpuinfo_min_freq = policy->cpuinfo.min_freq; + op->u.get_para.turbo_enabled =cpufreq_get_turbo_status (op->cpuid); + +if ( cpufreq_driver.name[0 ] ) +strlcpy (op->u.get_para.scaling_driver, + cpufreq_driver.name,CPUFREQ_NAME_LEN ); +else +strlcpy (op->u.get_para.scaling_driver,"Unknown" ,CPUFREQ_NAME_LEN ); +if ( !(scaling_available_governors =xzalloc_array (char, gov_num *CPUFREQ_NAME_LEN )) )return -ENOMEM ;
@@ -254,21 +266,10 @@ static int get_cpufreq_para(struct xen_sysctl_pm_op *op)if ( ret )return ret; - op->u.get_para.cpuinfo_cur_freq = - cpufreq_driver.get ? cpufreq_driver.get (op->cpuid) : policy->cur; - op->u.get_para.cpuinfo_max_freq = policy->cpuinfo.max_freq; - op->u.get_para.cpuinfo_min_freq = policy->cpuinfo.min_freq; - op->u.get_para.u.s.scaling_cur_freq = policy->cur; op->u.get_para.u.s.scaling_max_freq = policy->max; op->u.get_para.u.s.scaling_min_freq = policy->min; -if ( cpufreq_driver.name[0 ] ) -strlcpy (op->u.get_para.scaling_driver, - cpufreq_driver.name,CPUFREQ_NAME_LEN ); -else -strlcpy (op->u.get_para.scaling_driver,"Unknown" ,CPUFREQ_NAME_LEN ); -if ( policy->governor->name[0 ] )strlcpy (op->u.get_para.u.s.scaling_governor, policy->governor->name,CPUFREQ_NAME_LEN );
@@ -291,7 +292,6 @@ static int get_cpufreq_para(struct xen_sysctl_pm_op *op) &op->u.get_para.u.s.u.ondemand.sampling_rate, &op->u.get_para.u.s.u.ondemand.up_threshold); } - op->u.get_para.turbo_enabled =cpufreq_get_turbo_status (op->cpuid);return ret; }
Signature · 1 line
2.41.0
PATCH v6 6/15 cpufreq: Add Hardware P-State (HWP) driver
In reply to Jason AndryukFrom the Intel SDM: "Hardware-Controlled Performance States (HWP), which autonomously selects performance states while utilizing OS supplied performance guidance hints."
Enable HWP to run in autonomous mode by poking the correct MSRs. HWP is disabled by default, and cpufreq=hwp enables it.
cpufreq= parsing is expanded to allow cpufreq=hwp;xen. This allows trying HWP and falling back to xen if not available. Only hwp and xen are supported for this fallback feature. hdc is a sub-option under hwp (i.e. cpufreq=hwp,hdc=0) as is verbose.
There is no interface to configure - xen_sysctl_pm_op/xenpm will be extended to configure in subsequent patches. It will run with the default values, which should be the default 0x80 (out of 0x0-0xff) energy/performance preference.
Unscientific powertop measurement of an mostly idle, customized OpenXT install:
A 10th gen 6-core laptop showed battery discharge drop from ~9.x to ~7.x watts.
A 8th gen 4-core laptop dropped from ~10 to ~9
Power usage depends on many factors, especially display brightness, but this does show a power saving in balanced mode when CPU utilization is low.
HWP isn't compatible with an external governor - it doesn't take explicit frequency requests. Therefore a minimal internal governor, hwp, is also added as a placeholder.
While adding to the xen-command-line.pandoc entry, un-nest verbose from minfreq. They are independent.
With cpufreq=hwp,verbose, HWP prints processor capabilities that are not used by the code, like HW_FEEDBACK. This is done because otherwise there isn't a convenient way to query the information.
Xen doesn't use the HWP interrupt, so it is disabled like in the Linux pstate driver.
---
We disable on cpuid_level < 0x16. cpuid(0x16) is used to get the cpu frequencies for calculating the APERF/MPERF. Without it, things would still work, but the average cpu frequency output would be wrong.
My 8th & 10th gen test systems both report:
(XEN) HWP: 1 notify: 1 act_window: 1 energy_perf: 1 pkg_level: 0 peci: 0 (XEN) HWP: Hardware Duty Cycling (HDC) supported
(XEN) HWP: HW_FEEDBACK not supported
We can't use parse_boolean() since it requires a single name=val string and cpufreq_handle_common_option is provided two strings. Use parse_bool() and manual handle no-hwp.
FAST_IA32_HWP_REQUEST was removed in v2. The check in v1 was wrong, it's a model specific feature and the CPUID bit is only available after enabling via the MSR. Support was untested since I don't have hardware with the feature. Writes are expected to be infrequent, so just leave it out.
---
v2:
Alphabetize headers
Re-work driver registration
name hwp_drv_data anonymous union "hw"
Drop hwp_verbose_cont
style cleanups
Condense hwp_governor switchhwp_cpufreq_target remove .raw from hwp_req assignment Use typed-pointer in a few functions
Pass type to xzalloc
Add HWP_ENERGY_PERF_BALANCE/IA32_ENERGY_BIAS_BALANCE defines Add XEN_HWP_GOVERNOR define for "hwp-internal" Capitalize CPUID and MSR defines
Change '_' to '-' for energy-perf & act-window Read-modify-write MSRs updates
Use FAST_IA32_HWP_REQUEST_MSR_ENABLE define
constify pointer in hwp_set_misc_turbo
Add space after non-fallthrough break in governor switch Add IA32_ENERGY_BIAS_MASK define
Check CPUID_PM_LEAK for energy bias when needed
Fail initialization with curr_req = -1
Fold hwp_read_capabilities into hwp_init_msrs
Add command line cpufreq=xen:hwp
Add command line cpufreq=xen:hdc
Use per_cpu for hwp_drv_data pointers
Move hwp_energy_perf_bias call into hwp_write_request energy_perf 0 is valid, so hwp_energy_perf_bias cannot be skipped Ensure we don't generate interrupts
Remove Fast Write of Uncore MSR
Initialize hwp_drv_data from curr_req
Use SPDX line instead of license text in hwp.c
v3:
Add cf_check to cpufreq_gov_hwp_init() - Marek
Print cpuid_level with %#x - Marek
v4:
Use BIT() for CPUID and MSR bits
Move __initdata after type
Add __ro_after_init to feature_*
Remove aperf/mperf comment
Move feature_hwp_energy_perf { to newline
Remove _IA32_ infix
Use unsigned int & bool for bitfields
Require energy perf pref (Remove ENERGY_PERF_BIAS support) Initialize activity_window
Return errors on wrmsr failure
Change command line to: cpufreq=xen:hwp
Move hdc into the hwp-specific handle_options
Drop feature_hwp_energy_perf, feature_hwp_pkg_level_ctl & feature_hwp_peci Print features before exiting when energy/performance preference isn't available Disable HWP MSR on initialization error
Change hwp_ print macros to add prefixes
Disable HDC when hdc=0 - (opt_hdc no longer initdata)
Mark hwp governor internal and use "hwp" name
Add XEN_HWP_DRIVER
Use top-level cpufreq=hwp command line option
Document that cpufreq=hwp falls back to cpufreq=xen without hardware Add SPDX suffix GPL-2.0-only
v5:
Use _AC() macro in MSR_IA32_MISC_ENABLE_TURBO_DISENGAGE definition hwp_err arg re-ordering
Use XEN_HWP_DRIVER_NAME
Use cpufreq.h for all declarations
Clear feature_hdc on failure and print a message
Use unnamed bitfields instead of reservered
Remove asm/io.h include
static DEFINE_PER_CPU_READ_MOSTLY(struct hwp_drv_data Remove some empty newlines
Align feature_hdc assignment
Remove feature_hwp
Remove unnecesary return at end of void hwp_init_msrs() BUILD_BUG_ON member variable
Reformat a compound if
Clear pre_cpu hwp_drv_data before xfree()
Only print HWP capabilities for CPU 0
Specify processor models in turbo comment
Use arg[1] in setup_cpufreq_option()
Remove some log messages
Drop double newline
Parse verbose as a boolean instead of the custom parsing. Support cpufreq=hwp;xen fallback
Call hwp_available() from hwp_register_driver()
Move cpufreq_govenor_internal setting to hwp_register_driver
v6:
docs: mention verbose applies to both.
Use cpufreq=hwp;xen,verbose example with verbose at then end. Declare induction i inside for loop
Add CPUFREQ_none
Only call cpufreq fallback for -ENODEV
Brace on newline fixes
hdc_set_pkg_hdc_ctl()/hdc_set_pm_ctl1() return boolean
Continue without hdc
Consolidate hdc if statement
Use hwp_req variable for BUILD_BUG_ON
Newline between declarations and statement__initdata for cpufreq_xen_opts/cpufreq_xen_cnt
Only print HWP_REQUEST when differing from BSP.
Remove MSR_PM_ENABLE printing
Move hdc_set_pkg_hdc_ctl(), hdc_set_pm_ctl1(), hwp_get_cpu_speeds(), and
hwp_init_msrs() to before their sole caller, hwp_cpufreq_cpu_init()
Fix cpufreq= parsing without options (set ret=0)
Drop stray s NULL check
Return -EINVAL from hwp_cmdline_parse()
Latch first CPU HWP request and print differences
Use strpbrk to split on ',' or ':' for arg in xen/hwp do..while Limit hwp parsing error to just current option with %.*s and (end ?: e) - s
docs: Expand and clarify the handling of verbose with cpufreq fallbacks.
--- docs/misc/xen-command-line.pandoc | 20 +- xen/arch/x86/acpi/cpufreq/Makefile | 1 + xen/arch/x86/acpi/cpufreq/cpufreq.c | 21 +- xen/arch/x86/acpi/cpufreq/hwp.c | 521 ++++++++++++++++++++++++++ xen/arch/x86/include/asm/cpufeature.h | 12 +- xen/arch/x86/include/asm/msr-index.h | 15 +- xen/drivers/cpufreq/cpufreq.c | 59 ++- xen/include/acpi/cpufreq/cpufreq.h | 10 + xen/include/public/sysctl.h | 2 + 9 files changed, 646 insertions(+), 15 deletions(-) create mode 100644 xen/arch/x86/acpi/cpufreq/hwp.c
docs/misc/xen-command-line.pandoc +19 -1
@@ -499,7 +499,7 @@ If set, force use of the performance counters for oprofile, rather than detectin available support. ### cpufreq -> `= none | {{ <boolean> | xen } [:[powersave|performance|ondemand|userspace][,<maxfreq>][,[<minfreq>][,[verbose]]]]} | dom0-kernel` +> `= none | {{ <boolean> | xen } { [:[powersave|performance|ondemand|userspace][,[<maxfreq>]][,[<minfreq>]]] } [,verbose]} | dom0-kernel | hwp[:[<hdc>][,verbose]]` > Default: `xen`
@@ -510,6 +510,24 @@ choice of `dom0-kernel` is deprecated and not supported by all Dom0 kernels. * `<maxfreq>` and `<minfreq>` are integers which represent max and min processor frequencies respectively. * `verbose` option can be included as a string or also as `verbose=<integer>` + for `xen`. It is a boolean for `hwp`. +* `hwp` selects Hardware-Controlled Performance States (HWP) on supported Intel + hardware. HWP is a Skylake+ feature which provides better CPU power + management. The default is disabled. If `hwp` is selected, but hardware + support is not available, Xen will fallback to cpufreq=xen. +* `<hdc>` is a boolean to enable Hardware Duty Cycling (HDC). HDC enables the + processor to autonomously force physical package components into idle state. + The default is enabled, but the option only applies when `hwp` is enabled. + +There is also support for `;`-separated fallback options: +`cpufreq=hwp;xen,verbose`. This first tries `hwp` and falls back to `xen` if +unavailable. Note: The `verbose` suboption is handled globally. Setting it +for either the primary or fallback option applies to both irrespective of where +it is specified. + +Note: grub2 requires to escape or quote ';', so `"cpufreq=hwp;xen"` should be +specified within double quotes inside grub.cfg. Refer to the grub2 +documentation for more information. ### cpuid (x86) > `= List of comma separated booleans`
xen/arch/x86/acpi/cpufreq/Makefile +1 -0
@@ -1,2 +1,3 @@ obj-y += cpufreq.o +obj-y += hwp.o obj-y += powernow.o
xen/arch/x86/acpi/cpufreq/cpufreq.c +20 -1
@@ -642,7 +642,26 @@ static int __init cf_check cpufreq_driver_init(void)switch ( boot_cpu_data.x86_vendor ) {case X86_VENDOR_INTEL : - ret =cpufreq_register_driver (&acpi_cpufreq_driver); + ret = -ENOENT ; + +for (unsigned int i =0 ; i < cpufreq_xen_cnt; i++ ) + { +switch ( cpufreq_xen_opts[i] ) + { +case CPUFREQ_xen: + ret =cpufreq_register_driver (&acpi_cpufreq_driver); +break ; +case CPUFREQ_hwp: + ret =hwp_register_driver (); +break ; +case CPUFREQ_none: + ret =0 ; +break ; + } + +if ( ret != -ENODEV ) +break ; + }break ;case X86_VENDOR_AMD :
xen/arch/x86/acpi/cpufreq/hwp.c new file +521 -0
521 lines not on this page · raw message
xen/arch/x86/include/asm/cpufeature.h +10 -2
@@ -52,8 +52,16 @@ static inline bool boot_cpu_has(unsigned int feat)return cpu_has (&boot_cpu_data, feat); } -#define CPUID_PM_LEAF 6 -#define CPUID6_ECX_APERFMPERF_CAPABILITY 0x1 +#define CPUID_PM_LEAF 6 +#define CPUID6_EAX_HWP BIT(7, U) +#define CPUID6_EAX_HWP_NOTIFICATION BIT(8, U) +#define CPUID6_EAX_HWP_ACTIVITY_WINDOW BIT(9, U) +#define CPUID6_EAX_HWP_ENERGY_PERFORMANCE_PREFERENCE BIT(10, U) +#define CPUID6_EAX_HWP_PACKAGE_LEVEL_REQUEST BIT(11, U) +#define CPUID6_EAX_HDC BIT(13, U) +#define CPUID6_EAX_HWP_PECI BIT(16, U) +#define CPUID6_EAX_HW_FEEDBACK BIT(19, U) +#define CPUID6_ECX_APERFMPERF_CAPABILITY BIT(0, U)/* CPUID level 0x00000001.edx */ #define cpu_has_fpu 1
xen/arch/x86/include/asm/msr-index.h +14 -1
@@ -151,6 +151,13 @@#define MSR_PKRS 0x000006e1 +#define MSR_PM_ENABLE 0x00000770 +#define PM_ENABLE_HWP_ENABLE BIT(0, ULL) + +#define MSR_HWP_CAPABILITIES 0x00000771 +#define MSR_HWP_INTERRUPT 0x00000773 +#define MSR_HWP_REQUEST 0x00000774 +#define MSR_X2APIC_FIRST 0x00000800#define MSR_X2APIC_LAST 0x000008ff
@@ -165,6 +172,11 @@#define PASID_PASID_MASK 0x000fffff#define PASID_VALID (_AC(1, ULL) << 31) +#define MSR_PKG_HDC_CTL 0x00000db0 +#define PKG_HDC_CTL_HDC_PKG_ENABLE BIT(0, ULL) +#define MSR_PM_CTL1 0x00000db1 +#define PM_CTL1_HDC_ALLOW_BLOCK BIT(0, ULL) +#define MSR_UARCH_MISC_CTRL 0x00001b01#define UARCH_CTRL_DOITM (_AC(1, ULL) << 0)
@@ -466,7 +478,8 @@#define MSR_IA32_MISC_ENABLE_MONITOR_ENABLE (1<<18)#define MSR_IA32_MISC_ENABLE_LIMIT_CPUID (1<<22)#define MSR_IA32_MISC_ENABLE_XTPR_DISABLE (1<<23) -#define MSR_IA32_MISC_ENABLE_XD_DISABLE (_AC(1, ULL) << 34) +#define MSR_IA32_MISC_ENABLE_XD_DISABLE (_AC(1, ULL) << 34) +#define MSR_IA32_MISC_ENABLE_TURBO_DISENGAGE (_AC(1, ULL) << 38)#define MSR_IA32_TSC_DEADLINE 0x000006E0#define MSR_IA32_ENERGY_PERF_BIAS 0x000001b0
xen/drivers/cpufreq/cpufreq.c +49 -10
89 lines not on this page · raw message
xen/include/acpi/cpufreq/cpufreq.h +10 -0
@@ -24,6 +24,13 @@ DECLARE_PER_CPU(spinlock_t, cpufreq_statistic_lock);extern bool_t cpufreq_verbose; +enum cpufreq_xen_opt { + CPUFREQ_none, + CPUFREQ_xen, + CPUFREQ_hwp, +}; +extern enum cpufreq_xen_opt cpufreq_xen_opts[2 ]; +extern unsigned int cpufreq_xen_cnt;struct cpufreq_governor ;struct acpi_cpufreq_data {
@@ -245,4 +252,7 @@ void cpufreq_dbs_timer_resume(void);void intel_feature_detect (struct cpufreq_policy *policy); +int hwp_cmdline_parse (const char *s,const char *e); +int hwp_register_driver (void ); +#endif /* __XEN_CPUFREQ_PM_H__ */
xen/include/public/sysctl.h +2 -0
@@ -296,6 +296,8 @@ struct xen_ondemand {uint32_t up_threshold; }; +#define XEN_HWP_DRIVER_NAME "hwp" +/* * cpufreq para name of this structure named * same as sysfs file name of native linux
Signature · 1 line
2.41.0
Re: [PATCH v6 06/15] cpufreq: Add Hardware P-State (HWP) driver
Quoted 61 lines · Jason Andryuk
xen/arch/x86/acpi/cpufreq/hwp.c new file +58
-0@@ -0,0 +1,521 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* +* hwp.c cpufreq driver to run Intel Hardware P-States (HWP) +* +* Copyright (C) 2021 Jason Andryuk <[email protected]> +*/ + +#include <xen/cpumask.h> +#include <xen/init.h> +#include <xen/param.h> +#include <xen/xmalloc.h> +#include <asm/msr.h> +#include <acpi/cpufreq/cpufreq.h> + +static bool __ro_after_init feature_hwp_notification; +static bool __ro_after_init feature_hwp_activity_window; + +static bool __ro_after_init feature_hdc; + +static bool __ro_after_init opt_cpufreq_hdc = true; + +union hwp_request +{ +struct + { +unsigned int min_perf:8 ; +unsigned int max_perf:8 ; +unsigned int desired:8 ; +unsigned int energy_perf:8 ; +unsigned int activity_window:10 ; +bool package_control:1 ; + unsigned int :16; +bool activity_window_valid:1 ; +bool energy_perf_valid:1 ; +bool desired_valid:1 ; +bool max_perf_valid:1 ; +bool min_perf_valid:1 ; + }; +uint64_t raw; +}; + +struct hwp_drv_data +{ +union + { +uint64_t hwp_caps; +struct + { +unsigned int highest:8 ; +unsigned int guaranteed:8 ; +unsigned int most_efficient:8 ; +unsigned int lowest:8 ; + unsigned int :32; + } hw; + }; +union hwp_request curr_req; +int ret; +uint16_t activity_window;
xen/arch/x86/acpi/cpufreq/hwp.c line 68
Quoted 10 lines
xen/arch/x86/acpi/cpufreq/hwp.c new file +10
-0+uint8_t minimum; +uint8_t maximum; +uint8_t desired; +uint8_t energy_perf; +}; +static DEFINE_PER_CPU_READ_MOSTLY(struct hwp_drv_data *, hwp_drv_data); + +#define hwp_err (cpu, fmt, ...) \ + printk(XENLOG_ERR "HWP: CPU%u error: " fmt, cpu, ##__VA_ARGS__) +#define hwp_info (fmt, ...) printk(XENLOG_INFO "HWP: " fmt, ##__VA_ARGS__)
I'm not convinced ", ##__VA_ARGS__" is a good construct to use. I notice we have a few instances (mainly in code inherited from elsewhere), but I think it ought to either be plain C99 style (without the ##) or purely the gcc extension form (not using __VA_ARGS__).
xen/arch/x86/acpi/cpufreq/hwp.c line 72
Quoted 4 lines
xen/arch/x86/acpi/cpufreq/hwp.c new file +4
-0+#define hwp_verbose (fmt, ...) \ +({ \ + if ( cpufreq_verbose ) \ + printk(XENLOG_DEBUG "HWP: " fmt, ##__VA_ARGS__); \
(One more here then.)
xen/arch/x86/acpi/cpufreq/hwp.c line 99
Quoted 1 line
xen/arch/x86/acpi/cpufreq/hwp.c new file +1
-0+static bool hwp_handle_option (const char *s,const char *end)
__init?
xen/arch/x86/acpi/cpufreq/hwp.c line 329
Quoted 11 lines
xen/arch/x86/acpi/cpufreq/hwp.c new file +11
-0+static void hwp_get_cpu_speeds (struct cpufreq_policy *policy) +{ +uint32_t base_khz, max_khz, bus_khz, edx; + +cpuid (0x16 , &base_khz, &max_khz, &bus_khz, &edx); + + policy->cpuinfo.perf_freq = base_khz *1000 ; + policy->cpuinfo.min_freq = base_khz *1000 ; + policy->cpuinfo.max_freq = max_khz *1000 ; + policy->min = base_khz *1000 ; + policy->max = max_khz *1000 ;
Earlier on I asked what about cases where the CPUID output yields some zero values (as I know can happen). Iirc you said this doesn't affect functionality, but wouldn't it make sense to have a comment to this effect here (proving the cases were thought through).
Quoted 39 lines
xen/arch/x86/acpi/cpufreq/hwp.c new file +39
-0+static void cf_check hwp_init_msrs(void *info) +{ +struct cpufreq_policy *policy = info; +struct hwp_drv_data *data =this_cpu (hwp_drv_data); +uint64_t val; + +/* +* Package level MSR, but we don't have a good idea of packages here, so +* just do it everytime. +*/ +if (rdmsr_safe (MSR_PM_ENABLE , val) ) + { +hwp_err (policy->cpu,"rdmsr_safe(MSR_PM_ENABLE)\n" ); + data->curr_req.raw =-1 ; +return ; + } + +/* Ensure we don't generate interrupts */ +if ( feature_hwp_notification ) +wrmsr_safe (MSR_HWP_INTERRUPT ,0 ); + +if ( !(val &PM_ENABLE_HWP_ENABLE ) ) + { + val |=PM_ENABLE_HWP_ENABLE ; +if (wrmsr_safe (MSR_PM_ENABLE , val) ) + { +hwp_err (policy->cpu,"wrmsr_safe(MSR_PM_ENABLE, %lx)\n" , val); + data->curr_req.raw =-1 ; +return ; + } + } + +if (rdmsr_safe (MSR_HWP_CAPABILITIES , data->hwp_caps) ) + { +hwp_err (policy->cpu,"rdmsr_safe(MSR_HWP_CAPABILITIES)\n" ); + goto error; + } + +if (rdmsr_safe (MSR_HWP_REQUEST , data->curr_req.raw) )
xen/arch/x86/acpi/cpufreq/hwp.c line 381
Quoted 10 lines
xen/arch/x86/acpi/cpufreq/hwp.c new file +10
-0+ { +hwp_err (policy->cpu,"rdmsr_safe(MSR_HWP_REQUEST)\n" ); + goto error; + } + +/* +* Check for APERF/MPERF support in hardware +* also check for boost/turbo support +*/ +intel_feature_detect (policy);
Nit: The comment could do with adding at least a comma or semicolon.
xen/arch/x86/acpi/cpufreq/hwp.c line 388
Quoted 6 lines
xen/arch/x86/acpi/cpufreq/hwp.c new file +6
-0+if ( feature_hdc && + (!hdc_set_pkg_hdc_ctl (policy->cpu, opt_cpufreq_hdc) || + !hdc_set_pm_ctl1 (policy->cpu, opt_cpufreq_hdc)) ) + { +hwp_err (policy->cpu,"Disabling HDC support\n" ); + feature_hdc = false;
Nit: Too deep indentation.
Quoted 27 lines
xen/arch/x86/acpi/cpufreq/hwp.c new file +27
-0+static int cf_check hwp_cpufreq_cpu_init(struct cpufreq_policy *policy) +{ +static union hwp_request initial_req; +unsigned int cpu = policy->cpu; +struct hwp_drv_data *data; +bool first_run = false; + + data = xzalloc(struct hwp_drv_data); +if ( !data ) +return -ENOMEM ; + + policy->governor = &cpufreq_gov_hwp; + +per_cpu (hwp_drv_data, cpu) = data; + +on_selected_cpus (cpumask_of (cpu), hwp_init_msrs, policy,1 ); + +if ( data->curr_req.raw ==-1 ) + { +hwp_err (cpu,"Could not initialize HWP properly\n" ); +per_cpu (hwp_drv_data, cpu) =NULL ; +xfree (data); +return -ENODEV ; + } + + data->minimum = data->curr_req.min_perf; + data->maximum = data->curr_req.max_perf;
xen/arch/x86/acpi/cpufreq/hwp.c line 438
Quoted 10 lines
xen/arch/x86/acpi/cpufreq/hwp.c new file +10
-0+ data->desired = data->curr_req.desired; + data->energy_perf = data->curr_req.energy_perf; + data->activity_window = data->curr_req.activity_window; + +if ( initial_req.raw ==0 ) + { +hwp_verbose ("CPU%u: HWP_CAPABILITIES: %016lx\n" , cpu, data->hwp_caps); + initial_req = data->curr_req; + first_run = true; + }
What part of data->curr_req is guaranteed to be non-0 (for the condition around ...
xen/arch/x86/acpi/cpufreq/hwp.c line 442
Quoted 3 lines
xen/arch/x86/acpi/cpufreq/hwp.c new file +3
-0+if ( first_run || data->curr_req.raw != initial_req.raw ) +hwp_verbose ("CPU%u: rdmsr HWP_REQUEST %016lx\n" , cpu, + data->curr_req.raw);
... this logging to be effective)?
Quoted 19 lines
xen/arch/x86/acpi/cpufreq/hwp.c new file +19
-0+static void cf_check hwp_set_misc_turbo(void *info) +{ +const struct cpufreq_policy *policy = info; +struct hwp_drv_data *data =per_cpu (hwp_drv_data, policy->cpu); +uint64_t msr; + + data->ret =0 ; + +if (rdmsr_safe (MSR_IA32_MISC_ENABLE , msr) ) + { +hwp_verbose ("CPU%u: error rdmsr_safe(MSR_IA32_MISC_ENABLE)\n" , + policy->cpu); + data->ret = -EINVAL ; + +return ; + } + +if ( policy->turbo ==CPUFREQ_TURBO_ENABLED ) + msr &= ~MSR_IA32_MISC_ENABLE_TURBO_DISENGAGE ;
xen/arch/x86/acpi/cpufreq/hwp.c line 491
Quoted 10 lines
xen/arch/x86/acpi/cpufreq/hwp.c new file +10
-0+else + msr |=MSR_IA32_MISC_ENABLE_TURBO_DISENGAGE ; + +if (wrmsr_safe (MSR_IA32_MISC_ENABLE , msr) ) + { +hwp_verbose ("CPU%u: error wrmsr_safe(MSR_IA32_MISC_ENABLE): %016lx\n" , + policy->cpu, msr); + data->ret = -EINVAL ; + } +}
Neither of the two -EINVAL really indicate an invalid argument that was passed. Maybe EACCES (or less desirably EFAULT)?
Quoted 37 lines
xen/arch/x86/acpi/cpufreq/hwp.c new file +26
-6@@ -89,15 +96,45 @@ static int __init cf_check setup_cpufreq_option(const char *str)return 0 ; } -if ( choice >0 || !cmdline_strcmp (str,"xen" ) ) + do { - xen_processor_pmbits |=XEN_PROCESSOR_PM_PX ; - cpufreq_controller = FREQCTL_xen; -if ( *arg && *(arg +1 ) ) -return cpufreq_cmdline_parse (arg +1 ); - } + const char *end = strchr(str, ';'); + + if ( end == NULL ) + end = strchr(str, '\0'); + + arg = strpbrk(str, ",:"); + if ( !arg || arg > end ) + arg = strchr(str, '\0'); + + if ( cpufreq_xen_cnt == ARRAY_SIZE(cpufreq_xen_opts) ) + return -E2BIG; + + if ( choice > 0 || !cmdline_strcmp(str, "xen") ) + { + xen_processor_pmbits |= XEN_PROCESSOR_PM_PX; + cpufreq_controller = FREQCTL_xen; + cpufreq_xen_opts[cpufreq_xen_cnt++] = CPUFREQ_xen; + ret = 0; + if ( arg[0] && arg[1] ) + ret = cpufreq_cmdline_parse(arg + 1, end); + } + else if ( choice < 0 && !cmdline_strcmp(str, "hwp") ) + { + xen_processor_pmbits |= XEN_PROCESSOR_PM_PX; + cpufreq_controller = FREQCTL_xen;
xen/arch/x86/acpi/cpufreq/hwp.c static int __init cf_check setup_cpufreq_option(const char *str) · line 135
Quoted 10 lines
xen/arch/x86/acpi/cpufreq/hwp.c new file +10
-0+ cpufreq_xen_opts[cpufreq_xen_cnt++] = CPUFREQ_hwp; + ret =0 ; +if ( arg[0 ] && arg[1 ] ) + ret =hwp_cmdline_parse (arg +1 , end); + } +else + ret = -EINVAL ; + + str = end ? ++end : end; + }while ( choice <0 && ret ==0 && *str );
According to the earlier of the two lines, str may be NULL and hence cannot be dereferenced without first checking to be non-NULL. Earlier in the loop though you ensure end cannot be NULL. In that case, however, you point end at the nul character, so the increment above would point end at the next following one. So my guess is that you meant
str = *end ? ++end : end;
Jan
Re: [PATCH v6 06/15] cpufreq: Add Hardware P-State (HWP) driver
Quoted 70 lines · Jan Beulich
Quoted 68 lines · Jason Andryuk
xen/arch/x86/acpi/cpufreq/hwp.c new file +65
-0@@ -0,0 +1,521 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* +* hwp.c cpufreq driver to run Intel Hardware P-States (HWP) +* +* Copyright (C) 2021 Jason Andryuk <[email protected]> +*/ + +#include <xen/cpumask.h> +#include <xen/init.h> +#include <xen/param.h> +#include <xen/xmalloc.h> +#include <asm/msr.h> +#include <acpi/cpufreq/cpufreq.h> + +static bool __ro_after_init feature_hwp_notification; +static bool __ro_after_init feature_hwp_activity_window; + +static bool __ro_after_init feature_hdc; + +static bool __ro_after_init opt_cpufreq_hdc = true; + +union hwp_request +{ +struct + { +unsigned int min_perf:8 ; +unsigned int max_perf:8 ; +unsigned int desired:8 ; +unsigned int energy_perf:8 ; +unsigned int activity_window:10 ; +bool package_control:1 ; + unsigned int :16; +bool activity_window_valid:1 ; +bool energy_perf_valid:1 ; +bool desired_valid:1 ; +bool max_perf_valid:1 ; +bool min_perf_valid:1 ; + }; +uint64_t raw; +}; + +struct hwp_drv_data +{ +union + { +uint64_t hwp_caps; +struct + { +unsigned int highest:8 ; +unsigned int guaranteed:8 ; +unsigned int most_efficient:8 ; +unsigned int lowest:8 ; + unsigned int :32; + } hw; + }; +union hwp_request curr_req; +int ret; +uint16_t activity_window; +uint8_t minimum; +uint8_t maximum; +uint8_t desired; +uint8_t energy_perf; +}; +static DEFINE_PER_CPU_READ_MOSTLY(struct hwp_drv_data *, hwp_drv_data); +
Quoted 8 lines
xen/arch/x86/acpi/cpufreq/hwp.c line 68
Quoted 3 lines
xen/arch/x86/acpi/cpufreq/hwp.c new file +3
-0+#define hwp_err (cpu, fmt, ...) \ + printk(XENLOG_ERR "HWP: CPU%u error: " fmt, cpu, ##__VA_ARGS__) +#define hwp_info (fmt, ...) printk(XENLOG_INFO "HWP: " fmt, ##__VA_ARGS__)I'm not convinced ", ##__VA_ARGS__" is a good construct to use. I notice we have a few instances (mainly in code inherited from elsewhere), but I think it ought to either be plain C99 style (without the ##) or purely the gcc extension form (not using
__VA_ARGS__).
Using plain __VA_ARGS__ doesn't work for the cases without arguments:arch/x86/acpi/cpufreq/hwp.c:78:53: error: expected expression before ‘)’ token
78 | printk(XENLOG_DEBUG "HWP: " fmt, __VA_ARGS__); \
| ^arch/x86/acpi/cpufreq/hwp.c:201:9: note: in expansion of macro ‘hwp_verbose’
201 | hwp_verbose("disabled: No energy/performance
preference available");
| ^~~~~~~~~~~I can use "__VA_OPT__(,) __VA_ARGS__" though.
Quoted 10 lines
xen/arch/x86/acpi/cpufreq/hwp.c line 72
Quoted 4 lines
xen/arch/x86/acpi/cpufreq/hwp.c new file +4
-0+#define hwp_verbose (fmt, ...) \ +({ \ + if ( cpufreq_verbose ) \ + printk(XENLOG_DEBUG "HWP: " fmt, ##__VA_ARGS__); \(One more here then.)
xen/arch/x86/acpi/cpufreq/hwp.c line 99
Quoted 1 line
xen/arch/x86/acpi/cpufreq/hwp.c new file +1
-0+static bool hwp_handle_option (const char *s,const char *end)
__init?
Yes, thanks.
Quoted 8 lines
Quoted 8 lines
xen/arch/x86/acpi/cpufreq/hwp.c new file +8
-0+static void hwp_get_cpu_speeds (struct cpufreq_policy *policy) +{ +uint32_t base_khz, max_khz, bus_khz, edx; + +cpuid (0x16 , &base_khz, &max_khz, &bus_khz, &edx); + + policy->cpuinfo.perf_freq = base_khz *1000 ; + policy->cpuinfo.min_freq = base_khz *1000 ;
Quoted 8 lines
xen/arch/x86/acpi/cpufreq/hwp.c line 329
Quoted 3 lines
xen/arch/x86/acpi/cpufreq/hwp.c new file +3
-0+ policy->cpuinfo.max_freq = max_khz *1000 ; + policy->min = base_khz *1000 ; + policy->max = max_khz *1000 ;Earlier on I asked what about cases where the CPUID output yields some zero values (as I know can happen). Iirc you said this doesn't affect functionality, but wouldn't it make sense to have a comment to this effect here (proving the cases were thought through).
Sure.
Quoted 43 lines
Quoted 43 lines
xen/arch/x86/acpi/cpufreq/hwp.c new file +43
-0+static void cf_check hwp_init_msrs(void *info) +{ +struct cpufreq_policy *policy = info; +struct hwp_drv_data *data =this_cpu (hwp_drv_data); +uint64_t val; + +/* +* Package level MSR, but we don't have a good idea of packages here, so +* just do it everytime. +*/ +if (rdmsr_safe (MSR_PM_ENABLE , val) ) + { +hwp_err (policy->cpu,"rdmsr_safe(MSR_PM_ENABLE)\n" ); + data->curr_req.raw =-1 ; +return ; + } + +/* Ensure we don't generate interrupts */ +if ( feature_hwp_notification ) +wrmsr_safe (MSR_HWP_INTERRUPT ,0 ); + +if ( !(val &PM_ENABLE_HWP_ENABLE ) ) + { + val |=PM_ENABLE_HWP_ENABLE ; +if (wrmsr_safe (MSR_PM_ENABLE , val) ) + { +hwp_err (policy->cpu,"wrmsr_safe(MSR_PM_ENABLE, %lx)\n" , val); + data->curr_req.raw =-1 ; +return ; + } + } + +if (rdmsr_safe (MSR_HWP_CAPABILITIES , data->hwp_caps) ) + { +hwp_err (policy->cpu,"rdmsr_safe(MSR_HWP_CAPABILITIES)\n" ); + goto error; + } + +if (rdmsr_safe (MSR_HWP_REQUEST , data->curr_req.raw) ) + { +hwp_err (policy->cpu,"rdmsr_safe(MSR_HWP_REQUEST)\n" ); + goto error; + }
Quoted 8 lines
xen/arch/x86/acpi/cpufreq/hwp.c line 381
Quoted 6 lines
xen/arch/x86/acpi/cpufreq/hwp.c new file +6
-0+ +/* +* Check for APERF/MPERF support in hardware +* also check for boost/turbo support +*/ +intel_feature_detect (policy);Nit: The comment could do with adding at least a comma or semicolon.
Will change to "Check for turbo support." APERF/MPERF was removed from intel_feature_detect() in commit 4dd16c44152f ("x86/cpufreq:
Rework APERF/MPERF handling").
Quoted 8 lines
xen/arch/x86/acpi/cpufreq/hwp.c line 388
Quoted 6 lines
xen/arch/x86/acpi/cpufreq/hwp.c new file +6
-0+if ( feature_hdc && + (!hdc_set_pkg_hdc_ctl (policy->cpu, opt_cpufreq_hdc) || + !hdc_set_pm_ctl1 (policy->cpu, opt_cpufreq_hdc)) ) + { +hwp_err (policy->cpu,"Disabling HDC support\n" ); + feature_hdc = false;Nit: Too deep indentation.
Yes, thanks.
Quoted 41 lines
Quoted 27 lines
xen/arch/x86/acpi/cpufreq/hwp.c new file +27
-0+static int cf_check hwp_cpufreq_cpu_init(struct cpufreq_policy *policy) +{ +static union hwp_request initial_req; +unsigned int cpu = policy->cpu; +struct hwp_drv_data *data; +bool first_run = false; + + data = xzalloc(struct hwp_drv_data); +if ( !data ) +return -ENOMEM ; + + policy->governor = &cpufreq_gov_hwp; + +per_cpu (hwp_drv_data, cpu) = data; + +on_selected_cpus (cpumask_of (cpu), hwp_init_msrs, policy,1 ); + +if ( data->curr_req.raw ==-1 ) + { +hwp_err (cpu,"Could not initialize HWP properly\n" ); +per_cpu (hwp_drv_data, cpu) =NULL ; +xfree (data); +return -ENODEV ; + } + + data->minimum = data->curr_req.min_perf; + data->maximum = data->curr_req.max_perf;xen/arch/x86/acpi/cpufreq/hwp.c line 438
Quoted 10 lines
xen/arch/x86/acpi/cpufreq/hwp.c new file +10
-0+ data->desired = data->curr_req.desired; + data->energy_perf = data->curr_req.energy_perf; + data->activity_window = data->curr_req.activity_window; + +if ( initial_req.raw ==0 ) + { +hwp_verbose ("CPU%u: HWP_CAPABILITIES: %016lx\n" , cpu, data->hwp_caps); + initial_req = data->curr_req; + first_run = true; + }What part of
data->curr_reqis guaranteed to be non-0 (for the condition around ...
Quoted 5 lines
xen/arch/x86/acpi/cpufreq/hwp.c line 442
Quoted 3 lines
xen/arch/x86/acpi/cpufreq/hwp.c new file +3
-0+if ( first_run || data->curr_req.raw != initial_req.raw ) +hwp_verbose ("CPU%u: rdmsr HWP_REQUEST %016lx\n" , cpu, + data->curr_req.raw);... this logging to be effective)?
Hmmm. I think you are correct that there is no guarantee that data->curr_req will be non-zero. i.e. a BIOS could zero the whole register. In practice, I see 0x8000ff01 - energy_perf = 0x80, maximum = 0xff and minimum = 0x01.
Would you prefer that I make first_run a static variable to track if initial_req has been populated?
Quoted 24 lines
Quoted 24 lines
xen/arch/x86/acpi/cpufreq/hwp.c new file +24
-0+static void cf_check hwp_set_misc_turbo(void *info) +{ +const struct cpufreq_policy *policy = info; +struct hwp_drv_data *data =per_cpu (hwp_drv_data, policy->cpu); +uint64_t msr; + + data->ret =0 ; + +if (rdmsr_safe (MSR_IA32_MISC_ENABLE , msr) ) + { +hwp_verbose ("CPU%u: error rdmsr_safe(MSR_IA32_MISC_ENABLE)\n" , + policy->cpu); + data->ret = -EINVAL ; + +return ; + } + +if ( policy->turbo ==CPUFREQ_TURBO_ENABLED ) + msr &= ~MSR_IA32_MISC_ENABLE_TURBO_DISENGAGE ; +else + msr |=MSR_IA32_MISC_ENABLE_TURBO_DISENGAGE ; + +if (wrmsr_safe (MSR_IA32_MISC_ENABLE , msr) ) + {
Quoted 8 lines
xen/arch/x86/acpi/cpufreq/hwp.c line 491
Quoted 5 lines
xen/arch/x86/acpi/cpufreq/hwp.c new file +5
-0+hwp_verbose ("CPU%u: error wrmsr_safe(MSR_IA32_MISC_ENABLE): %016lx\n" , + policy->cpu, msr); + data->ret = -EINVAL ; + } +}Neither of the two
-EINVALreally indicate an invalid argument that was passed. Maybe EACCES (or less desirably EFAULT)?
Ok, I'll use EACCES.
Quoted 55 lines
Quoted 37 lines
xen/arch/x86/acpi/cpufreq/hwp.c new file +26
-6@@ -89,15 +96,45 @@ static int __init cf_check setup_cpufreq_option(const char *str)return 0 ; } -if ( choice >0 || !cmdline_strcmp (str,"xen" ) ) + do { - xen_processor_pmbits |=XEN_PROCESSOR_PM_PX ; - cpufreq_controller = FREQCTL_xen; -if ( *arg && *(arg +1 ) ) -return cpufreq_cmdline_parse (arg +1 ); - } + const char *end = strchr(str, ';'); + + if ( end == NULL ) + end = strchr(str, '\0'); + + arg = strpbrk(str, ",:"); + if ( !arg || arg > end ) + arg = strchr(str, '\0'); + + if ( cpufreq_xen_cnt == ARRAY_SIZE(cpufreq_xen_opts) ) + return -E2BIG; + + if ( choice > 0 || !cmdline_strcmp(str, "xen") ) + { + xen_processor_pmbits |= XEN_PROCESSOR_PM_PX; + cpufreq_controller = FREQCTL_xen; + cpufreq_xen_opts[cpufreq_xen_cnt++] = CPUFREQ_xen; + ret = 0; + if ( arg[0] && arg[1] ) + ret = cpufreq_cmdline_parse(arg + 1, end); + } + else if ( choice < 0 && !cmdline_strcmp(str, "hwp") ) + { + xen_processor_pmbits |= XEN_PROCESSOR_PM_PX; + cpufreq_controller = FREQCTL_xen;xen/arch/x86/acpi/cpufreq/hwp.c static int __init cf_check setup_cpufreq_option(const char *str) · line 135
Quoted 10 lines
xen/arch/x86/acpi/cpufreq/hwp.c new file +10
-0+ cpufreq_xen_opts[cpufreq_xen_cnt++] = CPUFREQ_hwp; + ret =0 ; +if ( arg[0 ] && arg[1 ] ) + ret =hwp_cmdline_parse (arg +1 , end); + } +else + ret = -EINVAL ; + + str = end ? ++end : end; + }while ( choice <0 && ret ==0 && *str );According to the earlier of the two lines, str may be NULL and hence cannot be dereferenced without first checking to be non-NULL. Earlier in the loop though you ensure end cannot be NULL. In that case, however, you point end at the nul character, so the increment above would point end at the next following one. So my guess is that you meant
Quoted 1 line
str = *end ? ++end : end;
Yes, you are correct. Thanks for catching it.
Thanks,
Jason
Re: [PATCH v6 06/15] cpufreq: Add Hardware P-State (HWP) driver
Quoted 79 lines · Jason Andryuk
Quoted 69 lines · Jan Beulich
Quoted 68 lines · Jason Andryuk
xen/arch/x86/acpi/cpufreq/hwp.c new file +65
-0@@ -0,0 +1,521 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* +* hwp.c cpufreq driver to run Intel Hardware P-States (HWP) +* +* Copyright (C) 2021 Jason Andryuk <[email protected]> +*/ + +#include <xen/cpumask.h> +#include <xen/init.h> +#include <xen/param.h> +#include <xen/xmalloc.h> +#include <asm/msr.h> +#include <acpi/cpufreq/cpufreq.h> + +static bool __ro_after_init feature_hwp_notification; +static bool __ro_after_init feature_hwp_activity_window; + +static bool __ro_after_init feature_hdc; + +static bool __ro_after_init opt_cpufreq_hdc = true; + +union hwp_request +{ +struct + { +unsigned int min_perf:8 ; +unsigned int max_perf:8 ; +unsigned int desired:8 ; +unsigned int energy_perf:8 ; +unsigned int activity_window:10 ; +bool package_control:1 ; + unsigned int :16; +bool activity_window_valid:1 ; +bool energy_perf_valid:1 ; +bool desired_valid:1 ; +bool max_perf_valid:1 ; +bool min_perf_valid:1 ; + }; +uint64_t raw; +}; + +struct hwp_drv_data +{ +union + { +uint64_t hwp_caps; +struct + { +unsigned int highest:8 ; +unsigned int guaranteed:8 ; +unsigned int most_efficient:8 ; +unsigned int lowest:8 ; + unsigned int :32; + } hw; + }; +union hwp_request curr_req; +int ret; +uint16_t activity_window; +uint8_t minimum; +uint8_t maximum; +uint8_t desired; +uint8_t energy_perf; +}; +static DEFINE_PER_CPU_READ_MOSTLY(struct hwp_drv_data *, hwp_drv_data); +Quoted 8 lines
xen/arch/x86/acpi/cpufreq/hwp.c line 68
Quoted 3 lines
xen/arch/x86/acpi/cpufreq/hwp.c new file +3
-0+#define hwp_err (cpu, fmt, ...) \ + printk(XENLOG_ERR "HWP: CPU%u error: " fmt, cpu, ##__VA_ARGS__) +#define hwp_info (fmt, ...) printk(XENLOG_INFO "HWP: " fmt, ##__VA_ARGS__)I'm not convinced ", ##__VA_ARGS__" is a good construct to use. I notice we have a few instances (mainly in code inherited from elsewhere), but I think it ought to either be plain C99 style (without the ##) or purely the gcc extension form (not using
__VA_ARGS__).
Quoted 8 lines
Using plain
__VA_ARGS__doesn't work for the cases without arguments:arch/x86/acpi/cpufreq/hwp.c:78:53: error: expected expression before ‘)’ token
78 |printk(XENLOG_DEBUG "HWP: " fmt, __VA_ARGS__); \
| ^arch/x86/acpi/cpufreq/hwp.c:201:9: note: in expansion of macro ‘hwp_verbose’
201 | hwp_verbose("disabled: No energy/performancepreference available"); | ^~~~~~~~~~~
Of course.
Quoted 1 line
I can use "
__VA_OPT__(,)__VA_ARGS__" though.
__VA_OPT__ is yet newer than C99, so this is an option only if all compilers we continue to support actually know of this. We have no uses of it in the codebase so far, which suggests you might best go with the longstanding gcc extension here.
Quoted 47 lines
Quoted 41 lines
Quoted 27 lines
xen/arch/x86/acpi/cpufreq/hwp.c new file +27
-0+static int cf_check hwp_cpufreq_cpu_init(struct cpufreq_policy *policy) +{ +static union hwp_request initial_req; +unsigned int cpu = policy->cpu; +struct hwp_drv_data *data; +bool first_run = false; + + data = xzalloc(struct hwp_drv_data); +if ( !data ) +return -ENOMEM ; + + policy->governor = &cpufreq_gov_hwp; + +per_cpu (hwp_drv_data, cpu) = data; + +on_selected_cpus (cpumask_of (cpu), hwp_init_msrs, policy,1 ); + +if ( data->curr_req.raw ==-1 ) + { +hwp_err (cpu,"Could not initialize HWP properly\n" ); +per_cpu (hwp_drv_data, cpu) =NULL ; +xfree (data); +return -ENODEV ; + } + + data->minimum = data->curr_req.min_perf; + data->maximum = data->curr_req.max_perf;xen/arch/x86/acpi/cpufreq/hwp.c line 438
Quoted 10 lines
xen/arch/x86/acpi/cpufreq/hwp.c new file +10
-0+ data->desired = data->curr_req.desired; + data->energy_perf = data->curr_req.energy_perf; + data->activity_window = data->curr_req.activity_window; + +if ( initial_req.raw ==0 ) + { +hwp_verbose ("CPU%u: HWP_CAPABILITIES: %016lx\n" , cpu, data->hwp_caps); + initial_req = data->curr_req; + first_run = true; + }What part of
data->curr_reqis guaranteed to be non-0 (for the condition around ...Quoted 5 lines
xen/arch/x86/acpi/cpufreq/hwp.c line 442
Quoted 3 lines
xen/arch/x86/acpi/cpufreq/hwp.c new file +3
-0+if ( first_run || data->curr_req.raw != initial_req.raw ) +hwp_verbose ("CPU%u: rdmsr HWP_REQUEST %016lx\n" , cpu, + data->curr_req.raw);... this logging to be effective)?
Quoted 7 lines
Hmmm. I think you are correct that there is no guarantee that
data->curr_reqwill be non-zero. i.e. a BIOS could zero the whole register. In practice, I see0x8000ff01-energy_perf=0x80, maximum =0xffand minimum =0x01.Would you prefer that I make
first_runa static variable to track ifinitial_reqhas been populated?
Well, I wouldn't call it "prefer", but I see no easy alternative.
Jan
Re: [PATCH v6 06/15] cpufreq: Add Hardware P-State (HWP) driver
Quoted 24 lines · Jan Beulich
Quoted 13 lines · Jason Andryuk
Quoted 11 lines · Jan Beulich
xen/arch/x86/acpi/cpufreq/hwp.c line 68
Quoted 5 lines · Jason Andryuk
xen/arch/x86/acpi/cpufreq/hwp.c new file +3
-0+#define hwp_err (cpu, fmt, ...) \ + printk(XENLOG_ERR "HWP: CPU%u error: " fmt, cpu, ##__VA_ARGS__) +#define hwp_info (fmt, ...) printk(XENLOG_INFO "HWP: " fmt, ##__VA_ARGS__)I'm not convinced ", ##__VA_ARGS__" is a good construct to use. I notice we have a few instances (mainly in code inherited from elsewhere), but I think it ought to either be plain C99 style (without the ##) or purely the gcc extension form (not using
__VA_ARGS__).Quoted 8 lines
Using plain
__VA_ARGS__doesn't work for the cases without arguments:arch/x86/acpi/cpufreq/hwp.c:78:53: error: expected expression before ‘)’ token
78 |printk(XENLOG_DEBUG "HWP: " fmt, __VA_ARGS__); \
| ^arch/x86/acpi/cpufreq/hwp.c:201:9: note: in expansion of macro ‘hwp_verbose’
201 | hwp_verbose("disabled: No energy/performancepreference available"); | ^~~~~~~~~~~
Quoted 6 lines
Of course.
Quoted 1 line
I can use "
__VA_OPT__(,)__VA_ARGS__" though.
__VA_OPT__is yet newer than C99, so this is an option only if all compilers we continue to support actually know of this.
Right, sorry.
Quoted 3 lines
We have no
uses of it in the codebase so far, which suggests you might best go with the longstanding gcc extension here.
FTAOD, "##__VA_ARGS__" is the longstanding extension? It's the only one I've been able to get to compile. I'm reading
https://gcc.gnu.org/onlinedocs/cpp/Variadic-Macros.html and it mentions a few different extensions.
This part seemed promising:
"""
This has been fixed in C++20, and GNU CPP also has a pair of extensions which deal with this problem.
First, in GNU CPP, and in C++ beginning in C++20, you are allowed to leave the variable argument out entirely:
eprintf ("success!\n")
→ fprintf(stderr, "success!\n", );
"""
However, it doesn't seem to actually work for me. I still get an error like the one above for plain __VA_ARGS__. That is for:
#define hwp_err(cpu, fmt, args...) \
printk(XENLOG_ERR "HWP: CPU%u error: " fmt, cpu, args)
I can drop "fmt" from hwp_info() and hwp_verbose() to just use __VA_ARGS__, but that doesn't work for hwp_err() since we want to re-order fmt and cpu inside the macro.
Thanks,
Jason
Re: [PATCH v6 06/15] cpufreq: Add Hardware P-State (HWP) driver
Quoted 32 lines · Jason Andryuk
Quoted 24 lines · Jan Beulich
Quoted 13 lines · Jason Andryuk
Quoted 11 lines · Jan Beulich
xen/arch/x86/acpi/cpufreq/hwp.c line 68
Quoted 5 lines · Jason Andryuk
xen/arch/x86/acpi/cpufreq/hwp.c new file +3
-0+#define hwp_err (cpu, fmt, ...) \ + printk(XENLOG_ERR "HWP: CPU%u error: " fmt, cpu, ##__VA_ARGS__) +#define hwp_info (fmt, ...) printk(XENLOG_INFO "HWP: " fmt, ##__VA_ARGS__)I'm not convinced ", ##__VA_ARGS__" is a good construct to use. I notice we have a few instances (mainly in code inherited from elsewhere), but I think it ought to either be plain C99 style (without the ##) or purely the gcc extension form (not using
__VA_ARGS__).Quoted 8 lines
Using plain
__VA_ARGS__doesn't work for the cases without arguments:arch/x86/acpi/cpufreq/hwp.c:78:53: error: expected expression before ‘)’ token
78 |printk(XENLOG_DEBUG "HWP: " fmt, __VA_ARGS__); \
| ^arch/x86/acpi/cpufreq/hwp.c:201:9: note: in expansion of macro ‘hwp_verbose’
201 | hwp_verbose("disabled: No energy/performancepreference available"); | ^~~~~~~~~~~Quoted 6 lines
Of course.
Quoted 1 line
I can use "
__VA_OPT__(,)__VA_ARGS__" though.
__VA_OPT__is yet newer than C99, so this is an option only if all compilers we continue to support actually know of this.
Quoted 7 lines
Right, sorry.
Quoted 3 lines
We have no
uses of it in the codebase so far, which suggests you might best go with the longstanding gcc extension here.FTAOD, "##__VA_ARGS__" is the longstanding extension?
No. But you've apparently found it ...
Quoted 14 lines
It's the only
one I've been able to get to compile. I'm reading
https://gcc.gnu.org/onlinedocs/cpp/Variadic-Macros.html and it mentions a few different extensions.This part seemed promising:
"""
This has been fixed in C++20, and GNU CPP also has a pair of extensions which deal with this problem.First, in GNU CPP, and in C++ beginning in C++20, you are allowed to leave the variable argument out entirely:
eprintf ("success!\n")
Quoted 8 lines
→ fprintf(stderr, "success!\n", );"""
However, it doesn't seem to actually work for me. I still get an error like the one above for plain
__VA_ARGS__. That is for:#define
hwp_err(cpu, fmt, args...)\
printk(XENLOG_ERR "HWP: CPU%u error: " fmt, cpu, args)
..., just that you're missing the ##:
#define hwp_err(cpu, fmt, args...) \
printk(XENLOG_ERR "HWP: CPU%u error: " fmt, cpu, ## args)
Jan
Re: [PATCH v6 06/15] cpufreq: Add Hardware P-State (HWP) driver
Quoted 10 lines · Jan Beulich
Quoted 2 lines · Jason Andryuk
#define
hwp_err(cpu, fmt, args...)\
printk(XENLOG_ERR "HWP: CPU%u error: " fmt, cpu, args)..., just that you're missing the ##:
#define
hwp_err(cpu, fmt, args...)\
printk(XENLOG_ERR "HWP: CPU%u error: " fmt, cpu, ## args)
Thanks. I thought I was trying to avoid the use of "##", which sent me off in the wrong direction.
Regards,
Jason
PATCH v6 7/15 xen/x86: Tweak PDC bits when using HWP
In reply to Jason AndryukQubes testing of HWP support had a report of a laptop, Thinkpad X1 Carbon Gen 4 with a Skylake processor, locking up during boot when HWP is enabled. A user found a kernel bug that seems to be the same issue:
https://bugzilla.kernel.org/show_bug.cgi?id=110941.
That bug was fixed by Linux commit a21211672c9a ("ACPI / processor:
Request native thermal interrupt handling via _OSC"). The tl;dr is SMM crashes when it receives thermal interrupts, so Linux calls the ACPI _OSC method to take over interrupt handling.
The Linux fix looks at the CPU features to decide whether or not to call _OSC with bit 12 set to take over native interrupt handling. Xen needs some way to communicate HWP to Dom0 for making an equivalent call.
Xen exposes modified PDC bits via the platform_op set_pminfo hypercall. Expand that to set bit 12 when HWP is present and in use.
Any generated interrupt would be handled by Xen's thermal drive, which clears the status.
Bit 12 isn't named in the linux header and is open coded in Linux's usage. Name it ACPI_PDC_CPPC_NATIVE_INTR.
This will need a corresponding linux patch to pick up and apply the PDC bits.
---
v5:
Minor fixup for feature_hwp removal
Use cpurfreq.h for declaration
v4:
Added __ro_after_init s/ACPI_PDC_CPPC_NTV_INT/ACPI_PDC_CPPC_NATIVE_INTR/ Remove _IA32_
Fixup for opt_cpufreq_hwp removal
Add Jan Reviewed-by
v3:
New
--- xen/arch/x86/acpi/cpufreq/hwp.c | 9 +++++++++ xen/arch/x86/acpi/lib.c | 5 +++++ xen/arch/x86/cpu/mcheck/mce_intel.c | 6 ++++++ xen/arch/x86/include/asm/msr-index.h | 1 + xen/include/acpi/cpufreq/cpufreq.h | 1 + xen/include/acpi/pdc_intel.h | 1 + 6 files changed, 23 insertions(+)
xen/arch/x86/acpi/cpufreq/hwp.c +9 -0
@@ -12,6 +12,8 @@#include <asm/msr.h> #include <acpi/cpufreq/cpufreq.h> +static bool __ro_after_init hwp_in_use; +static bool __ro_after_init feature_hwp_notification;static bool __ro_after_init feature_hwp_activity_window;
@@ -152,6 +154,11 @@ static int __init cf_check cpufreq_gov_hwp_init(void) }__initcall (cpufreq_gov_hwp_init); +bool hwp_active (void ) +{ +return hwp_in_use; +} +static bool __init hwp_available (void ) {unsigned int eax;
@@ -204,6 +211,8 @@ static bool __init hwp_available(void)hwp_verbose ("HW_FEEDBACK %ssupported\n" , (eax &CPUID6_EAX_HW_FEEDBACK ) ?"" :"not " ); + hwp_in_use = true; +hwp_info ("Using HWP for cpufreq\n" );return true;
xen/arch/x86/acpi/lib.c +5 -0
@@ -26,6 +26,8 @@#include <asm/fixmap.h> #include <asm/mwait.h> +#include <acpi/cpufreq/cpufreq.h> +u32 __read_mostly acpi_smi_cmd;u8 __read_mostly acpi_enable_value;u8 __read_mostly acpi_disable_value;
@@ -140,5 +142,8 @@ int arch_acpi_set_pdc_bits(u32 acpi_id, u32 *pdc, u32 mask) !(ecx & CPUID5_ECX_INTERRUPT_BREAK)) pdc[2 ] &= ~(ACPI_PDC_C_C1_FFH |ACPI_PDC_C_C2C3_FFH ); +if (hwp_active ()) + pdc[2 ] |=ACPI_PDC_CPPC_NATIVE_INTR ; +return 0 ; }
xen/arch/x86/cpu/mcheck/mce_intel.c +6 -0
@@ -15,6 +15,9 @@#include <asm/p2m.h> #include <asm/mce.h> #include <asm/apic.h> + +#include <acpi/cpufreq/cpufreq.h> +#include "mce.h" #include "x86_mca.h" #include "barrier.h"
@@ -64,6 +67,9 @@ static void cf_check intel_thermal_interrupt(struct cpu_user_regs *regs)ack_APIC_irq (); +if (hwp_active () ) +wrmsr_safe (MSR_HWP_STATUS ,0 ); +if (NOW () <per_cpu (next, cpu) )return ;
xen/arch/x86/include/asm/msr-index.h +1 -0
@@ -157,6 +157,7 @@#define MSR_HWP_CAPABILITIES 0x00000771#define MSR_HWP_INTERRUPT 0x00000773#define MSR_HWP_REQUEST 0x00000774 +#define MSR_HWP_STATUS 0x00000777#define MSR_X2APIC_FIRST 0x00000800#define MSR_X2APIC_LAST 0x000008ff
xen/include/acpi/cpufreq/cpufreq.h +1 -0
@@ -254,5 +254,6 @@ void intel_feature_detect(struct cpufreq_policy *policy);int hwp_cmdline_parse (const char *s,const char *e);int hwp_register_driver (void ); +bool hwp_active (void );#endif /* __XEN_CPUFREQ_PM_H__ */
xen/include/acpi/pdc_intel.h +1 -0
@@ -17,6 +17,7 @@#define ACPI_PDC_C_C1_FFH (0x0100)#define ACPI_PDC_C_C2C3_FFH (0x0200)#define ACPI_PDC_SMP_P_HWCOORD (0x0800) +#define ACPI_PDC_CPPC_NATIVE_INTR (0x1000)#define ACPI_PDC_EST_CAPABILITY_SMP (ACPI_PDC_SMP_C1PT | \ ACPI_PDC_C_C1_HALT | \
Signature · 1 line
2.41.0
PATCH v6 8/15 xenpm: Change get-cpufreq-para output for hwp
In reply to Jason AndryukWhen using HWP, some of the returned data is not applicable. In that case, we should just omit it to avoid confusing the user. So switch to printing the base and max frequencies since those are relevant to HWP. Similarly, stop printing the CPU frequencies since those do not apply. The scaling fields are also no longer printed.
---
v5:
Use XEN_HWP_DRIVER_NAME
Add Jan's Ack
v4:
s/turbo/max/
Check for XEN_HWP_DRIVER driver instead of "-internal"
v2:
Use full governor name XEN_HWP_GOVERNOR to change output Style fixes
--- tools/misc/xenpm.c | 83 +++++++++++++++++++++++++--------------------- 1 file changed, 46 insertions(+), 37 deletions(-)
tools/misc/xenpm.c +46 -37
@@ -711,6 +711,7 @@ void start_gather_func(int argc, char *argv[])/* print out parameters about cpu frequency */ static void print_cpufreq_para (int cpuid,struct xc_get_cpufreq_para *p_cpufreq) { +bool hwp =strcmp (p_cpufreq->scaling_driver,XEN_HWP_DRIVER_NAME ) ==0 ;int i;printf ("cpu id : %d\n" , cpuid);
@@ -720,49 +721,57 @@ static void print_cpufreq_para(int cpuid, struct xc_get_cpufreq_para *p_cpufreq)printf (" %d" , p_cpufreq->affected_cpus[i]);printf ("\n" ); -printf ("cpuinfo frequency : max [%u] min [%u] cur [%u]\n" , - p_cpufreq->cpuinfo_max_freq, - p_cpufreq->cpuinfo_min_freq, - p_cpufreq->cpuinfo_cur_freq); +if ( hwp ) +printf ("cpuinfo frequency : base [%u] max [%u]\n" , + p_cpufreq->cpuinfo_min_freq, + p_cpufreq->cpuinfo_max_freq); +else +printf ("cpuinfo frequency : max [%u] min [%u] cur [%u]\n" , + p_cpufreq->cpuinfo_max_freq, + p_cpufreq->cpuinfo_min_freq, + p_cpufreq->cpuinfo_cur_freq);printf ("scaling_driver : %s\n" , p_cpufreq->scaling_driver); -printf ("scaling_avail_gov : %s\n" , - p_cpufreq->scaling_available_governors); - -printf ("current_governor : %s\n" , p_cpufreq->u.s.scaling_governor); -if ( !strncmp (p_cpufreq->u.s.scaling_governor, -"userspace" ,CPUFREQ_NAME_LEN ) ) - { -printf (" userspace specific :\n" ); -printf (" scaling_setspeed : %u\n" , - p_cpufreq->u.s.u.userspace.scaling_setspeed); - } -else if ( !strncmp (p_cpufreq->u.s.scaling_governor, -"ondemand" ,CPUFREQ_NAME_LEN ) ) +if ( !hwp ) { -printf (" ondemand specific :\n" ); -printf (" sampling_rate : max [%u] min [%u] cur [%u]\n" , - p_cpufreq->u.s.u.ondemand.sampling_rate_max, - p_cpufreq->u.s.u.ondemand.sampling_rate_min, - p_cpufreq->u.s.u.ondemand.sampling_rate); -printf (" up_threshold : %u\n" , - p_cpufreq->u.s.u.ondemand.up_threshold); - } +printf ("scaling_avail_gov : %s\n" , + p_cpufreq->scaling_available_governors); -printf ("scaling_avail_freq :" ); -for ( i =0 ; i < p_cpufreq->freq_num; i++ ) -if ( p_cpufreq->scaling_available_frequencies[i] == - p_cpufreq->u.s.scaling_cur_freq ) -printf (" *%d" , p_cpufreq->scaling_available_frequencies[i]); -else -printf (" %d" , p_cpufreq->scaling_available_frequencies[i]); -printf ("\n" ); +printf ("current_governor : %s\n" , p_cpufreq->u.s.scaling_governor); +if ( !strncmp (p_cpufreq->u.s.scaling_governor, +"userspace" ,CPUFREQ_NAME_LEN ) ) + { +printf (" userspace specific :\n" ); +printf (" scaling_setspeed : %u\n" , + p_cpufreq->u.s.u.userspace.scaling_setspeed); + } +else if ( !strncmp (p_cpufreq->u.s.scaling_governor, +"ondemand" ,CPUFREQ_NAME_LEN ) ) + { +printf (" ondemand specific :\n" ); +printf (" sampling_rate : max [%u] min [%u] cur [%u]\n" , + p_cpufreq->u.s.u.ondemand.sampling_rate_max, + p_cpufreq->u.s.u.ondemand.sampling_rate_min, + p_cpufreq->u.s.u.ondemand.sampling_rate); +printf (" up_threshold : %u\n" , + p_cpufreq->u.s.u.ondemand.up_threshold); + } + +printf ("scaling_avail_freq :" ); +for ( i =0 ; i < p_cpufreq->freq_num; i++ ) +if ( p_cpufreq->scaling_available_frequencies[i] == + p_cpufreq->u.s.scaling_cur_freq ) +printf (" *%d" , p_cpufreq->scaling_available_frequencies[i]); +else +printf (" %d" , p_cpufreq->scaling_available_frequencies[i]); +printf ("\n" ); -printf ("scaling frequency : max [%u] min [%u] cur [%u]\n" , - p_cpufreq->u.s.scaling_max_freq, - p_cpufreq->u.s.scaling_min_freq, - p_cpufreq->u.s.scaling_cur_freq); +printf ("scaling frequency : max [%u] min [%u] cur [%u]\n" , + p_cpufreq->u.s.scaling_max_freq, + p_cpufreq->u.s.scaling_min_freq, + p_cpufreq->u.s.scaling_cur_freq); + }printf ("turbo mode : %s\n" , p_cpufreq->turbo_enabled ?"enabled" :"disabled or n/a" );
Signature · 1 line
2.41.0
PATCH v6 9/15 cpufreq: Export HWP parameters to userspace as CPPC
In reply to Jason AndryukExtend xen_get_cpufreq_para to return hwp parameters. HWP is an implementation of ACPI CPPC (Collaborative Processor Performance Control). Use the CPPC name since that might be useful in the future for AMD P-state.
We need the features bitmask to indicate fields supported by the actual hardware - this only applies to activity window for the time being.
The HWP most_efficient is mapped to CPPC lowest_nonlinear, and guaranteed is mapped to nominal. CPPC has a guaranteed that is optional while nominal is required. ACPI spec says "If this register is not implemented, OSPM assumes guaranteed performance is always equal to nominal performance."
---
v2:
Style fixes
Don't bump XEN_SYSCTL_INTERFACE_VERSION
Drop cpufreq.h comment divider
Expand xen_hwp_para comment
Add HWP activity window mantissa/exponent defines
Handle union rename
Add const to get_hwp_para
Remove hw_ prefix from xen_hwp_para members
Use XEN_HWP_GOVERNOR
Use per_cpu for hwp_drv_data
v4:
Fixup for opt_cpufreq_hwp/hdc removalget_hwp_para() takes cpu as argXEN_ prefix HWP_ACT_WINDOW_*
Drop HWP_ACT_WINDOW_EXPONENT_SHIFT - shift MASK
Remove Energy Bias (0-15) EPP fallback
Rename xen_hwp_para to xen_cppc_para
s/hwp/cppc/
Use scaling driver to switch output
v5:
Use XEN_HWP_DRIVER_NAME
Use cpufreq.h for declarations
Fixup some comments
Drop const from unsigned int cpu
Drop some unnecessary { }
Use strncmp
Switch sizeof(char) to sizeof(*scaling_available_governors) Reindent copy_to_guest call
Add "HWP: " prefix to sysctl comments for cppc->hwp mapping
v6:
Drop commit message uint8_t paragraphsysctl.h s/They/They're/
Fix indent and add parens for read_scaling_available_governors() args Add Jan's Ack
--- xen/arch/x86/acpi/cpufreq/hwp.c | 23 ++++++++++ xen/drivers/acpi/pmstat.c | 74 ++++++++++++++++-------------- xen/include/acpi/cpufreq/cpufreq.h | 2 + xen/include/public/sysctl.h | 56 ++++++++++++++++++++++ 4 files changed, 121 insertions(+), 34 deletions(-)
xen/arch/x86/acpi/cpufreq/hwp.c +23 -0
@@ -516,6 +516,29 @@ static const struct cpufreq_driver __initconstrel hwp_cpufreq_driver = .update = hwp_cpufreq_update, }; +int get_hwp_para (unsigned int cpu, +struct xen_cppc_para *cppc_para) +{ +const struct hwp_drv_data *data =per_cpu (hwp_drv_data, cpu); + +if ( data ==NULL ) +return -ENODATA ; + + cppc_para->features = + (feature_hwp_activity_window ?XEN_SYSCTL_CPPC_FEAT_ACT_WINDOW :0 ); + cppc_para->lowest = data->hw.lowest; + cppc_para->lowest_nonlinear = data->hw.most_efficient; + cppc_para->nominal = data->hw.guaranteed; + cppc_para->highest = data->hw.highest; + cppc_para->minimum = data->minimum; + cppc_para->maximum = data->maximum; + cppc_para->desired = data->desired; + cppc_para->energy_perf = data->energy_perf; + cppc_para->activity_window = data->activity_window; + +return 0 ; +} +int __init hwp_register_driver (void ) {int ret;
xen/drivers/acpi/pmstat.c +40 -34
86 lines not on this page · raw message
xen/include/acpi/cpufreq/cpufreq.h +2 -0
@@ -255,5 +255,7 @@ void intel_feature_detect(struct cpufreq_policy *policy);int hwp_cmdline_parse (const char *s,const char *e);int hwp_register_driver (void );bool hwp_active (void ); +int get_hwp_para (unsigned int cpu, +struct xen_cppc_para *cppc_para);#endif /* __XEN_CPUFREQ_PM_H__ */
xen/include/public/sysctl.h +56 -0
68 lines not on this page · raw message
Signature · 1 line
2.41.0
PATCH v6 10/15 libxc: Include cppc_para in definitions
In reply to Jason AndryukExpose the cppc_para fields through libxc.
---
v4:
Rename hwp to cppc
Add Anthony's Ack
--- tools/include/xenctrl.h | 2 ++ 1 file changed, 2 insertions(+)
tools/include/xenctrl.h +2 -0
@@ -1892,6 +1892,7 @@ int xc_smt_disable(xc_interface *xch);*/ typedef struct xen_userspace xc_userspace_t ;typedef struct xen_ondemand xc_ondemand_t ; +typedef struct xen_cppc_para xc_cppc_para_t ;struct xc_get_cpufreq_para {/* IN/OUT variable */
@@ -1923,6 +1924,7 @@ struct xc_get_cpufreq_para {xc_ondemand_t ondemand; } u; } s; +xc_cppc_para_t cppc_para; } u;int32_t turbo_enabled;
Signature · 1 line
2.41.0
PATCH v6 11/15 xenpm: Print HWP/CPPC parameters
In reply to Jason AndryukPrint HWP-specific parameters. Some are always present, but others depend on hardware support.
---
v2:
Style fixes
Declare i outside loop
Replace repearted hardware/configured limits with spaces Fixup for hw_ removal
Use XEN_HWP_GOVERNOR
Use HWP_ACT_WINDOW_EXPONENT_*
Remove energy_perf hw autonomous - 0 doesn't mean autonomous
v4:
Return activity_window from calculate_hwp_activity_window Use blanks instead of _ in output
Use MASK_EXTR
Check XEN_HWP_DRIVER name since governor is no longer returned s/hwp/cppc
v5:
Add Jan's Reviewed-by
--- tools/misc/xenpm.c | 66 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 66 insertions(+)
tools/misc/xenpm.c +66 -0
@@ -708,6 +708,46 @@ void start_gather_func(int argc, char *argv[])pause (); } +static unsigned int calculate_activity_window (const xc_cppc_para_t *cppc, +const char **units) +{ +unsigned int mantissa =MASK_EXTR (cppc->activity_window, +XEN_CPPC_ACT_WINDOW_MANTISSA_MASK ); +unsigned int exponent =MASK_EXTR (cppc->activity_window, +XEN_CPPC_ACT_WINDOW_EXPONENT_MASK ); +unsigned int multiplier =1 ; +unsigned int i; + +/* +* SDM only states a 0 register is hardware selected, and doesn't mention +* a 0 mantissa with a non-0 exponent. Only special case a 0 register. +*/ +if ( cppc->activity_window ==0 ) + { + *units ="hardware selected" ; + +return 0 ; + } + +if ( exponent >=6 ) + { + *units ="s" ; + exponent -=6 ; + } +else if ( exponent >=3 ) + { + *units ="ms" ; + exponent -=3 ; + } +else + *units ="us" ; + +for ( i =0 ; i < exponent; i++ ) + multiplier *=10 ; + +return mantissa * multiplier; +} +/* print out parameters about cpu frequency */ static void print_cpufreq_para (int cpuid,struct xc_get_cpufreq_para *p_cpufreq) {
@@ -772,6 +812,32 @@ static void print_cpufreq_para(int cpuid, struct xc_get_cpufreq_para *p_cpufreq) p_cpufreq->u.s.scaling_min_freq, p_cpufreq->u.s.scaling_cur_freq); } +else + { +const xc_cppc_para_t *cppc = &p_cpufreq->u.cppc_para; + +printf ("cppc variables :\n" ); +printf (" hardware limits : lowest [%u] lowest nonlinear [%u]\n" , + cppc->lowest, cppc->lowest_nonlinear); +printf (" : nominal [%u] highest [%u]\n" , + cppc->nominal, cppc->highest); +printf (" configured limits : min [%u] max [%u] energy perf [%u]\n" , + cppc->minimum, cppc->maximum, cppc->energy_perf); + +if ( cppc->features &XEN_SYSCTL_CPPC_FEAT_ACT_WINDOW ) + { +unsigned int activity_window; +const char *units; + + activity_window =calculate_activity_window (cppc, &units); +printf (" : activity_window [%u %s]\n" , + activity_window, units); + } + +printf (" : desired [%u%s]\n" , + cppc->desired, + cppc->desired ?"" :" hw autonomous" ); + }printf ("turbo mode : %s\n" , p_cpufreq->turbo_enabled ?"enabled" :"disabled or n/a" );
Signature · 1 line
2.41.0
PATCH v6 12/15 xen: Add SET_CPUFREQ_HWP xen_sysctl_pm_op
In reply to Jason AndryukAdd SET_CPUFREQ_HWP xen_sysctl_pm_op to set HWP parameters. The sysctl supports setting multiple values simultaneously as indicated by the set_params bits. This allows atomically applying new HWP configuration via a single wrmsr.
XEN_SYSCTL_HWP_SET_PRESET_BALANCE/PERFORMANCE/POWERSAVE provide three common presets. Setting them depends on hardware limits which the hypervisor is already caching. So using them allows skipping a hypercall to query the limits (lowest/highest) to then set those same values. The code is organized to allow a preset to be refined with additional parameters if desired.
"most_efficient" and "guaranteed" could be additional presets in the future, but the are not added now. Those levels can change at runtime, but we don't have code in place to monitor and update for those events.
Since activity window may not be supported by all hardware, omit writing it when not supported, and return that fact to userspace by updating set_params.
CPPC parameter checking disallows setting reserved bytes and ensure values are only non-zero when the corresponding set_params bit is set. There is no range checking (0-255 is allowed) since hardware is documented to clip internally.
---
v6:
Add () around bit test
Add U suffix to XEN_SYSCTL_ constants
Change -EINVAL returns to -ENOENT/-EOPNOTSUPP
Return success for no-op set_hwp_para()
v5:
Use cpufreq.h for include
Add () around bit test
Fix Configure typo
Drop duplicated energy_perf comment
Define XEN_SYSCTL_CPPC_ACT_WINDOW_MASK from *_MANTISSA_MASK and *_EXPONENT_MASK Re-order XEN_SYSCTL_CPPC_SET_* flags to match field and hardware order. Remove const from set_cppc param to update set_params
Skip Activity Window if not supported by hardware and clear set_params Make parameter parsing consistent
Add an exit path when there are no parameters to write.
Expand the header file to cover the IN/OUT set_params.
Remove the "desired" lowest/highest checking as hardware clips internally
v4:
Remove IA32_ENERGY_BIAS support
Validate parameters don't exceed 255
Use CPPC/cppc nameset_cppc_para() add constset_cppc_para() return hwp_cpufreq_target()
Expand sysctl comments
v3:
Remove cpufreq_governor_internal from set_cpufreq_hwp
v2:
Update for naming anonymous union
Drop hwp_err for invalid input in set_hwp_para() Drop uint16_t cast in XEN_SYSCTL_HWP_SET_PARAM_MASK Drop parens for HWP_SET_PRESET defines
Reference activity_window format comment
Place SET_CPUFREQ_HWP after SET_CPUFREQ_PARA
Add {HWP,IA32}_ENERGY_PERF_MAX_{PERFORMANCE,POWERSAVE} defines Order defines before fields in sysctl.h
Use XEN_HWP_GOVERNOR
Use per_cpu for hwp_drv_data
--- xen/arch/x86/acpi/cpufreq/hwp.c | 101 +++++++++++++++++++++++++++++ xen/drivers/acpi/pmstat.c | 17 +++++ xen/include/acpi/cpufreq/cpufreq.h | 2 + xen/include/public/sysctl.h | 64 ++++++++++++++++++ 4 files changed, 184 insertions(+)
xen/arch/x86/acpi/cpufreq/hwp.c +101 -0
@@ -21,6 +21,10 @@ static bool __ro_after_init feature_hdc;static bool __ro_after_init opt_cpufreq_hdc = true; +#define HWP_ENERGY_PERF_MAX_PERFORMANCE 0 +#define HWP_ENERGY_PERF_BALANCE 0x80 +#define HWP_ENERGY_PERF_MAX_POWERSAVE 0xff +union hwp_request { struct
@@ -539,6 +543,103 @@ int get_hwp_para(unsigned int cpu,return 0 ; } +int set_hwp_para (struct cpufreq_policy *policy, +struct xen_set_cppc_para *set_cppc) +{ +unsigned int cpu = policy->cpu; +struct hwp_drv_data *data =per_cpu (hwp_drv_data, cpu); +bool cleared_act_window = false; + +if ( data ==NULL ) +return -ENOENT ; + +/* Validate all parameters - Disallow reserved bits. */ +if ( set_cppc->minimum >255 || + set_cppc->maximum >255 || + set_cppc->desired >255 || + set_cppc->energy_perf >255 || + (set_cppc->set_params & ~XEN_SYSCTL_CPPC_SET_PARAM_MASK ) || + (set_cppc->activity_window & ~XEN_SYSCTL_CPPC_ACT_WINDOW_MASK ) ) +return -EINVAL ; + +/* Only allow values if params bit is set. */ +if ( (!(set_cppc->set_params &XEN_SYSCTL_CPPC_SET_DESIRED ) && + set_cppc->desired) || + (!(set_cppc->set_params &XEN_SYSCTL_CPPC_SET_MINIMUM ) && + set_cppc->minimum) || + (!(set_cppc->set_params &XEN_SYSCTL_CPPC_SET_MAXIMUM ) && + set_cppc->maximum) || + (!(set_cppc->set_params &XEN_SYSCTL_CPPC_SET_ENERGY_PERF ) && + set_cppc->energy_perf) || + (!(set_cppc->set_params &XEN_SYSCTL_CPPC_SET_ACT_WINDOW ) && + set_cppc->activity_window) ) +return -EINVAL ; + +/* Clear out activity window if lacking HW supported. */ +if ( (set_cppc->set_params &XEN_SYSCTL_CPPC_SET_ACT_WINDOW ) && + !feature_hwp_activity_window ) { + set_cppc->set_params &= ~XEN_SYSCTL_CPPC_SET_ACT_WINDOW ; + cleared_act_window = true; + } + +/* Return if there is nothing to do. */ +if ( set_cppc->set_params ==0 ) +return 0 ; + +/* Apply presets */ +switch ( set_cppc->set_params &XEN_SYSCTL_CPPC_SET_PRESET_MASK ) + { +case XEN_SYSCTL_CPPC_SET_PRESET_POWERSAVE : + data->minimum = data->hw.lowest; + data->maximum = data->hw.lowest; + data->activity_window =0 ; + data->energy_perf =HWP_ENERGY_PERF_MAX_POWERSAVE ; + data->desired =0 ; +break ; + +case XEN_SYSCTL_CPPC_SET_PRESET_PERFORMANCE : + data->minimum = data->hw.highest; + data->maximum = data->hw.highest; + data->activity_window =0 ; + data->energy_perf =HWP_ENERGY_PERF_MAX_PERFORMANCE ; + data->desired =0 ; +break ; + +case XEN_SYSCTL_CPPC_SET_PRESET_BALANCE : + data->minimum = data->hw.lowest; + data->maximum = data->hw.highest; + data->activity_window =0 ; + data->energy_perf =HWP_ENERGY_PERF_BALANCE ; + data->desired =0 ; +break ; + +case XEN_SYSCTL_CPPC_SET_PRESET_NONE : +break ; + +default : +return -EINVAL ; + } + +/* Further customize presets if needed */ +if ( set_cppc->set_params &XEN_SYSCTL_CPPC_SET_MINIMUM ) + data->minimum = set_cppc->minimum; + +if ( set_cppc->set_params &XEN_SYSCTL_CPPC_SET_MAXIMUM ) + data->maximum = set_cppc->maximum; + +if ( set_cppc->set_params &XEN_SYSCTL_CPPC_SET_ENERGY_PERF ) + data->energy_perf = set_cppc->energy_perf; + +if ( set_cppc->set_params &XEN_SYSCTL_CPPC_SET_DESIRED ) + data->desired = set_cppc->desired; + +if ( set_cppc->set_params &XEN_SYSCTL_CPPC_SET_ACT_WINDOW ) + data->activity_window = set_cppc->activity_window & +XEN_SYSCTL_CPPC_ACT_WINDOW_MASK ; + +return hwp_cpufreq_target (policy,0 ,0 ); +} +int __init hwp_register_driver (void ) {int ret;
xen/drivers/acpi/pmstat.c +17 -0
@@ -400,6 +400,19 @@ static int set_cpufreq_para(struct xen_sysctl_pm_op *op)return ret; } +static int set_cpufreq_cppc (struct xen_sysctl_pm_op *op) +{ +struct cpufreq_policy *policy =per_cpu (cpufreq_cpu_policy, op->cpuid); + +if ( !policy || !policy->governor ) +return -ENOENT ; + +if ( !hwp_active () ) +return -EOPNOTSUPP ; + +return set_hwp_para (policy, &op->u.set_cppc); +} +int do_pm_op (struct xen_sysctl_pm_op *op) {int ret =0 ;
@@ -472,6 +485,10 @@ int do_pm_op(struct xen_sysctl_pm_op *op)break ; } +case SET_CPUFREQ_CPPC : + ret =set_cpufreq_cppc (op); +break ; +case GET_CPUFREQ_AVGFREQ : { op->u.get_avgfreq =cpufreq_driver_getavg (op->cpuid,USR_GETAVG );
xen/include/acpi/cpufreq/cpufreq.h +2 -0
@@ -257,5 +257,7 @@ int hwp_register_driver(void);bool hwp_active (void );int get_hwp_para (unsigned int cpu,struct xen_cppc_para *cppc_para); +int set_hwp_para (struct cpufreq_policy *policy, +struct xen_set_cppc_para *set_cppc);#endif /* __XEN_CPUFREQ_PM_H__ */
xen/include/public/sysctl.h +64 -0
82 lines not on this page · raw message
Signature · 1 line
2.41.0
Re: [PATCH v6 12/15] xen: Add SET_CPUFREQ_HWP xen_sysctl_pm_op
Quoted 20 lines · Jason Andryuk
Add
SET_CPUFREQ_HWPxen_sysctl_pm_opto set HWP parameters. The sysctl supports setting multiple values simultaneously as indicated by theset_paramsbits. This allows atomically applying new HWP configuration via a single wrmsr.XEN_SYSCTL_HWP_SET_PRESET_BALANCE/PERFORMANCE/POWERSAVE provide three common presets. Setting them depends on hardware limits which the hypervisor is already caching. So using them allows skipping a hypercall to query the limits (lowest/highest) to then set those same values. The code is organized to allow a preset to be refined with additional parameters if desired.
"
most_efficient" and "guaranteed" could be additional presets in the future, but the are not added now. Those levels can change at runtime, but we don't have code in place to monitor and update for those events.Since activity window may not be supported by all hardware, omit writing it when not supported, and return that fact to userspace by updating
set_params.
Quoted 6 lines
CPPC parameter checking disallows setting reserved bytes and ensure values are only non-zero when the corresponding
set_paramsbit is set. There is no range checking (0-255 is allowed) since hardware is documented to clip internally.Signed-off-by Jason Andryuk <[email protected]>
with one last nit taken care of:
Quoted 29 lines
xen/arch/x86/acpi/cpufreq/hwp.c +25
-0@@ -539,6 +543,103 @@ int get_hwp_para(unsigned int cpu,return 0 ; } +int set_hwp_para (struct cpufreq_policy *policy, +struct xen_set_cppc_para *set_cppc) +{ +unsigned int cpu = policy->cpu; +struct hwp_drv_data *data =per_cpu (hwp_drv_data, cpu); +bool cleared_act_window = false; + +if ( data ==NULL ) +return -ENOENT ; + +/* Validate all parameters - Disallow reserved bits. */ +if ( set_cppc->minimum >255 || + set_cppc->maximum >255 || + set_cppc->desired >255 || + set_cppc->energy_perf >255 || + (set_cppc->set_params & ~XEN_SYSCTL_CPPC_SET_PARAM_MASK ) || + (set_cppc->activity_window & ~XEN_SYSCTL_CPPC_ACT_WINDOW_MASK ) ) +return -EINVAL ; + +/* Only allow values if params bit is set. */ + if ( (!(set_cppc->set_params & XEN_SYSCTL_CPPC_SET_DESIRED) && + set_cppc->desired) || + (!(set_cppc->set_params & XEN_SYSCTL_CPPC_SET_MINIMUM) && + set_cppc->minimum) || + (!(set_cppc->set_params & XEN_SYSCTL_CPPC_SET_MAXIMUM) &&
xen/arch/x86/acpi/cpufreq/hwp.c int get_hwp_para(unsigned int cpu, · line 580
Quoted 10 lines
xen/arch/x86/acpi/cpufreq/hwp.c +10
-0+ set_cppc->maximum) || + (!(set_cppc->set_params &XEN_SYSCTL_CPPC_SET_ENERGY_PERF ) && + set_cppc->energy_perf) || + (!(set_cppc->set_params &XEN_SYSCTL_CPPC_SET_ACT_WINDOW ) && + set_cppc->activity_window) ) + return -EINVAL; + +/* Clear out activity window if lacking HW supported. */ +if ( (set_cppc->set_params &XEN_SYSCTL_CPPC_SET_ACT_WINDOW ) && + !feature_hwp_activity_window ) {
Yet another misplaced brace.
Jan
PATCH v6 13/15 libxc: Add xc_set_cpufreq_cppc
In reply to Jason AndryukAdd xc_set_cpufreq_cppc to allow calling xen_systctl_pm_op SET_CPUFREQ_CPPC.
---
v2:
Mark xc_set_hwp_para_t const
v4:
s/hwp/cppc/
Add Anthony's Ack
v5:
Remove const and copy back result
--- tools/include/xenctrl.h | 4 ++++ tools/libs/ctrl/xc_pm.c | 23 +++++++++++++++++++++++ 2 files changed, 27 insertions(+)
tools/include/xenctrl.h +4 -0
@@ -1930,11 +1930,15 @@ struct xc_get_cpufreq_para {int32_t turbo_enabled; }; +typedef struct xen_set_cppc_para xc_set_cppc_para_t ; +int xc_get_cpufreq_para (xc_interface *xch,int cpuid,struct xc_get_cpufreq_para *user_para);int xc_set_cpufreq_gov (xc_interface *xch,int cpuid,char *govname);int xc_set_cpufreq_para (xc_interface *xch,int cpuid,int ctrl_type,int ctrl_value); +int xc_set_cpufreq_cppc (xc_interface *xch,int cpuid, +xc_set_cppc_para_t *set_cppc);int xc_get_cpufreq_avgfreq (xc_interface *xch,int cpuid,int *avg_freq);int xc_set_sched_opt_smt (xc_interface *xch,uint32_t value);
tools/libs/ctrl/xc_pm.c +23 -0
@@ -329,6 +329,29 @@ int xc_set_cpufreq_para(xc_interface *xch, int cpuid,return xc_sysctl (xch, &sysctl); } +int xc_set_cpufreq_cppc (xc_interface *xch,int cpuid, +xc_set_cppc_para_t *set_cppc) +{ +DECLARE_SYSCTL ; +int ret; + +if ( !xch ) + { + errno =EINVAL ; +return -1 ; + } + sysctl.cmd = XEN_SYSCTL_pm_op; + sysctl.u.pm_op.cmd =SET_CPUFREQ_CPPC ; + sysctl.u.pm_op.cpuid = cpuid; + sysctl.u.pm_op.u.set_cppc = *set_cppc; + + ret =xc_sysctl (xch, &sysctl); + + *set_cppc = sysctl.u.pm_op.u.set_cppc; + +return ret; +} +int xc_get_cpufreq_avgfreq (xc_interface *xch,int cpuid,int *avg_freq) {int ret =0 ;
Signature · 1 line
2.41.0
PATCH v6 14/15 xenpm: Add set-cpufreq-cppc subcommand
In reply to Jason Andryukset-cpufreq-cppc allows setting the Hardware P-State (HWP) parameters.
It can be run on all or just a single cpu. There are presets of balance, powersave & performance. Those can be further tweaked by param:val arguments as explained in the usage description.
Parameter names are just checked to the first 3 characters to shorten typing.
Some options are hardware dependent, and ranges can be found in get-cpufreq-para.
---
v5:
Make i unsigned int
Use local max_cpuid instead of max_cpu_nr
Add Jan's Ack
Check set_params and print a message if activity window wasn't set
v4:
Remove energy bias 0-15 & 7 references
Use MASK_INSR
Fixup { placement
Drop extra case in parse_activity_window
strcmp suffix
Expand help text
s/hwp/cppc/
Use isdigit() to check cpuid - otherwise run on all CPUs.
v2:
Compare provided parameter name and not just 3 characters. Use "-" in parameter names
Remove hw_
Replace sscanf with strchr & strtoul.
Remove toplevel error message with lower level ones. Help text s/127/128/
Help text mention truncation.
Avoid some truncation rounding down by adding 5 before division. Help test mention default microseconds
Also comment the limit check written to avoid overflow.
--- tools/misc/xenpm.c | 244 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 244 insertions(+)
tools/misc/xenpm.c +244 -0
@@ -16,6 +16,8 @@*/ #define MAX_NR_CPU 512 +#include <ctype.h> +#include <limits.h> #include <stdio.h> #include <stdlib.h> #include <unistd.h>
@@ -67,6 +69,30 @@ void show_help(void)" set-max-cstate <num>|'unlimited' [<num2>|'unlimited']\n" " set the C-State limitation (<num> >= 0) and\n" " optionally the C-sub-state limitation (<num2> >= 0)\n" +" set-cpufreq-cppc [cpuid] [balance|performance|powersave] <param:val>*\n" +" set Hardware P-State (HWP) parameters\n" +" on CPU <cpuid> or all if omitted.\n" +" optionally a preset of one of:\n" +" balance|performance|powersave\n" +" an optional list of param:val arguments\n" +" minimum:N (0-255)\n" +" maximum:N (0-255)\n" +" get-cpufreq-para lowest/highest\n" +" values are limits for\n" +" minumum/maximum.\n" +" desired:N (0-255)\n" +" set explicit performance target.\n" +" non-zero disables auto-HWP mode.\n" +" energy-perf:N (0-255)\n" +" energy/performance hint\n" +" lower - favor performance\n" +" higher - favor powersave\n" +" 128 - balance\n" +" act-window:N{,m,u}s range 1us-1270s\n" +" window for internal calculations.\n" +" units default to \"us\" if unspecified.\n" +" truncates un-representable values.\n" +" 0 lets the hardware decide.\n" " start [seconds] start collect Cx/Px statistics,\n" " output after CTRL-C or SIGINT or several seconds.\n" " enable-turbo-mode [cpuid] enable Turbo Mode for processors that support it.\n"
@@ -1292,6 +1318,223 @@ void disable_turbo_mode(int argc, char *argv[]) errno, strerror(errno)); } +/* +* Parse activity_window:NNN{us,ms,s} and validate range. +* +* Activity window is a 7bit mantissa (0-127) with a 3bit exponent (0-7) base +* 10 in microseconds. So the range is 1 microsecond to 1270 seconds. A value +* of 0 lets the hardware autonomously select the window. +* +* Return 0 on success +* -1 on error +*/ +static int parse_activity_window (xc_set_cppc_para_t *set_cppc,unsigned long u, +const char *suffix) +{ +unsigned int exponent =0 ; +unsigned int multiplier =1 ; + +if ( suffix && suffix[0 ] ) + { +if (strcmp (suffix,"s" ) ==0 ) + { + multiplier =1000 *1000 ; + exponent =6 ; + } +else if (strcmp (suffix,"ms" ) ==0 ) + { + multiplier =1000 ; + exponent =3 ; + } +else if (strcmp (suffix,"us" ) !=0 ) + { +fprintf (stderr,"invalid activity window units: \"%s\"\n" , suffix); + +return -1 ; + } + } + +/* u * multipler > 1270 * 1000 * 1000 transformed to avoid overflow. */ +if ( u >1270 *1000 *1000 / multiplier ) + { +fprintf (stderr,"activity window is too large\n" ); + +return -1 ; + } + +/* looking for 7 bits of mantissa and 3 bits of exponent */ +while ( u >127 ) + { + u +=5 ;/* Round up to mitigate truncation rounding down +e.g. 128 -> 120 vs 128 -> 130. */ + u /=10 ; + exponent +=1 ; + } + + set_cppc->activity_window = +MASK_INSR (exponent,XEN_CPPC_ACT_WINDOW_EXPONENT_MASK ) | +MASK_INSR (u,XEN_CPPC_ACT_WINDOW_MANTISSA_MASK ); + set_cppc->set_params |=XEN_SYSCTL_CPPC_SET_ACT_WINDOW ; + +return 0 ; +} + +static int parse_cppc_opts (xc_set_cppc_para_t *set_cppc,int *cpuid, +int argc,char *argv[]) +{ +int i =0 ; + +if ( argc <1 ) + { +fprintf (stderr,"Missing arguments\n" ); +return -1 ; + } + +if (isdigit (argv[i][0 ]) ) + { +if (sscanf (argv[i],"%d" , cpuid) !=1 || *cpuid <0 ) + { +fprintf (stderr,"Could not parse cpuid \"%s\"\n" , argv[i]); +return -1 ; + } + + i++; + } + +if ( i == argc ) + { +fprintf (stderr,"Missing arguments\n" ); +return -1 ; + } + +if (strcasecmp (argv[i],"powersave" ) ==0 ) + { + set_cppc->set_params =XEN_SYSCTL_CPPC_SET_PRESET_POWERSAVE ; + i++; + } +else if (strcasecmp (argv[i],"performance" ) ==0 ) + { + set_cppc->set_params =XEN_SYSCTL_CPPC_SET_PRESET_PERFORMANCE ; + i++; + } +else if (strcasecmp (argv[i],"balance" ) ==0 ) + { + set_cppc->set_params =XEN_SYSCTL_CPPC_SET_PRESET_BALANCE ; + i++; + } + +for ( ; i < argc; i++) + { +unsigned long val; +char *param = argv[i]; +char *value; +char *suffix; +int ret; + + value =strchr (param,':' ); +if ( value ==NULL ) + { +fprintf (stderr,"\"%s\" is an invalid cppc parameter\n" , argv[i]); +return -1 ; + } + + value[0 ] ='\0' ; + value++; + + errno =0 ; + val =strtoul (value, &suffix,10 ); +if ( (errno && val ==ULONG_MAX ) || value == suffix ) + { +fprintf (stderr,"Could not parse number \"%s\"\n" , value); +return -1 ; + } + +if (strncasecmp (param,"act-window" ,strlen (param)) ==0 ) + { + ret =parse_activity_window (set_cppc, val, suffix); +if (ret) +return -1 ; + +continue ; + } + +if ( val >255 ) + { +fprintf (stderr,"\"%s\" value \"%lu\" is out of range\n" , param, + val); +return -1 ; + } + +if ( suffix && suffix[0 ] ) + { +fprintf (stderr,"Suffix \"%s\" is invalid\n" , suffix); +return -1 ; + } + +if (strncasecmp (param,"minimum" ,MAX (2 ,strlen (param))) ==0 ) + { + set_cppc->minimum = val; + set_cppc->set_params |=XEN_SYSCTL_CPPC_SET_MINIMUM ; + } +else if (strncasecmp (param,"maximum" ,MAX (2 ,strlen (param))) ==0 ) + { + set_cppc->maximum = val; + set_cppc->set_params |=XEN_SYSCTL_CPPC_SET_MAXIMUM ; + } +else if (strncasecmp (param,"desired" ,strlen (param)) ==0 ) + { + set_cppc->desired = val; + set_cppc->set_params |=XEN_SYSCTL_CPPC_SET_DESIRED ; + } +else if (strncasecmp (param,"energy-perf" ,strlen (param)) ==0 ) + { + set_cppc->energy_perf = val; + set_cppc->set_params |=XEN_SYSCTL_CPPC_SET_ENERGY_PERF ; + } +else + { +fprintf (stderr,"\"%s\" is an invalid parameter\n" , param); +return -1 ; + } + } + +if ( set_cppc->set_params ==0 ) + { +fprintf (stderr,"No parameters set in request\n" ); +return -1 ; + } + +return 0 ; +} + +static void cppc_set_func (int argc,char *argv[]) +{ +xc_set_cppc_para_t set_cppc = {}; +unsigned int max_cpuid = max_cpu_nr; +int cpuid =-1 ; +unsigned int i =0 ; +uint32_t set_params; + +if (parse_cppc_opts (&set_cppc, &cpuid, argc, argv) ) +exit (EINVAL ); + +if ( cpuid !=-1 ) + { + i = cpuid; + max_cpuid = i +1 ; + } + + set_params = set_cppc.set_params; +for ( ; i < max_cpuid; i++ ) { +if (xc_set_cpufreq_cppc (xc_handle, i, &set_cppc) ) +fprintf (stderr,"[CPU%d] failed to set cppc params (%d - %s)\n" , + i, errno,strerror (errno)); + } + +if ( (set_params ^ set_cppc.set_params) &XEN_SYSCTL_CPPC_SET_ACT_WINDOW ) +printf ("Activity window not supported and omitted\n" ); +} +struct {const char *name;void (*function)(int argc,char *argv[]);
@@ -1302,6 +1545,7 @@ struct { { "get-cpufreq-average", cpufreq_func }, { "start", start_gather_func }, { "get-cpufreq-para", cpufreq_para_func }, + { "set-cpufreq-cppc", cppc_set_func }, { "set-scaling-maxfreq", scaling_max_freq_func }, { "set-scaling-minfreq", scaling_min_freq_func }, { "set-scaling-governor", scaling_governor_func },
Signature · 1 line
2.41.0
PATCH v6 15/15 CHANGELOG: Add Intel HWP entry
In reply to Jason Andryuk---
v3:
Position under existing Added section
Add Henry's Ack
v2:
Add blank line
--- CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
CHANGELOG.md +1 -1
@@ -24,7 +24,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) - xl/libxl can customize SMBIOS strings for HVM guests. - Add support for AVX512-FP16 on x86. - On Arm, Xen supports guests running SVE/SVE2 instructions. (Tech Preview) - + - Add Intel Hardware P-States (HWP) cpufreq driver. ## [4.17.0](https://xenbits.xen.org/gitweb/?p=xen.git;a=shortlog;h=RELEASE-4.17.0) - 2022-12-12
Signature · 1 line
2.41.0