x86 / CPU: Always show current CPU frequency in /proc/cpuinfo

commit 7d5905dc14a87805a59f3c5bf70173aac2bb18f8 upstream.

After commit 890da9cf0983 (Revert "x86: do not use cpufreq_quick_get()
for /proc/cpuinfo "cpu MHz"") the "cpu MHz" number in /proc/cpuinfo
on x86 can be either the nominal CPU frequency (which is constant)
or the frequency most recently requested by a scaling governor in
cpufreq, depending on the cpufreq configuration.  That is somewhat
inconsistent and is different from what it was before 4.13, so in
order to restore the previous behavior, make it report the current
CPU frequency like the scaling_cur_freq sysfs file in cpufreq.

To that end, modify the /proc/cpuinfo implementation on x86 to use
aperfmperf_snapshot_khz() to snapshot the APERF and MPERF feedback
registers, if available, and use their values to compute the CPU
frequency to be reported as "cpu MHz".

However, do that carefully enough to avoid accumulating delays that
lead to unacceptable access times for /proc/cpuinfo on systems with
many CPUs.  Run aperfmperf_snapshot_khz() once on all CPUs
asynchronously at the /proc/cpuinfo open time, add a single delay
upfront (if necessary) at that point and simply compute the current
frequency while running show_cpuinfo() for each individual CPU.

Also, to avoid slowing down /proc/cpuinfo accesses too much, reduce
the default delay between consecutive APERF and MPERF reads to 10 ms,
which should be sufficient to get large enough numbers for the
frequency computation in all cases.

Fixes: 890da9cf0983 (Revert "x86: do not use cpufreq_quick_get() for /proc/cpuinfo "cpu MHz"")
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Acked-by: Thomas Gleixner <tglx@linutronix.de>
Tested-by: Thomas Gleixner <tglx@linutronix.de>
Acked-by: Ingo Molnar <mingo@kernel.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/arch/x86/kernel/cpu/Makefile b/arch/x86/kernel/cpu/Makefile
index 90cb82dbba577cc3bd7dd1e9cf63ef9b89c89daa..570e8bb1f386d918487ca0a01991b9e5f0052d9e 100644 (file)
--- a/arch/x86/kernel/cpu/Makefile
+++ b/arch/x86/kernel/cpu/Makefile
@@ -22,7 +22,7 @@ obj-y                 += common.o
 obj-y                  += rdrand.o
 obj-y                  += match.o
 obj-y                  += bugs.o
-obj-$(CONFIG_CPU_FREQ) += aperfmperf.o
+obj-y                  += aperfmperf.o
 obj-y                  += cpuid-deps.o
 
 obj-$(CONFIG_PROC_FS)  += proc.o

diff --git a/arch/x86/kernel/cpu/aperfmperf.c b/arch/x86/kernel/cpu/aperfmperf.c
index 957813e0180d278563bf33289c54c7462ca83a8a..7eba34df54c3d44e17e3685321a7e9a6ca3b0f25 100644 (file)
--- a/arch/x86/kernel/cpu/aperfmperf.c
+++ b/arch/x86/kernel/cpu/aperfmperf.c
@@ -14,6 +14,8 @@
 #include <linux/percpu.h>
 #include <linux/smp.h>
 
+#include "cpu.h"
+
 struct aperfmperf_sample {
        unsigned int    khz;
        ktime_t time;
@@ -24,7 +26,7 @@ struct aperfmperf_sample {
 static DEFINE_PER_CPU(struct aperfmperf_sample, samples);
 
 #define APERFMPERF_CACHE_THRESHOLD_MS  10
-#define APERFMPERF_REFRESH_DELAY_MS    20
+#define APERFMPERF_REFRESH_DELAY_MS    10
 #define APERFMPERF_STALE_THRESHOLD_MS  1000
 
 /*
@@ -38,8 +40,6 @@ static void aperfmperf_snapshot_khz(void *dummy)
        u64 aperf, aperf_delta;
        u64 mperf, mperf_delta;
        struct aperfmperf_sample *s = this_cpu_ptr(&samples);
-       ktime_t now = ktime_get();
-       s64 time_delta = ktime_ms_delta(now, s->time);
        unsigned long flags;
 
        local_irq_save(flags);
@@ -57,38 +57,68 @@ static void aperfmperf_snapshot_khz(void *dummy)
        if (mperf_delta == 0)
                return;
 
-       s->time = now;
+       s->time = ktime_get();
        s->aperf = aperf;
        s->mperf = mperf;
-
-       /* If the previous iteration was too long ago, discard it. */
-       if (time_delta > APERFMPERF_STALE_THRESHOLD_MS)
-               s->khz = 0;
-       else
-               s->khz = div64_u64((cpu_khz * aperf_delta), mperf_delta);
+       s->khz = div64_u64((cpu_khz * aperf_delta), mperf_delta);
 }
 
-unsigned int arch_freq_get_on_cpu(int cpu)
+static bool aperfmperf_snapshot_cpu(int cpu, ktime_t now, bool wait)
 {
-       s64 time_delta;
-       unsigned int khz;
+       s64 time_delta = ktime_ms_delta(now, per_cpu(samples.time, cpu));
+
+       /* Don't bother re-computing within the cache threshold time. */
+       if (time_delta < APERFMPERF_CACHE_THRESHOLD_MS)
+               return true;
+
+       smp_call_function_single(cpu, aperfmperf_snapshot_khz, NULL, wait);
+
+       /* Return false if the previous iteration was too long ago. */
+       return time_delta <= APERFMPERF_STALE_THRESHOLD_MS;
+}
 
+unsigned int aperfmperf_get_khz(int cpu)
+{
        if (!cpu_khz)
                return 0;
 
        if (!static_cpu_has(X86_FEATURE_APERFMPERF))
                return 0;
 
-       /* Don't bother re-computing within the cache threshold time. */
-       time_delta = ktime_ms_delta(ktime_get(), per_cpu(samples.time, cpu));
-       khz = per_cpu(samples.khz, cpu);
-       if (khz && time_delta < APERFMPERF_CACHE_THRESHOLD_MS)
-               return khz;
+       aperfmperf_snapshot_cpu(cpu, ktime_get(), true);
+       return per_cpu(samples.khz, cpu);
+}
 
-       smp_call_function_single(cpu, aperfmperf_snapshot_khz, NULL, 1);
-       khz = per_cpu(samples.khz, cpu);
-       if (khz)
-               return khz;
+void arch_freq_prepare_all(void)
+{
+       ktime_t now = ktime_get();
+       bool wait = false;
+       int cpu;
+
+       if (!cpu_khz)
+               return;
+
+       if (!static_cpu_has(X86_FEATURE_APERFMPERF))
+               return;
+
+       for_each_online_cpu(cpu)
+               if (!aperfmperf_snapshot_cpu(cpu, now, false))
+                       wait = true;
+
+       if (wait)
+               msleep(APERFMPERF_REFRESH_DELAY_MS);
+}
+
+unsigned int arch_freq_get_on_cpu(int cpu)
+{
+       if (!cpu_khz)
+               return 0;
+
+       if (!static_cpu_has(X86_FEATURE_APERFMPERF))
+               return 0;
+
+       if (aperfmperf_snapshot_cpu(cpu, ktime_get(), true))
+               return per_cpu(samples.khz, cpu);
 
        msleep(APERFMPERF_REFRESH_DELAY_MS);
        smp_call_function_single(cpu, aperfmperf_snapshot_khz, NULL, 1);

diff --git a/arch/x86/kernel/cpu/cpu.h b/arch/x86/kernel/cpu/cpu.h
index f52a370b6c00f99a4d4333a7f612bd351dd48c30..e806b11a99af4c72c5868731c7a8555cfb3957d9 100644 (file)
--- a/arch/x86/kernel/cpu/cpu.h
+++ b/arch/x86/kernel/cpu/cpu.h
@@ -47,4 +47,7 @@ extern const struct cpu_dev *const __x86_cpu_dev_start[],
 
 extern void get_cpu_cap(struct cpuinfo_x86 *c);
 extern void cpu_detect_cache_sizes(struct cpuinfo_x86 *c);
+
+unsigned int aperfmperf_get_khz(int cpu);
+
 #endif /* ARCH_X86_CPU_H */

diff --git a/arch/x86/kernel/cpu/proc.c b/arch/x86/kernel/cpu/proc.c
index 6b7e17bf0b71dd63394b0ec5a83bea508c7ebfe9..e7ecedafa1c8f7b033eccbdcf24198089933b386 100644 (file)
--- a/arch/x86/kernel/cpu/proc.c
+++ b/arch/x86/kernel/cpu/proc.c
@@ -5,6 +5,8 @@
 #include <linux/seq_file.h>
 #include <linux/cpufreq.h>
 
+#include "cpu.h"
+
 /*
  *     Get CPU information for use by the procfs.
  */
@@ -78,8 +80,10 @@ static int show_cpuinfo(struct seq_file *m, void *v)
                seq_printf(m, "microcode\t: 0x%x\n", c->microcode);
 
        if (cpu_has(c, X86_FEATURE_TSC)) {
-               unsigned int freq = cpufreq_quick_get(cpu);
+               unsigned int freq = aperfmperf_get_khz(cpu);
 
+               if (!freq)
+                       freq = cpufreq_quick_get(cpu);
                if (!freq)
                        freq = cpu_khz;
                seq_printf(m, "cpu MHz\t\t: %u.%03u\n",

diff --git a/fs/proc/cpuinfo.c b/fs/proc/cpuinfo.c
index e0f867cd855375ce42c0fae37518d941e36c9236..96f1087e372c19332d0acc23fb588a06cf10efe8 100644 (file)
--- a/fs/proc/cpuinfo.c
+++ b/fs/proc/cpuinfo.c
@@ -1,12 +1,18 @@
 // SPDX-License-Identifier: GPL-2.0
+#include <linux/cpufreq.h>
 #include <linux/fs.h>
 #include <linux/init.h>
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
 
+__weak void arch_freq_prepare_all(void)
+{
+}
+
 extern const struct seq_operations cpuinfo_op;
 static int cpuinfo_open(struct inode *inode, struct file *file)
 {
+       arch_freq_prepare_all();
        return seq_open(file, &cpuinfo_op);
 }
 

diff --git a/include/linux/cpufreq.h b/include/linux/cpufreq.h
index 537ff842ff733290252c795b2a8261b82944fd94..cbf85c4c745f856b6c5e8f4f6d6c3dad80b887c7 100644 (file)
--- a/include/linux/cpufreq.h
+++ b/include/linux/cpufreq.h
@@ -917,6 +917,7 @@ static inline bool policy_has_boost_freq(struct cpufreq_policy *policy)
 }
 #endif
 
+extern void arch_freq_prepare_all(void);
 extern unsigned int arch_freq_get_on_cpu(int cpu);
 
 /* the following are really really optional */