Skip to contentSkip to conversation

time: Fix incorrect sleeptime injection when suspend fails

PATCH Superseded Mukesh Ojha 3 participants 10 messages Jul 6, 2018 – Jul 16, 2018 Timekeeping, clocksource core, NTP, alarmtimer

v3 of 5 Superseded Latest is v5 →

lore
Share & tools
lore
#0 lore raw

PATCH v3 1/1 time: Fix incorrect sleeptime injection when suspend fails

Currently, there exists a corner case assuming when there is only one clocksource e.g RTC, and system failed to go to suspend mode. While resume rtc_resume() injects the sleeptime as timekeeping_rtc_skipresume() returned 'false' (default value of sleeptime_injected) due to which we can see mismatch in timestamps.

This issue can also come in a system where more than one clocksource are present and very first suspend fails.

Fix this by handling sleeptime_injected flag properly.

Success case:
------------

                                        {sleeptime_injected=false}

rtc_suspend() => timekeeping_suspend() => timekeeping_resume() =>

(sleeptime injected)
rtc_resume()

Failure case:
------------

         {failure in sleep path} {sleeptime_injected=false}

rtc_suspend() => rtc_resume()

sleeptime injected again which was not required as the suspend failed)

---
Changes in v3:
* Updated commit subject and description.
* Updated the patch as per the fix given by Thomas Gleixner.

Changes in v2:
* Updated the commit text.
* Removed extra variable and used the earlier static variable 'sleeptime_injected'.

 kernel/time/timekeeping.c | 21 ++++++++++++++++++---
 1 file changed, 18 insertions(+), 3 deletions(-)
kernel/time/timekeeping.c +18 -3
index 4786df9..32ae9ae 100644
@@ -1510,8 +1510,20 @@ void __weak read_boot_clock64(struct timespec64 *ts)
 	ts->tv_nsec = 0;
 }
 
-/* Flag for if timekeeping_resume() has injected sleeptime */
-static bool sleeptime_injected;
+/*
+ * Flag reflecting whether timekeeping_resume() has injected sleeptime.
+ *
+ * The flag starts of true and is only cleared when a suspend reaches
+ * timekeeping_suspend(), timekeeping_resume() sets it when the timekeeper
+ * clocksource is not stopping across suspend and has been used to update
+ * sleep time. If the timekeeper clocksource has stopped then the flag
+ * stays false and is used by the RTC resume code to decide whether sleep
+ * time must be injected and if so the flag gets set then.
+ *
+ * If a suspend fails before reaching timekeeping_resume() then the flag
+ * stays true and prevents erroneous sleeptime injection.
+ */
+static bool sleeptime_injected = true;
 
 /* Flag for if there is a persistent clock on this platform */
 static bool persistent_clock_exists;
@@ -1646,6 +1658,8 @@ void timekeeping_inject_sleeptime64(struct timespec64 *delta)
 	raw_spin_lock_irqsave(&timekeeper_lock, flags);
 	write_seqcount_begin(&tk_core.seq);
 
+	sleeptime_injected = true;
+
 	timekeeping_forward_now(tk);
 
 	__timekeeping_inject_sleeptime(tk, delta);
@@ -1671,7 +1685,6 @@ void timekeeping_resume(void)
 	struct timespec64 ts_new, ts_delta;
 	u64 cycle_now;
 
-	sleeptime_injected = false;
 	read_persistent_clock64(&ts_new);
 
 	clockevents_resume();
@@ -1743,6 +1756,8 @@ int timekeeping_suspend(void)
 	if (timekeeping_suspend_time.tv_sec || timekeeping_suspend_time.tv_nsec)
 		persistent_clock_exists = true;
 
+	sleeptime_injected = false;
+
 	raw_spin_lock_irqsave(&timekeeper_lock, flags);
 	write_seqcount_begin(&tk_core.seq);
 	timekeeping_forward_now(tk);
Signature · 2 lines
Qualcomm India Private Limited, on behalf of Qualcomm Innovation Center,
Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project
#1 lore raw
Quoted 56 lines · Mukesh Ojha

Currently, there exists a corner case assuming when there is only one clocksource e.g RTC, and system failed to go to suspend mode. While resume rtc_resume() injects the sleeptime as timekeeping_rtc_skipresume() returned 'false' (default value of sleeptime_injected) due to which we can see mismatch in timestamps.

This issue can also come in a system where more than one clocksource are present and very first suspend fails.

Fix this by handling sleeptime_injected flag properly.

Success case:
------------

                                        {sleeptime_injected=false}

rtc_suspend() => timekeeping_suspend() => timekeeping_resume() =>

(sleeptime injected)
rtc_resume()

Failure case:
------------

         {failure in sleep path} {sleeptime_injected=false}

rtc_suspend() => rtc_resume()

sleeptime injected again which was not required as the suspend failed)

---
Changes in v3:
* Updated commit subject and description.
* Updated the patch as per the fix given by Thomas Gleixner.

Changes in v2:
* Updated the commit text.
* Removed extra variable and used the earlier static variable 'sleeptime_injected'.

 kernel/time/timekeeping.c | 21 ++++++++++++++++++---
 1 file changed, 18 insertions(+), 3 deletions(-)
kernel/time/timekeeping.c +4 -2
index 4786df9..32ae9ae 100644
@@ -1510,8 +1510,20 @@ void __weak read_boot_clock64(struct timespec64 *ts)
        ts->tv_nsec = 0;
 }
 
-/* Flag for if timekeeping_resume() has injected sleeptime */
-static bool sleeptime_injected;
+/*
+ * Flag reflecting whether timekeeping_resume() has injected sleeptime.
+ *
+ * The flag starts of true and is only cleared when a suspend reaches

kernel/time/timekeeping.c void __weak read_boot_clock64(struct timespec64 *ts) · line 1526

Quoted 10 lines
kernel/time/timekeeping.c +10 -0
+ * timekeeping_suspend(), timekeeping_resume() sets it when the timekeeper
+ * clocksource is not stopping across suspend and has been used to update
+ * sleep time. If the timekeeper clocksource has stopped then the flag
+ * stays false and is used by the RTC resume code to decide whether sleep
+ * time must be injected and if so the flag gets set then.
+ *
+ * If a suspend fails before reaching timekeeping_resume() then the flag
+ * stays true and prevents erroneous sleeptime injection.
+ */
+static bool sleeptime_injected = true;

I worry this upside-down logic is too subtle to be easily reasoned about, and will just lead to future mistakes.

Can we instead call this "suspend_timing_needed" and only set it to true when we don't inject any sleep time on resume?

I think that will help make things a bit more clear, no?

thanks
-john

#2 lore raw

Hi John,

Thanks for your response
Please find my comments inline.

Quoted 70 lines · John Stultz
Quoted 56 lines · Mukesh Ojha

Currently, there exists a corner case assuming when there is only one clocksource e.g RTC, and system failed to go to suspend mode. While resume rtc_resume() injects the sleeptime as timekeeping_rtc_skipresume() returned 'false' (default value of sleeptime_injected) due to which we can see mismatch in timestamps.

This issue can also come in a system where more than one clocksource are present and very first suspend fails.

Fix this by handling sleeptime_injected flag properly.

Success case:
------------

                                         {sleeptime_injected=false}

rtc_suspend() => timekeeping_suspend() => timekeeping_resume() =>

(sleeptime injected)
rtc_resume()

Failure case:
------------

          {failure in sleep path} {sleeptime_injected=false}

rtc_suspend() => rtc_resume()

sleeptime injected again which was not required as the suspend failed)

---
Changes in v3:
* Updated commit subject and description.
* Updated the patch as per the fix given by Thomas Gleixner.

Changes in v2:
* Updated the commit text.
* Removed extra variable and used the earlier static variable 'sleeptime_injected'.

  kernel/time/timekeeping.c | 21 ++++++++++++++++++---
  1 file changed, 18 insertions(+), 3 deletions(-)
kernel/time/timekeeping.c +4 -2
index 4786df9..32ae9ae 100644
@@ -1510,8 +1510,20 @@ void __weak read_boot_clock64(struct timespec64 *ts)
         ts->tv_nsec = 0;
  }
 
-/* Flag for if timekeeping_resume() has injected sleeptime */
-static bool sleeptime_injected;
+/*
+ * Flag reflecting whether timekeeping_resume() has injected sleeptime.
+ *
+ * The flag starts of true and is only cleared when a suspend reaches

kernel/time/timekeeping.c void __weak read_boot_clock64(struct timespec64 *ts) · line 1526

Quoted 10 lines
kernel/time/timekeeping.c +10 -0
+ * timekeeping_suspend(), timekeeping_resume() sets it when the timekeeper
+ * clocksource is not stopping across suspend and has been used to update
+ * sleep time. If the timekeeper clocksource has stopped then the flag
+ * stays false and is used by the RTC resume code to decide whether sleep
+ * time must be injected and if so the flag gets set then.
+ *
+ * If a suspend fails before reaching timekeeping_resume() then the flag
+ * stays true and prevents erroneous sleeptime injection.
+ */
+static bool sleeptime_injected = true;

I worry this upside-down logic is too subtle to be easily reasoned about, and will just lead to future mistakes.

Quoted 2 lines

Can we instead call this "suspend_timing_needed" and only set it to true when we don't inject any sleep time on resume?

I did not get your point "only set it to true when we don't inject any sleep time on resume? " How do we know  this ?
This question itself depends on the "sleeptime_injected" if it is true means no need to inject else need to inject.

Also, we need to make this variable back and forth true, false; suspends path ensures it to make it false.

Just to add here there are already two path where sleeptime_injected set to true one from NON-stop clocksource and other from persistant clock and the RTC one was missing, so we are adding with this patch.

Cheers,
-Mukesh

#3 lore raw
Quoted 88 lines · Mukesh Ojha

Hi John,

Thanks for your response
Please find my comments inline.

Quoted 77 lines · John Stultz
Quoted 63 lines · Mukesh Ojha

Currently, there exists a corner case assuming when there is only one clocksource e.g RTC, and system failed to go to suspend mode. While resume rtc_resume() injects the sleeptime as timekeeping_rtc_skipresume() returned 'false' (default value of sleeptime_injected) due to which we can see mismatch in timestamps.

This issue can also come in a system where more than one clocksource are present and very first suspend fails.

Fix this by handling sleeptime_injected flag properly.

Success case:
------------

                                         {sleeptime_injected=false}

rtc_suspend() => timekeeping_suspend() => timekeeping_resume() =>

(sleeptime injected)
rtc_resume()

Failure case:
------------

          {failure in sleep path} {sleeptime_injected=false}

rtc_suspend() => rtc_resume()

sleeptime injected again which was not required as the suspend failed)

---
Changes in v3:
* Updated commit subject and description.
* Updated the patch as per the fix given by Thomas Gleixner.

Changes in v2:
* Updated the commit text.
* Removed extra variable and used the earlier static variable 'sleeptime_injected'.

  kernel/time/timekeeping.c | 21 ++++++++++++++++++---
  1 file changed, 18 insertions(+), 3 deletions(-)
kernel/time/timekeeping.c +5 -2
index 4786df9..32ae9ae 100644
@@ -1510,8 +1510,20 @@ void __weak read_boot_clock64(struct timespec64
 *ts)
         ts->tv_nsec = 0;
  }
 
-/* Flag for if timekeeping_resume() has injected sleeptime */
-static bool sleeptime_injected;
+/*
+ * Flag reflecting whether timekeeping_resume() has injected sleeptime.
+ *
+ * The flag starts of true and is only cleared when a suspend reaches
+ * timekeeping_suspend(), timekeeping_resume() sets it when the

timekeeper
+ * clocksource is not stopping across suspend and has been used to update
+ * sleep time. If the timekeeper clocksource has stopped then the flag

Quoted 8 lines

+ * stays false and is used by the RTC resume code to decide whether sleep
+ * time must be injected and if so the flag gets set then.
+ *
+ * If a suspend fails before reaching timekeeping_resume() then the flag
+ * stays true and prevents erroneous sleeptime injection.
+ */
+static bool sleeptime_injected = true;

I worry this upside-down logic is too subtle to be easily reasoned about, and will just lead to future mistakes.

Quoted 2 lines

Can we instead call this "suspend_timing_needed" and only set it to true when we don't inject any sleep time on resume?

Quoted 8 lines

I did not get your point "only set it to true when we don't inject any sleep time on resume? "
How do we know this ?
This question itself depends on the "sleeptime_injected" if it is true means no need to inject else need to inject.

Also, we need to make this variable back and forth true, false; suspends path ensures it to make it false.

So yea, I'm not saying logically the code is really any different, this is more of a naming nit. So instead of having a variable that is always on that we occasionally turn off, lets invert the naming and have it be a flag that we occasionally turn on.

Just the name sleeptime_injected is read a statement, which if we say is defaults to true, becomes confusing to think about when the timekeeping_suspend/resume code hasn't yet run (which is the case where your error cropped up) - and no sleeptime has actually been injected.

So instead if we call it suspend_timing_needed and only set it on in timekeeping_resume() after the timekeeping code has not injected any sleep-time, then I think the code will make more sense to read. (And yes, we still need to set suspend_timing_needed false on timekeeping_suspend and in the inject_sleeptime call path - the logic doesn't change, just the naming and boolean state).

thanks
-john

#4 lore raw
Quoted 91 lines · John Stultz
Quoted 90 lines · Mukesh Ojha

Hi John,

Thanks for your response
Please find my comments inline.

Quoted 74 lines · John Stultz
Quoted 62 lines · Mukesh Ojha

Currently, there exists a corner case assuming when there is only one clocksource e.g RTC, and system failed to go to suspend mode. While resume rtc_resume() injects the sleeptime as timekeeping_rtc_skipresume() returned 'false' (default value of sleeptime_injected) due to which we can see mismatch in timestamps.

This issue can also come in a system where more than one clocksource are present and very first suspend fails.

Fix this by handling sleeptime_injected flag properly.

Success case:
------------

                                          {sleeptime_injected=false}

rtc_suspend() => timekeeping_suspend() => timekeeping_resume() =>

(sleeptime injected)
rtc_resume()

Failure case:
------------

           {failure in sleep path} {sleeptime_injected=false}

rtc_suspend() => rtc_resume()

sleeptime injected again which was not required as the suspend failed)

---
Changes in v3:
* Updated commit subject and description.
* Updated the patch as per the fix given by Thomas Gleixner.

Changes in v2:
* Updated the commit text.
* Removed extra variable and used the earlier static variable 'sleeptime_injected'.

   kernel/time/timekeeping.c | 21 ++++++++++++++++++---
   1 file changed, 18 insertions(+), 3 deletions(-)
kernel/time/timekeeping.c +5 -2
index 4786df9..32ae9ae 100644
@@ -1510,8 +1510,20 @@ void __weak read_boot_clock64(struct timespec64
 *ts)
          ts->tv_nsec = 0;
   }
 
-/* Flag for if timekeeping_resume() has injected sleeptime */
-static bool sleeptime_injected;
+/*
+ * Flag reflecting whether timekeeping_resume() has injected sleeptime.
+ *
+ * The flag starts of true and is only cleared when a suspend reaches
+ * timekeeping_suspend(), timekeeping_resume() sets it when the

timekeeper
+ * clocksource is not stopping across suspend and has been used to update
+ * sleep time. If the timekeeper clocksource has stopped then the flag

Quoted 8 lines

+ * stays false and is used by the RTC resume code to decide whether sleep
+ * time must be injected and if so the flag gets set then.
+ *
+ * If a suspend fails before reaching timekeeping_resume() then the flag
+ * stays true and prevents erroneous sleeptime injection.
+ */
+static bool sleeptime_injected = true;

I worry this upside-down logic is too subtle to be easily reasoned about, and will just lead to future mistakes.

Quoted 2 lines

Can we instead call this "suspend_timing_needed" and only set it to true when we don't inject any sleep time on resume?

I did not get your point "only set it to true when we don't inject any sleep time on resume? "
How do we know this ?
This question itself depends on the "sleeptime_injected" if it is true means no need to inject else need to inject.

Quoted 6 lines
Quoted 2 lines

Also, we need to make this variable back and forth true, false; suspends path ensures it to make it false.

So yea, I'm not saying logically the code is really any different, this is more of a naming nit. So instead of having a variable that is always on that we occasionally turn off, lets invert the naming and have it be a flag that we occasionally turn on.

I understand your concern about the name of the variable will be misleading. But the changing Boolean state would not solve the actual issue.

If i understand you correctly you meant below code

kernel/time/timekeeping.c +0 -0
index 32ae9ae..becc5bd 100644
@@ -1523,7 +1523,7 @@ void __weak read_boot_clock64(struct timespec64 *ts)

  * If a suspend fails before reaching timekeeping_resume() then the flag
  * stays true and prevents erroneous sleeptime injection.
  */
-static bool sleeptime_injected = true;
+static bool suspend_timing_needed;

 /* Flag for if there is a persistent clock on this platform */
 static bool persistent_clock_exists;
@@ -1658,7 +1658,7 @@ void timekeeping_inject_sleeptime64(struct timespec64 *delta) raw_spin_lock_irqsave(&timekeeper_lock, flags); write_seqcount_begin(&tk_core.seq);

-       sleeptime_injected = true;
+       suspend_timing_needed = false;

        timekeeping_forward_now(tk);

@@ -1714,10 +1714,10 @@ void timekeeping_resume(void) tk->tkr_mono.mask); nsec = mul_u64_u32_shr(cyc_delta, clock->mult, clock->shift); ts_delta = ns_to_timespec64(nsec);
-               sleeptime_injected = true;
+               suspend_timing_needed = true;
        } else if (timespec64_compare(&ts_new, &timekeeping_suspend_time) > 0) { ts_delta = timespec64_sub(ts_new, timekeeping_suspend_time); -               sleeptime_injected = true;
+               suspend_timing_needed = true;
        }

        if (sleeptime_injected)
@@ -1756,7 +1756,7 @@ int timekeeping_suspend(void)
        if (timekeeping_suspend_time.tv_sec || timekeeping_suspend_time.tv_nsec) persistent_clock_exists = true;

-       sleeptime_injected = false;
+       suspend_timing_needed = false;

        raw_spin_lock_irqsave(&timekeeper_lock, flags);

This has a problem..

Quoted 6 lines

Just the name sleeptime_injected is read a statement, which if we say is defaults to true, becomes confusing to think about when the timekeeping_suspend/resume code hasn't yet run (which is the case where your error cropped up) - and no sleeptime has actually been injected.

Yes, when very first suspend fails and timekeeping_suspend/resume did not run ; That is the exact issue. So, exact solution is no need to inject any sleeptime here.

 If we set the default value to false then we will see timekeeping_resume will inject sleeptime by below code which was not intended.

static int rtc_resume(struct device *dev)
{
        struct rtc_device       *rtc = to_rtc_device(dev); struct rtc_time         tm;
        struct timespec64       new_system, new_rtc; struct timespec64       sleep_time;
        int err;

        if (timekeeping_rtc_skipresume())  // it will return the value false as sleep failed and timekeeping_resume() did not get called. return 0;

  <sleeptime injection happens here>
....
..

Quoted 7 lines

So instead if we call it suspend_timing_needed and only set it on in timekeeping_resume() after the timekeeping code has not injected any sleep-time, then I think the code will make more sense to read. (And yes, we still need to set suspend_timing_needed false on timekeeping_suspend and in the inject_sleeptime call path - the logic doesn't change, just the naming and boolean state).

Thanks for your time and patience.

-Mukesh

Quoted 2 lines

thanks
-john

#5 lore raw
Quoted 58 lines · Mukesh Ojha
Quoted 17 lines · John Stultz

On Fri, Jul 13, 2018 at 12:13 AM, Mukesh Ojha <[email protected]>

Quoted 16 lines · John Stultz
Quoted 5 lines

I worry this upside-down logic is too subtle to be easily reasoned about, and will just lead to future mistakes.

Can we instead call this "suspend_timing_needed" and only set it to true when we don't inject any sleep time on resume?

I did not get your point "only set it to true when we don't inject any sleep
time on resume? "
How do we know this ?
This question itself depends on the "sleeptime_injected" if it is true means
no need to inject else need to inject.

Quoted 7 lines
Quoted 2 lines

Also, we need to make this variable back and forth true, false; suspends path ensures it to make it false.

So yea, I'm not saying logically the code is really any different, this is more of a naming nit. So instead of having a variable that is always on that we occasionally turn off, lets invert the naming and have it be a flag that we occasionally turn on.

I understand your concern about the name of the variable will be misleading. But the changing Boolean state would not solve the actual issue.

If i understand you correctly you meant below code

kernel/time/timekeeping.c +2 -2
index 32ae9ae..becc5bd 100644
@@ -1523,7 +1523,7 @@ void __weak read_boot_clock64(struct timespec64 *ts)
  * If a suspend fails before reaching timekeeping_resume() then the flag
  * stays true and prevents erroneous sleeptime injection.
  */
-static bool sleeptime_injected = true;
+static bool suspend_timing_needed;
 
 /* Flag for if there is a persistent clock on this platform */
 static bool persistent_clock_exists;
@@ -1658,7 +1658,7 @@ void timekeeping_inject_sleeptime64(struct timespec64
 *delta)
        raw_spin_lock_irqsave(&timekeeper_lock, flags);
        write_seqcount_begin(&tk_core.seq);
 
-       sleeptime_injected = true;
+       suspend_timing_needed = false;
 
        timekeeping_forward_now(tk);
@@ -1714,10 +1714,10 @@ void timekeeping_resume(void)
                                              tk->tkr_mono.mask);
                nsec = mul_u64_u32_shr(cyc_delta, clock->mult,

kernel/time/timekeeping.c void timekeeping_resume(void) · line 1723

Quoted 10 lines
kernel/time/timekeeping.c +2 -2
 clock->shift);
                ts_delta = ns_to_timespec64(nsec);
-               sleeptime_injected = true;
+               suspend_timing_needed = true;
        } else if (timespec64_compare(&ts_new, &timekeeping_suspend_time) >
 0) {
                ts_delta = timespec64_sub(ts_new, timekeeping_suspend_time);
-               sleeptime_injected = true;
+               suspend_timing_needed = true;
        }

No no... This part is wrong. We only set suspend_timing_needed if we *didn't* calculate the suspend time in timekeeping_resume.

You have to invert all the boolean logic for it to be equivalent.

Quoted 42 lines

if (sleeptime_injected)

kernel/time/timekeeping.c +1 -1
@@ -1756,7 +1756,7 @@ int timekeeping_suspend(void)
        if (timekeeping_suspend_time.tv_sec ||
 timekeeping_suspend_time.tv_nsec)
                persistent_clock_exists = true;
 
-       sleeptime_injected = false;
+       suspend_timing_needed = false;
 
        raw_spin_lock_irqsave(&timekeeper_lock, flags);

This has a problem..

Quoted 6 lines

Just the name sleeptime_injected is read a statement, which if we say is defaults to true, becomes confusing to think about when the timekeeping_suspend/resume code hasn't yet run (which is the case where your error cropped up) - and no sleeptime has actually been injected.

Yes, when very first suspend fails and timekeeping_suspend/resume did not run ; That is the exact issue.
So, exact solution is no need to inject any sleeptime here.

If we set the default value to false then we will see timekeeping_resume
will inject sleeptime by below code which was not intended.

static int rtc_resume(struct device *dev)

{
        struct rtc_device       *rtc = to_rtc_device(dev);
        struct rtc_time         tm;
        struct timespec64       new_system, new_rtc;
        struct timespec64       sleep_time;
        int err;

        if (timekeeping_rtc_skipresume())  // it will return the value false
as sleep failed and timekeeping_resume() did not get called.
                return 0;
Quoted 1 line

<sleeptime injection happens here>

So, I think with the logic bug above it will work out properly, but let me know if I'm still missing something.

thanks
-john

#6 lore raw
Quoted 75 lines · John Stultz
Quoted 58 lines · Mukesh Ojha
Quoted 17 lines · John Stultz

On Fri, Jul 13, 2018 at 12:13 AM, Mukesh Ojha <[email protected]>

Quoted 16 lines · John Stultz
Quoted 5 lines

I worry this upside-down logic is too subtle to be easily reasoned about, and will just lead to future mistakes.

Can we instead call this "suspend_timing_needed" and only set it to true when we don't inject any sleep time on resume?

I did not get your point "only set it to true when we don't inject any sleep
time on resume? "
How do we know this ?
This question itself depends on the "sleeptime_injected" if it is true means
no need to inject else need to inject.

Quoted 7 lines
Quoted 2 lines

Also, we need to make this variable back and forth true, false; suspends path ensures it to make it false.

So yea, I'm not saying logically the code is really any different, this is more of a naming nit. So instead of having a variable that is always on that we occasionally turn off, lets invert the naming and have it be a flag that we occasionally turn on.

I understand your concern about the name of the variable will be misleading. But the changing Boolean state would not solve the actual issue.

If i understand you correctly you meant below code

kernel/time/timekeeping.c +2 -2
index 32ae9ae..becc5bd 100644
@@ -1523,7 +1523,7 @@ void __weak read_boot_clock64(struct timespec64 *ts)
  * If a suspend fails before reaching timekeeping_resume() then the flag
  * stays true and prevents erroneous sleeptime injection.
  */
-static bool sleeptime_injected = true;
+static bool suspend_timing_needed;
 
 /* Flag for if there is a persistent clock on this platform */
 static bool persistent_clock_exists;
@@ -1658,7 +1658,7 @@ void timekeeping_inject_sleeptime64(struct timespec64
 *delta)
        raw_spin_lock_irqsave(&timekeeper_lock, flags);
        write_seqcount_begin(&tk_core.seq);
 
-       sleeptime_injected = true;
+       suspend_timing_needed = false;
 
        timekeeping_forward_now(tk);
@@ -1714,10 +1714,10 @@ void timekeeping_resume(void)
                                              tk->tkr_mono.mask);
                nsec = mul_u64_u32_shr(cyc_delta, clock->mult,

kernel/time/timekeeping.c void timekeeping_resume(void) · line 1723

Quoted 10 lines
kernel/time/timekeeping.c +2 -2
 clock->shift);
                ts_delta = ns_to_timespec64(nsec);
-               sleeptime_injected = true;
+               suspend_timing_needed = true;
        } else if (timespec64_compare(&ts_new, &timekeeping_suspend_time) >
 0) {
                ts_delta = timespec64_sub(ts_new, timekeeping_suspend_time);
-               sleeptime_injected = true;
+               suspend_timing_needed = true;
        }

No no... This part is wrong. We only set suspend_timing_needed if we *didn't* calculate the suspend time in timekeeping_resume.

You have to invert all the boolean logic for it to be equivalent.

...

Quoted 5 lines
Quoted 1 line

<sleeptime injection happens here>

So, I think with the logic bug above it will work out properly, but let me know if I'm still missing something.

Sorry, I meant "with the logic bug above fixed it will work out".

thanks
-john

#7 lore raw
Quoted 70 lines · John Stultz
Quoted 69 lines · John Stultz
Quoted 55 lines · Mukesh Ojha
Quoted 16 lines · John Stultz

On Fri, Jul 13, 2018 at 12:13 AM, Mukesh Ojha <[email protected]>

Quoted 15 lines · John Stultz
Quoted 5 lines

I worry this upside-down logic is too subtle to be easily reasoned about, and will just lead to future mistakes.

Can we instead call this "suspend_timing_needed" and only set it to true when we don't inject any sleep time on resume?

I did not get your point "only set it to true when we don't inject any sleep
time on resume? "
How do we know this ?
This question itself depends on the "sleeptime_injected" if it is true means
no need to inject else need to inject.

Quoted 6 lines
Quoted 2 lines

Also, we need to make this variable back and forth true, false; suspends path ensures it to make it false.

So yea, I'm not saying logically the code is really any different, this is more of a naming nit. So instead of having a variable that is always on that we occasionally turn off, lets invert the naming and have it be a flag that we occasionally turn on.

I understand your concern about the name of the variable will be misleading. But the changing Boolean state would not solve the actual issue.

If i understand you correctly you meant below code

kernel/time/timekeeping.c +2 -2
index 32ae9ae..becc5bd 100644
@@ -1523,7 +1523,7 @@ void __weak read_boot_clock64(struct timespec64 *ts)
   * If a suspend fails before reaching timekeeping_resume() then the flag
   * stays true and prevents erroneous sleeptime injection.
   */
-static bool sleeptime_injected = true;
+static bool suspend_timing_needed;
 
  /* Flag for if there is a persistent clock on this platform */
  static bool persistent_clock_exists;
@@ -1658,7 +1658,7 @@ void timekeeping_inject_sleeptime64(struct timespec64
 *delta)
         raw_spin_lock_irqsave(&timekeeper_lock, flags);
         write_seqcount_begin(&tk_core.seq);
 
-       sleeptime_injected = true;
+       suspend_timing_needed = false;
 
         timekeeping_forward_now(tk);
@@ -1714,10 +1714,10 @@ void timekeeping_resume(void)
                                               tk->tkr_mono.mask);
                 nsec = mul_u64_u32_shr(cyc_delta, clock->mult,

kernel/time/timekeeping.c void timekeeping_resume(void) · line 1723

Quoted 10 lines
kernel/time/timekeeping.c +2 -2
 clock->shift);
                 ts_delta = ns_to_timespec64(nsec);
-               sleeptime_injected = true;
+               suspend_timing_needed = true;
         } else if (timespec64_compare(&ts_new, &timekeeping_suspend_time) >
 0) {
                 ts_delta = timespec64_sub(ts_new, timekeeping_suspend_time);
-               sleeptime_injected = true;
+               suspend_timing_needed = true;
         }

No no... This part is wrong. We only set suspend_timing_needed if we *didn't* calculate the suspend time in timekeeping_resume.

Quoted 7 lines
Quoted 2 lines

You have to invert all the boolean logic for it to be equivalent.

...

Quoted 4 lines
Quoted 1 line

<sleeptime injection happens here>

So, I think with the logic bug above it will work out properly, but let me know if I'm still missing something.

Please give it thought to a case where very first suspend fails with your logic. If i am not able to get your thought, please write a patch.

-Mukesh

Quoted 4 lines

Sorry, I meant "with the logic bug above fixed it will work out".

thanks
-john

#8 lore raw
Quoted 99 lines · Mukesh Ojha
Quoted 96 lines · John Stultz
Quoted 88 lines · John Stultz
Quoted 76 lines · Mukesh Ojha
Quoted 20 lines · John Stultz

On Fri, Jul 13, 2018 at 12:13 AM, Mukesh Ojha <[email protected]>

Quoted 18 lines · John Stultz
Quoted 6 lines

I worry this upside-down logic is too subtle to be easily reasoned about, and will just lead to future mistakes.

Can we instead call this "suspend_timing_needed" and only set it to true when we don't inject any sleep time on resume?

I did not get your point "only set it to true when we don't inject any sleep
time on resume? "
How do we know this ?
This question itself depends on the "sleeptime_injected" if it is true means
no need to inject else need to inject.

Quoted 8 lines
Quoted 3 lines

Also, we need to make this variable back and forth true, false; suspends
path ensures it to make it false.

So yea, I'm not saying logically the code is really any different, this is more of a naming nit. So instead of having a variable that is always on that we occasionally turn off, lets invert the naming and have it be a flag that we occasionally turn on.

I understand your concern about the name of the variable will be misleading.
But the changing Boolean state would not solve the actual issue.

If i understand you correctly you meant below code

kernel/time/timekeeping.c +0 -0
index 32ae9ae..becc5bd 100644
@@ -1523,7 +1523,7 @@ void __weak read_boot_clock64(struct timespec64
 *ts)
   * If a suspend fails before reaching timekeeping_resume() then the

flag
* stays true and prevents erroneous sleeptime injection. */

kernel/time/timekeeping.c +1 -1
-static bool sleeptime_injected = true;
+static bool suspend_timing_needed;
 
  /* Flag for if there is a persistent clock on this platform */
  static bool persistent_clock_exists;
@@ -1658,7 +1658,7 @@ void timekeeping_inject_sleeptime64(struct

timespec64
*delta)

         raw_spin_lock_irqsave(&timekeeper_lock, flags);
         write_seqcount_begin(&tk_core.seq);
kernel/time/timekeeping.c +2 -2
-       sleeptime_injected = true;
+       suspend_timing_needed = false;
 
         timekeeping_forward_now(tk);
@@ -1714,10 +1714,10 @@ void timekeeping_resume(void)
                                               tk->tkr_mono.mask);
                 nsec = mul_u64_u32_shr(cyc_delta, clock->mult,
 clock->shift);
                 ts_delta = ns_to_timespec64(nsec);
-               sleeptime_injected = true;
+               suspend_timing_needed = true;
         } else if (timespec64_compare(&ts_new,

&timekeeping_suspend_time) >
0) {
ts_delta = timespec64_sub(ts_new,
timekeeping_suspend_time);

kernel/time/timekeeping.c

Quoted 3 lines
kernel/time/timekeeping.c +1 -1
-               sleeptime_injected = true;
+               suspend_timing_needed = true;
         }

No no... This part is wrong. We only set suspend_timing_needed if we *didn't* calculate the suspend time in timekeeping_resume.

You have to invert all the boolean logic for it to be equivalent.

...

Quoted 4 lines
Quoted 2 lines

<sleeptime injection happens here>

Quoted 6 lines
Quoted 2 lines
Quoted 2 lines

So, I think with the logic bug above it will work out properly, but let me know if I'm still missing something.

Please give it thought to a case where very first suspend fails with your logic.

I believe I did. If the first suspend fails, we never reach timekeeping_resume, so we never set "suspend_time_needed = true", so then timekeeping_rtc_skipresume can then return true, and we don't inject the time in the RTC code.

Quoted 1 line

If i am not able to get your thought, please write a patch.

I probably will, but I'd like to encourage you to follow through on this one. You reported the issue, and submitted a few patches, so I think it would be good for you to also get the patch credit here. I don't believe its a complex request I've made, and I think you can figure it out.

So, please, take one more real stab at this and I'll rework it if it seems necessary.

thanks
-john

#9 lore raw
In reply to Mukesh Ojha
Quoted 7 lines · Mukesh Ojha
Quoted 2 lines · John Stultz
Quoted 2 lines

So, I think with the logic bug above it will work out properly, but let me know if I'm still missing something.

Please give it thought to a case where very first suspend fails with your logic.
If i am not able to get your thought, please write a patch.

John wants you to invert the logic. i.e.

     true -> false
     false -> true
     if (var) -> if (!var)
     if (!var) -> if (var)

It's not that hard, right?

Thanks,

tglx