diff mbox

[012/100] acpi: fix of pmtimer overflow that make Cx states time incorrect

Message ID 20090423072212.535803819@sous-sol.org (mailing list archive)
State Not Applicable, archived
Headers show

Commit Message

Chris Wright April 23, 2009, 7:20 a.m. UTC 
-stable review patch.  If anyone has any objections, please let us know.
---------------------

From: alex.shi <alex.shi@intel.com>

upstream commit: ff69f2bba67bd45514923aaedbf40fe351787c59

We found Cx states time abnormal in our some of machines which have 16
LCPUs, the C0 take too many time while system is really idle when kernel
enabled tickless and highres.  powertop output is below:

     PowerTOP version 1.9       (C) 2007 Intel Corporation

Cn                Avg residency       P-states (frequencies)
C0 (cpu running)        (40.5%)         2.53 Ghz     0.0%
C1                0.0ms ( 0.0%)         2.53 Ghz     0.0%
C2              128.8ms (59.5%)         2.40 Ghz     0.0%
                                        1.60 Ghz   100.0%

Wakeups-from-idle per second :  4.7     interval: 20.0s
no ACPI power usage estimate available

Top causes for wakeups:
  41.4% ( 24.9)       <interrupt> : extra timer interrupt
  20.2% ( 12.2)     <kernel core> : usb_hcd_poll_rh_status
(rh_timer_func)

After tacking detailed for this issue, Yakui and I find it is due to 24
bit PM timer overflows when some of cpu sleep more than 4 seconds.  With
tickless kernel, the CPU want to sleep as much as possible when system
idle.  But the Cx sleep time are recorded by pmtimer which length is
determined by BIOS.  The current Cx time was gotten in the following
function from driver/acpi/processor_idle.c:

static inline u32 ticks_elapsed(u32 t1, u32 t2)
{
       if (t2 >= t1)
               return (t2 - t1);
       else if (!(acpi_gbl_FADT.flags & ACPI_FADT_32BIT_TIMER))
               return (((0x00FFFFFF - t1) + t2) & 0x00FFFFFF);
       else
               return ((0xFFFFFFFF - t1) + t2);
}

If pmtimer is 24 bits and it take 5 seconds from t1 to t2, in above
function, just about 1 seconds ticks was recorded.  So the Cx time will be
reduced about 4 seconds.  and this is why we see above powertop output.

To resolve this problem, Yakui and I use ktime_get() to record the Cx
states time instead of PM timer as the following patch.  the patch was
tested with i386/x86_64 modes on several platforms.

Acked-by: Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
Tested-by: Alex Shi <alex.shi@intel.com>
Signed-off-by: Alex Shi <alex.shi@intel.com>
Signed-off-by: Yakui.zhao <yakui.zhao@intel.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Len Brown <len.brown@intel.com>
Signed-off-by: Chris Wright <chrisw@sous-sol.org>
---
 drivers/acpi/processor_idle.c |   63 ++++++++++++++++++------------------------
 1 file changed, 27 insertions(+), 36 deletions(-)


--
To unsubscribe from this list: send the line "unsubscribe linux-acpi" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Comments

alex.shi April 23, 2009, 9:24 a.m. UTC | #1 
It was reported make some latop booting hang. and is not root caused now. :(
http://bugzilla.kernel.org/show_bug.cgi?id=13087 

Alex 
>-----Original Message-----
>From: Chris Wright [mailto:chrisw@sous-sol.org]
>Sent: 2009年4月23日 15:21
>To: linux-kernel@vger.kernel.org; stable@kernel.org
>Cc: Justin Forbes; Zwane Mwaikambo; Theodore Ts'o; Randy Dunlap; Dave Jones;
>Chuck Wolber; Chris Wedgwood; Michael Krufky; Chuck Ebbert; Domenico Andreoli;
>Willy Tarreau; Rodrigo Rubira Branco; Jake Edge; Eugene Teo;
>torvalds@linux-foundation.org; akpm@linux-foundation.org;
>alan@lxorguk.ukuu.org.uk; Len Brown; linux-acpi@vger.kernel.org; Shi, Alex;
>Pallipadi, Venkatesh; Zhao, Yakui; Brown, Len
>Subject: [patch 012/100] acpi: fix of pmtimer overflow that make Cx states time
>incorrect
>
>-stable review patch.  If anyone has any objections, please let us know.
>---------------------
>
>From: alex.shi <alex.shi@intel.com>
>
>upstream commit: ff69f2bba67bd45514923aaedbf40fe351787c59
>
>We found Cx states time abnormal in our some of machines which have 16
>LCPUs, the C0 take too many time while system is really idle when kernel
>enabled tickless and highres.  powertop output is below:
>
>     PowerTOP version 1.9       (C) 2007 Intel Corporation
>
>Cn                Avg residency       P-states (frequencies)
>C0 (cpu running)        (40.5%)         2.53 Ghz     0.0%
>C1                0.0ms ( 0.0%)         2.53 Ghz     0.0%
>C2              128.8ms (59.5%)         2.40 Ghz     0.0%
>                                        1.60 Ghz   100.0%
>
>Wakeups-from-idle per second :  4.7     interval: 20.0s
>no ACPI power usage estimate available
>
>Top causes for wakeups:
>  41.4% ( 24.9)       <interrupt> : extra timer interrupt
>  20.2% ( 12.2)     <kernel core> : usb_hcd_poll_rh_status
>(rh_timer_func)
>
>After tacking detailed for this issue, Yakui and I find it is due to 24
>bit PM timer overflows when some of cpu sleep more than 4 seconds.  With
>tickless kernel, the CPU want to sleep as much as possible when system
>idle.  But the Cx sleep time are recorded by pmtimer which length is
>determined by BIOS.  The current Cx time was gotten in the following
>function from driver/acpi/processor_idle.c:
>
>static inline u32 ticks_elapsed(u32 t1, u32 t2)
>{
>       if (t2 >= t1)
>               return (t2 - t1);
>       else if (!(acpi_gbl_FADT.flags & ACPI_FADT_32BIT_TIMER))
>               return (((0x00FFFFFF - t1) + t2) & 0x00FFFFFF);
>       else
>               return ((0xFFFFFFFF - t1) + t2);
>}
>
>If pmtimer is 24 bits and it take 5 seconds from t1 to t2, in above
>function, just about 1 seconds ticks was recorded.  So the Cx time will be
>reduced about 4 seconds.  and this is why we see above powertop output.
>
>To resolve this problem, Yakui and I use ktime_get() to record the Cx
>states time instead of PM timer as the following patch.  the patch was
>tested with i386/x86_64 modes on several platforms.
>
>Acked-by: Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
>Tested-by: Alex Shi <alex.shi@intel.com>
>Signed-off-by: Alex Shi <alex.shi@intel.com>
>Signed-off-by: Yakui.zhao <yakui.zhao@intel.com>
>Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
>Signed-off-by: Len Brown <len.brown@intel.com>
>Signed-off-by: Chris Wright <chrisw@sous-sol.org>
>---
> drivers/acpi/processor_idle.c |   63
>++++++++++++++++++------------------------
> 1 file changed, 27 insertions(+), 36 deletions(-)
>
>--- a/drivers/acpi/processor_idle.c
>+++ b/drivers/acpi/processor_idle.c
>@@ -64,7 +64,6 @@
> #define _COMPONENT              ACPI_PROCESSOR_COMPONENT
> ACPI_MODULE_NAME("processor_idle");
> #define ACPI_PROCESSOR_FILE_POWER	"power"
>-#define US_TO_PM_TIMER_TICKS(t)		((t * (PM_TIMER_FREQUENCY/1000)) /
>1000)
> #define PM_TIMER_TICK_NS		(1000000000ULL/PM_TIMER_FREQUENCY)
> #define C2_OVERHEAD			1	/* 1us */
> #define C3_OVERHEAD			1	/* 1us */
>@@ -78,6 +77,10 @@ module_param(nocst, uint, 0000);
> static unsigned int latency_factor __read_mostly = 2;
> module_param(latency_factor, uint, 0644);
>
>+static s64 us_to_pm_timer_ticks(s64 t)
>+{
>+	return div64_u64(t * PM_TIMER_FREQUENCY, 1000000);
>+}
> /*
>  * IBM ThinkPad R40e crashes mysteriously when going into C2 or C3.
>  * For now disable this. Probably a bug somewhere else.
>@@ -159,25 +162,6 @@ static struct dmi_system_id __cpuinitdat
> 	{},
> };
>
>-static inline u32 ticks_elapsed(u32 t1, u32 t2)
>-{
>-	if (t2 >= t1)
>-		return (t2 - t1);
>-	else if (!(acpi_gbl_FADT.flags & ACPI_FADT_32BIT_TIMER))
>-		return (((0x00FFFFFF - t1) + t2) & 0x00FFFFFF);
>-	else
>-		return ((0xFFFFFFFF - t1) + t2);
>-}
>-
>-static inline u32 ticks_elapsed_in_us(u32 t1, u32 t2)
>-{
>-	if (t2 >= t1)
>-		return PM_TIMER_TICKS_TO_US(t2 - t1);
>-	else if (!(acpi_gbl_FADT.flags & ACPI_FADT_32BIT_TIMER))
>-		return PM_TIMER_TICKS_TO_US(((0x00FFFFFF - t1) + t2) & 0x00FFFFFF);
>-	else
>-		return PM_TIMER_TICKS_TO_US((0xFFFFFFFF - t1) + t2);
>-}
>
> /*
>  * Callers should disable interrupts before the call and enable
>@@ -853,7 +837,8 @@ static inline void acpi_idle_do_entry(st
> static int acpi_idle_enter_c1(struct cpuidle_device *dev,
> 			      struct cpuidle_state *state)
> {
>-	u32 t1, t2;
>+	ktime_t  kt1, kt2;
>+	s64 idle_time;
> 	struct acpi_processor *pr;
> 	struct acpi_processor_cx *cx = cpuidle_get_statedata(state);
>
>@@ -871,14 +856,15 @@ static int acpi_idle_enter_c1(struct cpu
> 		return 0;
> 	}
>
>-	t1 = inl(acpi_gbl_FADT.xpm_timer_block.address);
>+	kt1 = ktime_get_real();
> 	acpi_idle_do_entry(cx);
>-	t2 = inl(acpi_gbl_FADT.xpm_timer_block.address);
>+	kt2 = ktime_get_real();
>+	idle_time =  ktime_to_us(ktime_sub(kt2, kt1));
>
> 	local_irq_enable();
> 	cx->usage++;
>
>-	return ticks_elapsed_in_us(t1, t2);
>+	return idle_time;
> }
>
> /**
>@@ -891,8 +877,9 @@ static int acpi_idle_enter_simple(struct
> {
> 	struct acpi_processor *pr;
> 	struct acpi_processor_cx *cx = cpuidle_get_statedata(state);
>-	u32 t1, t2;
>-	int sleep_ticks = 0;
>+	ktime_t  kt1, kt2;
>+	s64 idle_time;
>+	s64 sleep_ticks = 0;
>
> 	pr = __get_cpu_var(processors);
>
>@@ -925,18 +912,19 @@ static int acpi_idle_enter_simple(struct
> 	if (cx->type == ACPI_STATE_C3)
> 		ACPI_FLUSH_CPU_CACHE();
>
>-	t1 = inl(acpi_gbl_FADT.xpm_timer_block.address);
>+	kt1 = ktime_get_real();
> 	/* Tell the scheduler that we are going deep-idle: */
> 	sched_clock_idle_sleep_event();
> 	acpi_idle_do_entry(cx);
>-	t2 = inl(acpi_gbl_FADT.xpm_timer_block.address);
>+	kt2 = ktime_get_real();
>+	idle_time =  ktime_to_us(ktime_sub(kt2, kt1));
>
> #if defined (CONFIG_GENERIC_TIME) && defined (CONFIG_X86)
> 	/* TSC could halt in idle, so notify users */
> 	if (tsc_halts_in_c(cx->type))
> 		mark_tsc_unstable("TSC halts in idle");;
> #endif
>-	sleep_ticks = ticks_elapsed(t1, t2);
>+	sleep_ticks = us_to_pm_timer_ticks(idle_time);
>
> 	/* Tell the scheduler how much we idled: */
> 	sched_clock_idle_wakeup_event(sleep_ticks*PM_TIMER_TICK_NS);
>@@ -948,7 +936,7 @@ static int acpi_idle_enter_simple(struct
>
> 	acpi_state_timer_broadcast(pr, cx, 0);
> 	cx->time += sleep_ticks;
>-	return ticks_elapsed_in_us(t1, t2);
>+	return idle_time;
> }
>
> static int c3_cpu_count;
>@@ -966,8 +954,10 @@ static int acpi_idle_enter_bm(struct cpu
> {
> 	struct acpi_processor *pr;
> 	struct acpi_processor_cx *cx = cpuidle_get_statedata(state);
>-	u32 t1, t2;
>-	int sleep_ticks = 0;
>+	ktime_t  kt1, kt2;
>+	s64 idle_time;
>+	s64 sleep_ticks = 0;
>+
>
> 	pr = __get_cpu_var(processors);
>
>@@ -1034,9 +1024,10 @@ static int acpi_idle_enter_bm(struct cpu
> 		ACPI_FLUSH_CPU_CACHE();
> 	}
>
>-	t1 = inl(acpi_gbl_FADT.xpm_timer_block.address);
>+	kt1 = ktime_get_real();
> 	acpi_idle_do_entry(cx);
>-	t2 = inl(acpi_gbl_FADT.xpm_timer_block.address);
>+	kt2 = ktime_get_real();
>+	idle_time =  ktime_to_us(ktime_sub(kt2, kt1));
>
> 	/* Re-enable bus master arbitration */
> 	if (pr->flags.bm_check && pr->flags.bm_control) {
>@@ -1051,7 +1042,7 @@ static int acpi_idle_enter_bm(struct cpu
> 	if (tsc_halts_in_c(ACPI_STATE_C3))
> 		mark_tsc_unstable("TSC halts in idle");
> #endif
>-	sleep_ticks = ticks_elapsed(t1, t2);
>+	sleep_ticks = us_to_pm_timer_ticks(idle_time);
> 	/* Tell the scheduler how much we idled: */
> 	sched_clock_idle_wakeup_event(sleep_ticks*PM_TIMER_TICK_NS);
>
>@@ -1062,7 +1053,7 @@ static int acpi_idle_enter_bm(struct cpu
>
> 	acpi_state_timer_broadcast(pr, cx, 0);
> 	cx->time += sleep_ticks;
>-	return ticks_elapsed_in_us(t1, t2);
>+	return idle_time;
> }
>
> struct cpuidle_driver acpi_idle_driver = {
alex.shi April 23, 2009, 9:40 a.m. UTC | #2 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--
To unsubscribe from this list: send the line "unsubscribe linux-acpi" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
diff mbox

Patch

--- a/drivers/acpi/processor_idle.c
+++ b/drivers/acpi/processor_idle.c
@@ -64,7 +64,6 @@ 
 #define _COMPONENT              ACPI_PROCESSOR_COMPONENT
 ACPI_MODULE_NAME("processor_idle");
 #define ACPI_PROCESSOR_FILE_POWER	"power"
-#define US_TO_PM_TIMER_TICKS(t)		((t * (PM_TIMER_FREQUENCY/1000)) / 1000)
 #define PM_TIMER_TICK_NS		(1000000000ULL/PM_TIMER_FREQUENCY)
 #define C2_OVERHEAD			1	/* 1us */
 #define C3_OVERHEAD			1	/* 1us */
@@ -78,6 +77,10 @@  module_param(nocst, uint, 0000);
 static unsigned int latency_factor __read_mostly = 2;
 module_param(latency_factor, uint, 0644);
 
+static s64 us_to_pm_timer_ticks(s64 t)
+{
+	return div64_u64(t * PM_TIMER_FREQUENCY, 1000000);
+}
 /*
  * IBM ThinkPad R40e crashes mysteriously when going into C2 or C3.
  * For now disable this. Probably a bug somewhere else.
@@ -159,25 +162,6 @@  static struct dmi_system_id __cpuinitdat
 	{},
 };
 
-static inline u32 ticks_elapsed(u32 t1, u32 t2)
-{
-	if (t2 >= t1)
-		return (t2 - t1);
-	else if (!(acpi_gbl_FADT.flags & ACPI_FADT_32BIT_TIMER))
-		return (((0x00FFFFFF - t1) + t2) & 0x00FFFFFF);
-	else
-		return ((0xFFFFFFFF - t1) + t2);
-}
-
-static inline u32 ticks_elapsed_in_us(u32 t1, u32 t2)
-{
-	if (t2 >= t1)
-		return PM_TIMER_TICKS_TO_US(t2 - t1);
-	else if (!(acpi_gbl_FADT.flags & ACPI_FADT_32BIT_TIMER))
-		return PM_TIMER_TICKS_TO_US(((0x00FFFFFF - t1) + t2) & 0x00FFFFFF);
-	else
-		return PM_TIMER_TICKS_TO_US((0xFFFFFFFF - t1) + t2);
-}
 
 /*
  * Callers should disable interrupts before the call and enable
@@ -853,7 +837,8 @@  static inline void acpi_idle_do_entry(st
 static int acpi_idle_enter_c1(struct cpuidle_device *dev,
 			      struct cpuidle_state *state)
 {
-	u32 t1, t2;
+	ktime_t  kt1, kt2;
+	s64 idle_time;
 	struct acpi_processor *pr;
 	struct acpi_processor_cx *cx = cpuidle_get_statedata(state);
 
@@ -871,14 +856,15 @@  static int acpi_idle_enter_c1(struct cpu
 		return 0;
 	}
 
-	t1 = inl(acpi_gbl_FADT.xpm_timer_block.address);
+	kt1 = ktime_get_real();
 	acpi_idle_do_entry(cx);
-	t2 = inl(acpi_gbl_FADT.xpm_timer_block.address);
+	kt2 = ktime_get_real();
+	idle_time =  ktime_to_us(ktime_sub(kt2, kt1));
 
 	local_irq_enable();
 	cx->usage++;
 
-	return ticks_elapsed_in_us(t1, t2);
+	return idle_time;
 }
 
 /**
@@ -891,8 +877,9 @@  static int acpi_idle_enter_simple(struct
 {
 	struct acpi_processor *pr;
 	struct acpi_processor_cx *cx = cpuidle_get_statedata(state);
-	u32 t1, t2;
-	int sleep_ticks = 0;
+	ktime_t  kt1, kt2;
+	s64 idle_time;
+	s64 sleep_ticks = 0;
 
 	pr = __get_cpu_var(processors);
 
@@ -925,18 +912,19 @@  static int acpi_idle_enter_simple(struct
 	if (cx->type == ACPI_STATE_C3)
 		ACPI_FLUSH_CPU_CACHE();
 
-	t1 = inl(acpi_gbl_FADT.xpm_timer_block.address);
+	kt1 = ktime_get_real();
 	/* Tell the scheduler that we are going deep-idle: */
 	sched_clock_idle_sleep_event();
 	acpi_idle_do_entry(cx);
-	t2 = inl(acpi_gbl_FADT.xpm_timer_block.address);
+	kt2 = ktime_get_real();
+	idle_time =  ktime_to_us(ktime_sub(kt2, kt1));
 
 #if defined (CONFIG_GENERIC_TIME) && defined (CONFIG_X86)
 	/* TSC could halt in idle, so notify users */
 	if (tsc_halts_in_c(cx->type))
 		mark_tsc_unstable("TSC halts in idle");;
 #endif
-	sleep_ticks = ticks_elapsed(t1, t2);
+	sleep_ticks = us_to_pm_timer_ticks(idle_time);
 
 	/* Tell the scheduler how much we idled: */
 	sched_clock_idle_wakeup_event(sleep_ticks*PM_TIMER_TICK_NS);
@@ -948,7 +936,7 @@  static int acpi_idle_enter_simple(struct
 
 	acpi_state_timer_broadcast(pr, cx, 0);
 	cx->time += sleep_ticks;
-	return ticks_elapsed_in_us(t1, t2);
+	return idle_time;
 }
 
 static int c3_cpu_count;
@@ -966,8 +954,10 @@  static int acpi_idle_enter_bm(struct cpu
 {
 	struct acpi_processor *pr;
 	struct acpi_processor_cx *cx = cpuidle_get_statedata(state);
-	u32 t1, t2;
-	int sleep_ticks = 0;
+	ktime_t  kt1, kt2;
+	s64 idle_time;
+	s64 sleep_ticks = 0;
+
 
 	pr = __get_cpu_var(processors);
 
@@ -1034,9 +1024,10 @@  static int acpi_idle_enter_bm(struct cpu
 		ACPI_FLUSH_CPU_CACHE();
 	}
 
-	t1 = inl(acpi_gbl_FADT.xpm_timer_block.address);
+	kt1 = ktime_get_real();
 	acpi_idle_do_entry(cx);
-	t2 = inl(acpi_gbl_FADT.xpm_timer_block.address);
+	kt2 = ktime_get_real();
+	idle_time =  ktime_to_us(ktime_sub(kt2, kt1));
 
 	/* Re-enable bus master arbitration */
 	if (pr->flags.bm_check && pr->flags.bm_control) {
@@ -1051,7 +1042,7 @@  static int acpi_idle_enter_bm(struct cpu
 	if (tsc_halts_in_c(ACPI_STATE_C3))
 		mark_tsc_unstable("TSC halts in idle");
 #endif
-	sleep_ticks = ticks_elapsed(t1, t2);
+	sleep_ticks = us_to_pm_timer_ticks(idle_time);
 	/* Tell the scheduler how much we idled: */
 	sched_clock_idle_wakeup_event(sleep_ticks*PM_TIMER_TICK_NS);
 
@@ -1062,7 +1053,7 @@  static int acpi_idle_enter_bm(struct cpu
 
 	acpi_state_timer_broadcast(pr, cx, 0);
 	cx->time += sleep_ticks;
-	return ticks_elapsed_in_us(t1, t2);
+	return idle_time;
 }
 
 struct cpuidle_driver acpi_idle_driver = {