tick/sched: Refactor idle cputime accounting

Offline handling happens from within the inner idle loop, after the beginning of dyntick cputime accounting, nohz idle load balancing and TIF_NEED_RESCHED polling.

This is not necessary and even buggy because:

* There is no dyntick handling to do. And calling tick_nohz_idle_enter() messes up with the struct tick_sched reset that was performed on tick_sched_timer_dying().

* There is no nohz idle balancing to do.

* Polling on TIF_RESCHED is irrelevant at this stage, there are no more tasks allowed to run.

* No need to check if need_resched() before offline handling since stop_machine is done and all per-cpu kthread should be done with their job.

Therefore move the offline handling at the beginning of the idle loop. This will also ease the idle cputime unification later by not elapsing idle time while offline through the call to:

	tick_nohz_idle_enter() -> tick_nohz_start_idle()

Signed-off-by Frederic Weisbecker <[email protected]>

---
  kernel/sched/idle.c | 13 ++++++++-----
  1 file changed, 8 insertions(+), 5 deletions(-)

kernel/sched/idle.c +8 -5

index c174afe1dd17..51764cbec6f3 100644
@@ -260,6 +260,14 @@ static void do_idle(void)
  {
  	int cpu = smp_processor_id();
 
+	if (cpu_is_offline(cpu)) {
+		local_irq_disable();
+		/* All per-CPU kernel threads should be done by now. */
+		WARN_ON_ONCE(need_resched());
+		cpuhp_report_idle_dead();
+		arch_cpu_idle_dead();
+	}
+
  	/*
  	 * Check if we need to update blocked load
  	 */

@@ -311,11 +319,6 @@ static void do_idle(void)
  		 */
  		local_irq_disable();
 
-		if (cpu_is_offline(cpu)) {
-			cpuhp_report_idle_dead();
-			arch_cpu_idle_dead();
-		}
-
  		arch_cpu_idle_enter();
  		rcu_nocb_flush_deferred_wakeup();
 

The first parameter to kcpustat_field() is a pointer to the cpu kcpustat to be fetched from. This parameter is error prone because a copy to a kcpustat could be passed by accident instead of the original one. Also the kcpustat structure can already be retrieved with the help of the mandatory CPU argument.

Remove the needless paramater.

Currently the tick subsystem stores the idle cputime accounting in private fields, allowing cohabitation with architecture idle vtime accounting. The former is fetched on online CPUs, the latter on offline CPUs.

For consolidation purpose, architecture vtime accounting will continue to account the cputime but will make a break when the idle tick is stopped. The dyntick cputime accounting will then be relayed by the tick subsystem so that the idle cputime is still seen advancing coherently even when the tick isn't there to flush the idle vtime.

Prepare for that and introduce three new APIs which will be used in subsequent patches:

_ vtime_dynticks_start() is deemed to be called when idle enters in
dyntick mode. The idle cputime that elapsed so far is accumulated.

- vtime_dynticks_stop() is deemed to be called when idle exits from dyntick mode. The vtime entry clocks are fast-forward to current time so that idle accounting restarts elapsing from now.

- vtime_reset() is deemed to be called from dynticks idle IRQ entry to fast-forward the clock to current time so that the IRQ time is still accounted by vtime while nohz cputime is paused.

Also accumulated vtime won't be flushed from dyntick-idle ticks to avoid accounting twice the idle cputime, along with nohz accounting.

Signed-off-by Frederic Weisbecker <[email protected]>

---
  arch/powerpc/kernel/time.c | 41 ++++++++++++++++++++++++++++++++++++++
  include/linux/vtime.h      |  6 ++++++
  2 files changed, 47 insertions(+)

arch/powerpc/kernel/time.c +3 -0

index 4bbeb8644d3d..18506740f4a4 100644
@@ -376,6 +376,47 @@ void vtime_task_switch(struct task_struct *prev)
  		acct->starttime = acct0->starttime;
  	}
  }
+
+#ifdef CONFIG_NO_HZ_COMMON
+/**

Quoted 21 lines

Currently the tick subsystem stores the idle cputime accounting in private fields, allowing cohabitation with architecture idle vtime accounting. The former is fetched on online CPUs, the latter on offline CPUs.

For consolidation purpose, architecture vtime accounting will continue to account the cputime but will make a break when the idle tick is stopped. The dyntick cputime accounting will then be relayed by the tick subsystem so that the idle cputime is still seen advancing coherently even when the tick isn't there to flush the idle vtime.

Prepare for that and introduce three new APIs which will be used in subsequent patches:

_ vtime_dynticks_start() is deemed to be called when idle enters in dyntick mode. The idle cputime that elapsed so far is accumulated.

- vtime_dynticks_stop() is deemed to be called when idle exits from dyntick mode. The vtime entry clocks are fast-forward to current time so that idle accounting restarts elapsing from now.

Quoted 8 lines

- vtime_reset() is deemed to be called from dynticks idle IRQ entry to fast-forward the clock to current time so that the IRQ time is still accounted by vtime while nohz cputime is paused.

Also accumulated vtime won't be flushed from dyntick-idle ticks to avoid accounting twice the idle cputime, along with nohz accounting.

Signed-off-by Frederic Weisbecker <[email protected]>

Reviewed-by Shrikanth Hegde <[email protected]>

Quoted 23 lines

---
  arch/powerpc/kernel/time.c | 41 ++++++++++++++++++++++++++++++++++++++ include/linux/vtime.h      |  6 ++++++

  2 files changed, 47 insertions(+)

arch/powerpc/kernel/time.c +6 -0

index 4bbeb8644d3d..18506740f4a4 100644
@@ -376,6 +376,47 @@ void vtime_task_switch(struct task_struct *prev)
           acct->starttime = acct0->starttime;
       }
   }
+
+#ifdef CONFIG_NO_HZ_COMMON
+/**
+ * vtime_reset - Fast forward vtime entry clocks
+ *
+ * Called from dynticks idle IRQ entry to fast-forward the clocks to 

current time
+ * so that the IRQ time is still accounted by vtime while nohz cputime is paused.
+ */

arch/powerpc/kernel/time.c

Quoted 5 lines

arch/powerpc/kernel/time.c +5 -0

+void vtime_reset(void)
+{
+    struct cpu_accounting_data *acct = get_accounting(current);
+
+    acct->starttime = mftb();

I figured out why those huge values happen.

This happens because mftb is from when the system is booted. I was doing kexec to start the new kernel and mftb wasn't getting reset.

I thought about this. This is concern for pseries too, where LPAR's restart but system won't restart and mftb will continue to run instead of reset.

I think we should be using sched_clock instead of mftb here. Though we need it a few more places and some cosmetic changes around it.

Note: Some values being huge exists without series for few CPUs, with series it shows up in most of the CPUs.

So I am planning send out fix below fix separately keeping your series as dependency.

---
  arch/powerpc/include/asm/accounting.h |  4 ++--
  arch/powerpc/include/asm/cputime.h    | 14 +++++++-------
  arch/powerpc/kernel/time.c            | 22 +++++++++++-----------
  3 files changed, 20 insertions(+), 20 deletions(-)

arch/powerpc/include/asm/accounting.h +2 -2

index 6d79c31700e2..50f120646e6d 100644
@@ -21,8 +21,8 @@ struct cpu_accounting_data {
      unsigned long steal_time;
      unsigned long idle_time;
      /* Internal counters */
-    unsigned long starttime;    /* TB value snapshot */
-    unsigned long starttime_user;    /* TB value on exit to usermode */
+    unsigned long starttime;    /* Time value snapshot */
+    unsigned long starttime_user;    /* Time value on exit to usermode */
  #ifdef CONFIG_ARCH_HAS_SCALED_CPUTIME
      unsigned long startspurr;    /* SPURR value snapshot */
      unsigned long utime_sspurr;    /* ->user_time when ->startspurr 

set */

arch/powerpc/include/asm/cputime.h +1 -1

index aff858ca99c0..eb6b629b113f 100644
@@ -20,9 +20,9 @@
  #include <asm/time.h>
  #include <asm/param.h>
  #include <asm/firmware.h>
+#include <linux/sched/clock.h>
 
  #ifdef __KERNEL__
-#define cputime_to_nsecs(cputime) tb_to_ns(cputime)
 
  /*
   * PPC64 uses PACA which is task independent for storing accounting 

data while

arch/powerpc/include/asm/cputime.h +5 -5

      struct cpu_accounting_data *acct = raw_get_accounting(current);
 
-    acct->utime += (tb - acct->starttime_user);
-    acct->starttime = tb;
+    acct->utime += (now - acct->starttime_user);
+    acct->starttime = now;
  }
 
  static notrace inline void account_cpu_user_exit(void)
  {
-    unsigned long tb = mftb();
+    unsigned long now = sched_clock();
      struct cpu_accounting_data *acct = raw_get_accounting(current);
 
-    acct->stime += (tb - acct->starttime);
-    acct->starttime_user = tb;
+    acct->stime += (now - acct->starttime);
+    acct->starttime_user = now;
  }
 
  static notrace inline void account_stolen_time(void)

arch/powerpc/kernel/time.c +10 -10

index 18506740f4a4..fb67cdae3bcb 100644
@@ -215,7 +215,7 @@ static unsigned long vtime_delta(struct 
 cpu_accounting_data *acct,
 
      WARN_ON_ONCE(!irqs_disabled());
 
-    now = mftb();
+    now = sched_clock();
      stime = now - acct->starttime;
      acct->starttime = now;

@@ -299,9 +299,9 @@ static void vtime_flush_scaled(struct task_struct *tsk,
  {
  #ifdef CONFIG_ARCH_HAS_SCALED_CPUTIME
      if (acct->utime_scaled)
-        tsk->utimescaled += cputime_to_nsecs(acct->utime_scaled);
+        tsk->utimescaled += acct->utime_scaled;
      if (acct->stime_scaled)
-        tsk->stimescaled += cputime_to_nsecs(acct->stime_scaled);
+        tsk->stimescaled += acct->stime_scaled;
 
      acct->utime_scaled = 0;
      acct->utime_sspurr = 0;

@@ -321,28 +321,28 @@ void vtime_flush(struct task_struct *tsk)
      struct cpu_accounting_data *acct = get_accounting(tsk);
 
      if (acct->utime)
-        account_user_time(tsk, cputime_to_nsecs(acct->utime));
+        account_user_time(tsk, acct->utime);
 
      if (acct->gtime)
-        account_guest_time(tsk, cputime_to_nsecs(acct->gtime));
+        account_guest_time(tsk, acct->gtime);
 
      if (IS_ENABLED(CONFIG_PPC_SPLPAR) && acct->steal_time) {
-        account_steal_time(cputime_to_nsecs(acct->steal_time));
+        account_steal_time(acct->steal_time);
          acct->steal_time = 0;
      }
 
      if (acct->idle_time)
-        account_idle_time(cputime_to_nsecs(acct->idle_time));
+        account_idle_time(acct->idle_time);
 
      if (acct->stime)
-        account_system_index_time(tsk, cputime_to_nsecs(acct->stime),
+        account_system_index_time(tsk, acct->stime,
                        CPUTIME_SYSTEM);
 
      if (acct->hardirq_time)
-        account_system_index_time(tsk, cputime_to_nsecs(acct- 
 >hardirq_time),
+        account_system_index_time(tsk, acct->hardirq_time,
                        CPUTIME_IRQ);
      if (acct->softirq_time)
-        account_system_index_time(tsk, cputime_to_nsecs(acct- 
 >softirq_time),
+        account_system_index_time(tsk, acct->softirq_time,
                        CPUTIME_SOFTIRQ);

     vtime_flush_scaled(tsk, acct);

arch/powerpc/kernel/time.c +1 -1

@@ -388,7 +388,7 @@ void vtime_reset(void)
  {
      struct cpu_accounting_data *acct = get_accounting(current);
 
-    acct->starttime = mftb();
+    acct->starttime = sched_clock();
  #ifdef CONFIG_ARCH_HAS_SCALED_CPUTIME
      acct->startspurr = read_spurr(acct->starttime);
  #endif

Hi Hegde,

Le 19/02/2026 à 19:30, Shrikanth Hegde a écrit :

Quoted 121 lines · Frederic Weisbecker

Quoted 21 lines

Currently the tick subsystem stores the idle cputime accounting in private fields, allowing cohabitation with architecture idle vtime accounting. The former is fetched on online CPUs, the latter on offline CPUs.

For consolidation purpose, architecture vtime accounting will continue to account the cputime but will make a break when the idle tick is stopped. The dyntick cputime accounting will then be relayed by the tick subsystem so that the idle cputime is still seen advancing coherently even when the tick isn't there to flush the idle vtime.

Prepare for that and introduce three new APIs which will be used in subsequent patches:

_ vtime_dynticks_start() is deemed to be called when idle enters in dyntick mode. The idle cputime that elapsed so far is accumulated.

- vtime_dynticks_stop() is deemed to be called when idle exits from dyntick mode. The vtime entry clocks are fast-forward to current time so that idle accounting restarts elapsing from now.

Quoted 8 lines

- vtime_reset() is deemed to be called from dynticks idle IRQ entry to fast-forward the clock to current time so that the IRQ time is still accounted by vtime while nohz cputime is paused.

Also accumulated vtime won't be flushed from dyntick-idle ticks to avoid accounting twice the idle cputime, along with nohz accounting.

Signed-off-by Frederic Weisbecker <[email protected]>

Reviewed-by Shrikanth Hegde <[email protected]>

Quoted 23 lines

---
  arch/powerpc/kernel/time.c | 41 ++++++++++++++++++++++++++++++++++++++ include/linux/vtime.h      |  6 ++++++

  2 files changed, 47 insertions(+)

arch/powerpc/kernel/time.c +6 -0

index 4bbeb8644d3d..18506740f4a4 100644
@@ -376,6 +376,47 @@ void vtime_task_switch(struct task_struct *prev)
           acct->starttime = acct0->starttime;
       }
   }
+
+#ifdef CONFIG_NO_HZ_COMMON
+/**
+ * vtime_reset - Fast forward vtime entry clocks
+ *
+ * Called from dynticks idle IRQ entry to fast-forward the clocks to 

current time
+ * so that the IRQ time is still accounted by vtime while nohz cputime is paused.
+ */

arch/powerpc/kernel/time.c

Quoted 5 lines

arch/powerpc/kernel/time.c +5 -0

+void vtime_reset(void)
+{
+    struct cpu_accounting_data *acct = get_accounting(current);
+
+    acct->starttime = mftb();

I figured out why those huge values happen.

This happens because mftb is from when the system is booted. I was doing kexec to start the new kernel and mftb wasn't getting reset.

I thought about this. This is concern for pseries too, where LPAR's restart but system won't restart and mftb will continue to run instead of reset.

I think we should be using sched_clock instead of mftb here. Though we need it a few more places and some cosmetic changes around it.

Note: Some values being huge exists without series for few CPUs, with series it shows up in most of the CPUs.

So I am planning send out fix below fix separately keeping your series as dependency.

---
  arch/powerpc/include/asm/accounting.h |  4 ++-- arch/powerpc/include/asm/cputime.h    | 14 +++++++------- arch/powerpc/kernel/time.c            | 22 +++++++++++-----------

  3 files changed, 20 insertions(+), 20 deletions(-)

arch/powerpc/include/asm/accounting.h +2 -2

index 6d79c31700e2..50f120646e6d 100644
@@ -21,8 +21,8 @@ struct cpu_accounting_data {
       unsigned long steal_time;
       unsigned long idle_time;
       /* Internal counters */
-    unsigned long starttime;    /* TB value snapshot */
-    unsigned long starttime_user;    /* TB value on exit to usermode */
+    unsigned long starttime;    /* Time value snapshot */
+    unsigned long starttime_user;    /* Time value on exit to 

usermode */
  #ifdef CONFIG_ARCH_HAS_SCALED_CPUTIME
      unsigned long startspurr;    /* SPURR value snapshot */ unsigned long utime_sspurr;    /* ->user_time when ->startspurr set */

arch/powerpc/include/asm/cputime.h +1 -1

index aff858ca99c0..eb6b629b113f 100644
@@ -20,9 +20,9 @@
   #include <asm/time.h>
   #include <asm/param.h>
   #include <asm/firmware.h>
+#include <linux/sched/clock.h>
 
   #ifdef __KERNEL__
-#define cputime_to_nsecs(cputime) tb_to_ns(cputime)
 
   /*
    * PPC64 uses PACA which is task independent for storing accounting data while

arch/powerpc/include/asm/cputime.h line 47

Quoted 5 lines

arch/powerpc/include/asm/cputime.h +1 -1

@@ -44,20 +44,20 @@
    */
   static notrace inline void account_cpu_user_entry(void)
   {
-    unsigned long tb = mftb();
+    unsigned long now = sched_clock();

Now way !

By doing that you'll kill performance for no reason. All we need when accounting time spent in kernel or in user is the difference between time at entry and time at exit, no mater what the time was at boot time.

Also sched_clock() returns nanoseconds which implies calculation from timebase. This is pointless CPU consumption. The current implementation calculates nanoseconds at task switch when calling vtime_flush().Your change will now do it at every kernel entry and kernel exit by calling sched_clock().

Another point is that sched_clock() returns a long long not a long.

And also sched_clock() uses get_tb() which does mftb and mftbu. Which is pointless for calculating time deltas unless your application spends hours without being re-scheduled.

Quoted 91 lines

arch/powerpc/include/asm/cputime.h +5 -5

       struct cpu_accounting_data *acct = raw_get_accounting(current);
 
-    acct->utime += (tb - acct->starttime_user);
-    acct->starttime = tb;
+    acct->utime += (now - acct->starttime_user);
+    acct->starttime = now;
   }
 
   static notrace inline void account_cpu_user_exit(void)
   {
-    unsigned long tb = mftb();
+    unsigned long now = sched_clock();
       struct cpu_accounting_data *acct = raw_get_accounting(current);
 
-    acct->stime += (tb - acct->starttime);
-    acct->starttime_user = tb;
+    acct->stime += (now - acct->starttime);
+    acct->starttime_user = now;
   }
 
   static notrace inline void account_stolen_time(void)

arch/powerpc/kernel/time.c +3 -3

index 18506740f4a4..fb67cdae3bcb 100644
@@ -215,7 +215,7 @@ static unsigned long vtime_delta(struct 
 cpu_accounting_data *acct,
 
       WARN_ON_ONCE(!irqs_disabled());
 
-    now = mftb();
+    now = sched_clock();
       stime = now - acct->starttime;
       acct->starttime = now;

@@ -299,9 +299,9 @@ static void vtime_flush_scaled(struct task_struct 
 *tsk,
   {
   #ifdef CONFIG_ARCH_HAS_SCALED_CPUTIME
       if (acct->utime_scaled)
-        tsk->utimescaled += cputime_to_nsecs(acct->utime_scaled);
+        tsk->utimescaled += acct->utime_scaled;
       if (acct->stime_scaled)
-        tsk->stimescaled += cputime_to_nsecs(acct->stime_scaled);
+        tsk->stimescaled += acct->stime_scaled;
 
       acct->utime_scaled = 0;

      acct->utime_sspurr = 0;

arch/powerpc/kernel/time.c +7 -7

@@ -321,28 +321,28 @@ void vtime_flush(struct task_struct *tsk)
       struct cpu_accounting_data *acct = get_accounting(tsk);
 
       if (acct->utime)
-        account_user_time(tsk, cputime_to_nsecs(acct->utime));
+        account_user_time(tsk, acct->utime);
 
       if (acct->gtime)
-        account_guest_time(tsk, cputime_to_nsecs(acct->gtime));
+        account_guest_time(tsk, acct->gtime);
 
       if (IS_ENABLED(CONFIG_PPC_SPLPAR) && acct->steal_time) {
-        account_steal_time(cputime_to_nsecs(acct->steal_time));
+        account_steal_time(acct->steal_time);
           acct->steal_time = 0;
       }
 
       if (acct->idle_time)
-        account_idle_time(cputime_to_nsecs(acct->idle_time));
+        account_idle_time(acct->idle_time);
 
       if (acct->stime)
-        account_system_index_time(tsk, cputime_to_nsecs(acct->stime),
+        account_system_index_time(tsk, acct->stime,
                         CPUTIME_SYSTEM);
 
       if (acct->hardirq_time)
-        account_system_index_time(tsk, cputime_to_nsecs(acct- 
  >hardirq_time),
+        account_system_index_time(tsk, acct->hardirq_time,
                         CPUTIME_IRQ);
       if (acct->softirq_time)
-        account_system_index_time(tsk, cputime_to_nsecs(acct- 
  >softirq_time),
+        account_system_index_time(tsk, acct->softirq_time,
                         CPUTIME_SOFTIRQ);

      vtime_flush_scaled(tsk, acct);

arch/powerpc/kernel/time.c +0 -0

@@ -388,7 +388,7 @@ void vtime_reset(void)
   {
       struct cpu_accounting_data *acct = get_accounting(current);
 

arch/powerpc/kernel/time.c void vtime_reset(void) · line 394

Quoted 5 lines

arch/powerpc/kernel/time.c +1 -1

-    acct->starttime = mftb();
+    acct->starttime = sched_clock();
   #ifdef CONFIG_ARCH_HAS_SCALED_CPUTIME
       acct->startspurr = read_spurr(acct->starttime);
   #endif

Hi Christophe,

Quoted 133 lines · Christophe Leroy (CS GROUP)

Hi Hegde,

Le 19/02/2026 à 19:30, Shrikanth Hegde a écrit :

Quoted 122 lines · Frederic Weisbecker

Quoted 21 lines

Currently the tick subsystem stores the idle cputime accounting in private fields, allowing cohabitation with architecture idle vtime accounting. The former is fetched on online CPUs, the latter on offline CPUs.

For consolidation purpose, architecture vtime accounting will continue to account the cputime but will make a break when the idle tick is stopped. The dyntick cputime accounting will then be relayed by the tick subsystem so that the idle cputime is still seen advancing coherently even when the tick isn't there to flush the idle vtime.

Prepare for that and introduce three new APIs which will be used in subsequent patches:

_ vtime_dynticks_start() is deemed to be called when idle enters in dyntick mode. The idle cputime that elapsed so far is accumulated.

- vtime_dynticks_stop() is deemed to be called when idle exits from dyntick mode. The vtime entry clocks are fast-forward to current time so that idle accounting restarts elapsing from now.

Quoted 8 lines

- vtime_reset() is deemed to be called from dynticks idle IRQ entry to fast-forward the clock to current time so that the IRQ time is still accounted by vtime while nohz cputime is paused.

Also accumulated vtime won't be flushed from dyntick-idle ticks to avoid accounting twice the idle cputime, along with nohz accounting.

Signed-off-by Frederic Weisbecker <[email protected]>

Reviewed-by Shrikanth Hegde <[email protected]>

Quoted 24 lines

---
  arch/powerpc/kernel/time.c | 41 ++++++++++++++++++++++++++++++++++
++++
  include/linux/vtime.h      |  6 ++++++

  2 files changed, 47 insertions(+)

arch/powerpc/kernel/time.c +6 -0

index 4bbeb8644d3d..18506740f4a4 100644
@@ -376,6 +376,47 @@ void vtime_task_switch(struct task_struct *prev)
           acct->starttime = acct0->starttime;
       }
   }
+
+#ifdef CONFIG_NO_HZ_COMMON
+/**
+ * vtime_reset - Fast forward vtime entry clocks
+ *
+ * Called from dynticks idle IRQ entry to fast-forward the clocks 

to current time
+ * so that the IRQ time is still accounted by vtime while nohz cputime is paused.
+ */

arch/powerpc/kernel/time.c

Quoted 5 lines

arch/powerpc/kernel/time.c +5 -0

+void vtime_reset(void)
+{
+    struct cpu_accounting_data *acct = get_accounting(current);
+
+    acct->starttime = mftb();

I figured out why those huge values happen.

This happens because mftb is from when the system is booted. I was doing kexec to start the new kernel and mftb wasn't getting reset.

I thought about this. This is concern for pseries too, where LPAR's restart but system won't restart and mftb will continue to run instead of reset.

I think we should be using sched_clock instead of mftb here. Though we need it a few more places and some cosmetic changes around it.

Note: Some values being huge exists without series for few CPUs, with series it shows up in most of the CPUs.

So I am planning send out fix below fix separately keeping your series as dependency.

---
  arch/powerpc/include/asm/accounting.h |  4 ++-- arch/powerpc/include/asm/cputime.h    | 14 +++++++------- arch/powerpc/kernel/time.c            | 22 +++++++++++-----------

  3 files changed, 20 insertions(+), 20 deletions(-)

arch/powerpc/include/asm/accounting.h +2 -2

index 6d79c31700e2..50f120646e6d 100644
@@ -21,8 +21,8 @@ struct cpu_accounting_data {
       unsigned long steal_time;
       unsigned long idle_time;
       /* Internal counters */
-    unsigned long starttime;    /* TB value snapshot */
-    unsigned long starttime_user;    /* TB value on exit to usermode */
+    unsigned long starttime;    /* Time value snapshot */
+    unsigned long starttime_user;    /* Time value on exit to 

usermode */
  #ifdef CONFIG_ARCH_HAS_SCALED_CPUTIME
      unsigned long startspurr;    /* SPURR value snapshot */ unsigned long utime_sspurr;    /* ->user_time when ->startspurr set */

arch/powerpc/include/asm/cputime.h +1 -1

index aff858ca99c0..eb6b629b113f 100644
@@ -20,9 +20,9 @@
   #include <asm/time.h>
   #include <asm/param.h>
   #include <asm/firmware.h>
+#include <linux/sched/clock.h>
 
   #ifdef __KERNEL__
-#define cputime_to_nsecs(cputime) tb_to_ns(cputime)
 
   /*
    * PPC64 uses PACA which is task independent for storing accounting data while

arch/powerpc/include/asm/cputime.h line 47

Quoted 5 lines

arch/powerpc/include/asm/cputime.h +1 -1

@@ -44,20 +44,20 @@
    */
   static notrace inline void account_cpu_user_entry(void)
   {
-    unsigned long tb = mftb();
+    unsigned long now = sched_clock();

Now way !

Quoted 2 lines

By doing that you'll kill performance for no reason. All we need when accounting time spent in kernel or in user is the difference between time at entry and time at exit, no mater what the time was at boot time.

No. With this patch there will not be any performance difference. All it does is, instead of using mftb uses sched_clock at those places.

In arch/powerpc/kernel/time.c we have sched_clock(). notrace unsigned long long sched_clock(void)
{
        return mulhdu(get_tb() - boot_tb, tb_to_ns_scale) <<
tb_to_ns_shift;
}

It does the same mftb call, and accounts only the time after boot, which is what /proc/stat should do as well.

"
the amount of time, measured in units of USER_HZ
(1/100ths of a second on most architectures

user   (1) Time spent in user mode.

idle   (4) Time spent in the idle task.  This value
       should be USER_HZ times the second entry in
       the /proc/uptime pseudo-file.
"
/proc/uptime is based on sched_clock, so i infer /proc/stat also should show values w.r.t to boot of the OS.

Quoted 1 line

Also sched_clock() returns nanoseconds which implies calculation from timebase. This is pointless CPU consumption. The current implementation calculates nanoseconds at task switch when calling vtime_flush().Your change will now do it at every kernel entry and kernel exit by calling sched_clock().

This change doesn't add any additional paths. Even without patches, mftb would have been called in every kernel entry/exit.  See mftb usage account_cpu_user_exit/enter

Now instead of mftb sched_clock is used, that's all. No additional entry/exit points. And previously when accounting we would have done cputime_to_nsecs, now that conversion is done automatically in sched_clock. So overall computation-wise it should be same.

What i am missing to see it here?

Hi Hegde,

Le 25/02/2026 à 08:46, Shrikanth Hegde a écrit :

Quoted 170 lines

Hi Christophe,

Quoted 135 lines · Christophe Leroy (CS GROUP)

Hi Hegde,

Le 19/02/2026 à 19:30, Shrikanth Hegde a écrit :

Quoted 124 lines · Frederic Weisbecker

Quoted 21 lines

Currently the tick subsystem stores the idle cputime accounting in private fields, allowing cohabitation with architecture idle vtime accounting. The former is fetched on online CPUs, the latter on offline CPUs.

For consolidation purpose, architecture vtime accounting will continue to account the cputime but will make a break when the idle tick is stopped. The dyntick cputime accounting will then be relayed by the tick subsystem so that the idle cputime is still seen advancing coherently even when the tick isn't there to flush the idle vtime.

Prepare for that and introduce three new APIs which will be used in subsequent patches:

_ vtime_dynticks_start() is deemed to be called when idle enters in dyntick mode. The idle cputime that elapsed so far is accumulated.

- vtime_dynticks_stop() is deemed to be called when idle exits from dyntick mode. The vtime entry clocks are fast-forward to current time so that idle accounting restarts elapsing from now.

Quoted 8 lines

- vtime_reset() is deemed to be called from dynticks idle IRQ entry to fast-forward the clock to current time so that the IRQ time is still accounted by vtime while nohz cputime is paused.

Also accumulated vtime won't be flushed from dyntick-idle ticks to avoid accounting twice the idle cputime, along with nohz accounting.

Signed-off-by Frederic Weisbecker <[email protected]>

Reviewed-by Shrikanth Hegde <[email protected]>

Quoted 24 lines

---
  arch/powerpc/kernel/time.c | 41 +++++++++++++++++++++++++++++++++
+ ++++
  include/linux/vtime.h      |  6 ++++++

  2 files changed, 47 insertions(+)

arch/powerpc/kernel/time.c +6 -0

index 4bbeb8644d3d..18506740f4a4 100644
@@ -376,6 +376,47 @@ void vtime_task_switch(struct task_struct *prev)
           acct->starttime = acct0->starttime;
       }
   }
+
+#ifdef CONFIG_NO_HZ_COMMON
+/**
+ * vtime_reset - Fast forward vtime entry clocks
+ *
+ * Called from dynticks idle IRQ entry to fast-forward the clocks 

to current time
+ * so that the IRQ time is still accounted by vtime while nohz cputime is paused.
+ */

arch/powerpc/kernel/time.c

Quoted 5 lines

arch/powerpc/kernel/time.c +5 -0

+void vtime_reset(void)
+{
+    struct cpu_accounting_data *acct = get_accounting(current);
+
+    acct->starttime = mftb();

I figured out why those huge values happen.

This happens because mftb is from when the system is booted. I was doing kexec to start the new kernel and mftb wasn't getting reset.

I thought about this. This is concern for pseries too, where LPAR's restart but system won't restart and mftb will continue to run instead of reset.

I think we should be using sched_clock instead of mftb here. Though we need it a few more places and some cosmetic changes around it.

Note: Some values being huge exists without series for few CPUs, with series it shows up in most of the CPUs.

So I am planning send out fix below fix separately keeping your series as dependency.

---
  arch/powerpc/include/asm/accounting.h |  4 ++-- arch/powerpc/include/asm/cputime.h    | 14 +++++++------- arch/powerpc/kernel/time.c            | 22 +++++++++++-----------

  3 files changed, 20 insertions(+), 20 deletions(-)

arch/powerpc/include/asm/accounting.h +0 -2

index 6d79c31700e2..50f120646e6d 100644
@@ -21,8 +21,8 @@ struct cpu_accounting_data {
       unsigned long steal_time;
       unsigned long idle_time;
       /* Internal counters */
-    unsigned long starttime;    /* TB value snapshot */
-    unsigned long starttime_user;    /* TB value on exit to 

usermode */
+    unsigned long starttime;    /* Time value snapshot */ +    unsigned long starttime_user;    /* Time value on exit to usermode */
  #ifdef CONFIG_ARCH_HAS_SCALED_CPUTIME
      unsigned long startspurr;    /* SPURR value snapshot */ unsigned long utime_sspurr;    /* ->user_time when -

Quoted 1 line

startspurr set */

arch/powerpc/include/asm/cputime.h +1 -1

index aff858ca99c0..eb6b629b113f 100644
@@ -20,9 +20,9 @@
   #include <asm/time.h>
   #include <asm/param.h>
   #include <asm/firmware.h>
+#include <linux/sched/clock.h>
 
   #ifdef __KERNEL__
-#define cputime_to_nsecs(cputime) tb_to_ns(cputime)
 
   /*
    * PPC64 uses PACA which is task independent for storing accounting data while

arch/powerpc/include/asm/cputime.h line 47

Quoted 5 lines

arch/powerpc/include/asm/cputime.h +1 -1

@@ -44,20 +44,20 @@
    */
   static notrace inline void account_cpu_user_entry(void)
   {
-    unsigned long tb = mftb();
+    unsigned long now = sched_clock();

Now way !

Quoted 2 lines

By doing that you'll kill performance for no reason. All we need when accounting time spent in kernel or in user is the difference between time at entry and time at exit, no mater what the time was at boot time.

No. With this patch there will not be any performance difference. All it does is, instead of using mftb uses sched_clock at those places.

In arch/powerpc/kernel/time.c we have sched_clock().
notrace unsigned long long sched_clock(void)
{
         return mulhdu(get_tb() - boot_tb, tb_to_ns_scale) << tb_to_ns_shift; }

It does the same mftb call, and accounts only the time after boot, which is what /proc/stat should do as well.

"
the amount of time, measured in units of USER_HZ
(1/100ths of a second on most architectures

user   (1) Time spent in user mode.

idle   (4) Time spent in the idle task.  This value
        should be USER_HZ times the second entry in
        the /proc/uptime pseudo-file.
"
/proc/uptime is based on sched_clock, so i infer /proc/stat also should show values w.r.t to boot of the OS.

Quoted 1 line

Also sched_clock() returns nanoseconds which implies calculation from timebase. This is pointless CPU consumption. The current implementation calculates nanoseconds at task switch when calling vtime_flush().Your change will now do it at every kernel entry and kernel exit by calling sched_clock().

Quoted 8 lines

This change doesn't add any additional paths. Even without patches, mftb would have been called in every kernel entry/exit.  See mftb usage account_cpu_user_exit/enter

Now instead of mftb sched_clock is used, that's all. No additional entry/exit points. And previously when accounting we would have done cputime_to_nsecs, now that conversion is done automatically in sched_clock. So overall computation-wise it should be same.

What i am missing to see it here?

Ok, lets try to explain in more details:

While a process is running, it will enter and leave the kernel multiple times, without task switch. For instance for system calls or for interrupts.

At every kernel entry and exit, account_cpu_user_entry() and account_cpu_user_exit() are called. That's a very hot path.

I have added the following functions to see what the code looks like:

(quoted diff) +12 -0

+
+void my_account_cpu_user_entry(void);
+void my_account_cpu_user_entry(void)
+{
+       account_cpu_user_entry();
+}
+
+void my_account_cpu_user_exit(void);
+void my_account_cpu_user_exit(void)
+{
+       account_cpu_user_exit();
+}

What we have today is very optimised:

00000148 <my_account_cpu_user_entry>:
 148:    7d 0c 42 e6     mftb    r8
 14c:    80 e2 00 08     lwz     r7,8(r2)
 150:    81 22 00 28     lwz     r9,40(r2)
 154:    91 02 00 24     stw     r8,36(r2)
 158:    7d 29 38 50     subf    r9,r9,r7
 15c:    7d 29 42 14     add     r9,r9,r8
 160:    91 22 00 08     stw     r9,8(r2)
 164:    4e 80 00 20     blr

00000168 <my_account_cpu_user_exit>:
 168:    7d 0c 42 e6     mftb    r8
 16c:    80 e2 00 0c     lwz     r7,12(r2)
 170:    81 22 00 24     lwz     r9,36(r2)
 174:    91 02 00 28     stw     r8,40(r2)
 178:    7d 29 38 50     subf    r9,r9,r7
 17c:    7d 29 42 14     add     r9,r9,r8
 180:    91 22 00 0c     stw     r9,12(r2)
 184:    4e 80 00 20     blr

With your change we now get a call to sched_clock() instead of a simple mftb,

00000154 <my_account_cpu_user_entry>:
 154:    94 21 ff f0     stwu    r1,-16(r1)
 158:    7c 08 02 a6     mflr    r0
 15c:    90 01 00 14     stw     r0,20(r1)
 160:    48 00 00 01     bl      160 <my_account_cpu_user_entry+0xc> 160: R_PPC_REL24    sched_clock
 164:    81 02 00 08     lwz     r8,8(r2)
 168:    81 22 00 28     lwz     r9,40(r2)
 16c:    90 82 00 24     stw     r4,36(r2)
 170:    7d 29 40 50     subf    r9,r9,r8
 174:    7d 29 22 14     add     r9,r9,r4
 178:    91 22 00 08     stw     r9,8(r2)
 17c:    80 01 00 14     lwz     r0,20(r1)
 180:    38 21 00 10     addi    r1,r1,16
 184:    7c 08 03 a6     mtlr    r0
 188:    4e 80 00 20     blr

0000018c <my_account_cpu_user_exit>:
 18c:    94 21 ff f0     stwu    r1,-16(r1)
 190:    7c 08 02 a6     mflr    r0
 194:    90 01 00 14     stw     r0,20(r1)
 198:    48 00 00 01     bl      198 <my_account_cpu_user_exit+0xc> 198: R_PPC_REL24    sched_clock
 19c:    81 02 00 0c     lwz     r8,12(r2)
 1a0:    81 22 00 24     lwz     r9,36(r2)
 1a4:    90 82 00 28     stw     r4,40(r2)
 1a8:    7d 29 40 50     subf    r9,r9,r8
 1ac:    7d 29 22 14     add     r9,r9,r4
 1b0:    91 22 00 0c     stw     r9,12(r2)
 1b4:    80 01 00 14     lwz     r0,20(r1)
 1b8:    38 21 00 10     addi    r1,r1,16
 1bc:    7c 08 03 a6     mtlr    r0
 1c0:    4e 80 00 20     blr

And sched_clock() is heavy, first it has the sequence mftbu/mftb/mftbu, and then it does awful lot of calculations including many multiply:

000004d8 <sched_clock>:
 4d8:    7d 2d 42 e6     mftbu   r9
 4dc:    7d 0c 42 e6     mftb    r8
 4e0:    7d 4d 42 e6     mftbu   r10
 4e4:    7c 09 50 40     cmplw   r9,r10
 4e8:    40 82 ff f0     bne     4d8 <sched_clock> 4ec:    3d 40 00 00     lis     r10,0
            4ee: R_PPC_ADDR16_HA    .data..ro_after_init 4f0:    38 ca 00 00     addi    r6,r10,0
            4f2: R_PPC_ADDR16_LO    .data..ro_after_init 4f4:    3c e0 00 00     lis     r7,0
            4f6: R_PPC_ADDR16_HA    .data..read_mostly 4f8:    38 87 00 00     addi    r4,r7,0
            4fa: R_PPC_ADDR16_LO    .data..read_mostly 4fc:    80 66 00 04     lwz     r3,4(r6)
 500:    80 e7 00 00     lwz     r7,0(r7)
            502: R_PPC_ADDR16_LO    .data..read_mostly 504:    80 c4 00 04     lwz     r6,4(r4)
 508:    81 4a 00 00     lwz     r10,0(r10) 50a: R_PPC_ADDR16_LO    .data..ro_after_init 50c:    7c 63 40 10     subfc   r3,r3,r8
 510:    7d 0a 49 10     subfe   r8,r10,r9
 514:    7d 27 19 d6     mullw   r9,r7,r3
 518:    7d 43 30 16     mulhwu  r10,r3,r6
 51c:    7c 08 31 d6     mullw   r0,r8,r6
 520:    7d 4a 48 14     addc    r10,r10,r9 524:    7c 67 18 16     mulhwu  r3,r7,r3
 528:    39 20 00 00     li      r9,0
 52c:    7c c8 30 16     mulhwu  r6,r8,r6
 530:    7c a9 49 14     adde    r5,r9,r9
 534:    7d 67 41 d6     mullw   r11,r7,r8
 538:    7d 4a 00 14     addc    r10,r10,r0 53c:    7c a5 01 94     addze   r5,r5
 540:    7c 63 30 14     addc    r3,r3,r6
 544:    7d 29 49 14     adde    r9,r9,r9
 548:    80 84 00 08     lwz     r4,8(r4)
 54c:    7c 63 58 14     addc    r3,r3,r11
 550:    7c e7 40 16     mulhwu  r7,r7,r8
 554:    7d 29 01 94     addze   r9,r9
 558:    7c 63 28 14     addc    r3,r3,r5
 55c:    7d 29 39 14     adde    r9,r9,r7
 560:    35 44 ff e0     addic.  r10,r4,-32 564:    41 80 00 10     blt     574 <sched_clock+0x9c> 568:    7c 63 50 30     slw     r3,r3,r10
 56c:    38 80 00 00     li      r4,0
 570:    4e 80 00 20     blr
 574:    21 04 00 1f     subfic  r8,r4,31
 578:    54 6a f8 7e     srwi    r10,r3,1
 57c:    7d 29 20 30     slw     r9,r9,r4
 580:    7d 4a 44 30     srw     r10,r10,r8 584:    7c 64 20 30     slw     r4,r3,r4
 588:    7d 43 4b 78     or      r3,r10,r9
 58c:    4e 80 00 20     blr

I think the difference is obvious, no need of benchmarking. We shall refrain from calling sched_clock() at every kernel entry/exit. Converting from timebase to nanoseconds only need to be done in vtime_flush() called by vtime_task_switch() during task switch.

Hope it is more explicit now.

Hi Christophe.

Quoted 3 lines · Christophe Leroy (CS GROUP)

Hope it is more explicit now.

Got it. The main concern was around with additional computation that sched_clock, not any additional paths per se.

yes, that would be possible,

How about we do below? This adds only one subtraction. This achieves the same outcome.

Hi Hegde,

Le 25/02/2026 à 11:34, Shrikanth Hegde a écrit :

Quoted 10 lines

Hi Christophe.

Quoted 3 lines · Christophe Leroy (CS GROUP)

Hope it is more explicit now.

Got it. The main concern was around with additional computation that sched_clock, not any additional paths per se.

Quoted 5 lines

yes, that would be possible,

How about we do below? This adds only one subtraction. This achieves the same outcome.

It adds a bit more than just a substration. It adds a call to an extern fonction.

00000164 <my_account_cpu_user_entry>:
 164:    94 21 ff f0     stwu    r1,-16(r1)
 168:    7c 08 02 a6     mflr    r0
 16c:    90 01 00 14     stw     r0,20(r1)
 170:    93 e1 00 0c     stw     r31,12(r1)
 174:    7f ec 42 e6     mftb    r31
 178:    48 00 00 01     bl      178 <my_account_cpu_user_entry+0x14> 178: R_PPC_REL24    get_boot_tb
 17c:    81 02 00 08     lwz     r8,8(r2)
 180:    81 22 00 28     lwz     r9,40(r2)
 184:    7c 84 f8 50     subf    r4,r4,r31
 188:    7d 29 40 50     subf    r9,r9,r8
 18c:    7d 29 22 14     add     r9,r9,r4
 190:    90 82 00 24     stw     r4,36(r2)
 194:    91 22 00 08     stw     r9,8(r2)
 198:    80 01 00 14     lwz     r0,20(r1)
 19c:    83 e1 00 0c     lwz     r31,12(r1)
 1a0:    7c 08 03 a6     mtlr    r0
 1a4:    38 21 00 10     addi    r1,r1,16
 1a8:    4e 80 00 20     blr

000001ac <my_account_cpu_user_exit>:
 1ac:    94 21 ff f0     stwu    r1,-16(r1)
 1b0:    7c 08 02 a6     mflr    r0
 1b4:    90 01 00 14     stw     r0,20(r1)
 1b8:    93 e1 00 0c     stw     r31,12(r1)
 1bc:    7f ec 42 e6     mftb    r31
 1c0:    48 00 00 01     bl      1c0 <my_account_cpu_user_exit+0x14> 1c0: R_PPC_REL24    get_boot_tb
 1c4:    81 02 00 0c     lwz     r8,12(r2)
 1c8:    81 22 00 24     lwz     r9,36(r2)
 1cc:    7c 84 f8 50     subf    r4,r4,r31
 1d0:    7d 29 40 50     subf    r9,r9,r8
 1d4:    7d 29 22 14     add     r9,r9,r4
 1d8:    90 82 00 28     stw     r4,40(r2)
 1dc:    91 22 00 0c     stw     r9,12(r2)
 1e0:    80 01 00 14     lwz     r0,20(r1)
 1e4:    83 e1 00 0c     lwz     r31,12(r1)
 1e8:    7c 08 03 a6     mtlr    r0
 1ec:    38 21 00 10     addi    r1,r1,16
 1f0:    4e 80 00 20     blr

I really still can't see the point of this substraction.

At one place we do

    tb1 = mftb1;

    acct->utime += (tb1 - acct->starttime_user);
    acct->starttime = tb1;

At the other place we do

    tb2 = mftb2;

    acct->stime += (tb2 - acct->starttime);
    acct->starttime_user = tb2;

So at the end we have

    acct->utime += mftb1 - mftb2;
    acct->stime += mftb2 - mftb1;

You want to change to
    tb1 = mftb1 - boot_tb;
    tb2 = mftb2 - boot_tb;

At the end we would get

    acct->utime += mftb1 - boot_tb - mftb2 + boot_tb = mftb1 - mftb2; acct->stime += mftb2 - boot_tb - mftb1 + boot_tb = mftb2 - mftb1;

So what's the point in doing such a useless substract that disappears at the end ? What am I missing ?

Quoted 13 lines

Hi Hegde,

Le 25/02/2026 à 11:34, Shrikanth Hegde a écrit :

Quoted 10 lines

Hi Christophe.

Quoted 3 lines · Christophe Leroy (CS GROUP)

Hope it is more explicit now.

Got it. The main concern was around with additional computation that sched_clock, not any additional paths per se.

Quoted 7 lines

Quoted 5 lines

yes, that would be possible,

How about we do below? This adds only one subtraction. This achieves the same outcome.

It adds a bit more than just a substration. It adds a call to an extern fonction.

I think we should make it always inline and move it to time.h

Quoted 69 lines

00000164 <my_account_cpu_user_entry>:
  164:    94 21 ff f0     stwu    r1,-16(r1)
  168:    7c 08 02 a6     mflr    r0
  16c:    90 01 00 14     stw     r0,20(r1)
  170:    93 e1 00 0c     stw     r31,12(r1)
  174:    7f ec 42 e6     mftb    r31
  178:    48 00 00 01     bl      178 <my_account_cpu_user_entry+0x14> 178: R_PPC_REL24    get_boot_tb
  17c:    81 02 00 08     lwz     r8,8(r2)
  180:    81 22 00 28     lwz     r9,40(r2)
  184:    7c 84 f8 50     subf    r4,r4,r31
  188:    7d 29 40 50     subf    r9,r9,r8
  18c:    7d 29 22 14     add     r9,r9,r4
  190:    90 82 00 24     stw     r4,36(r2)
  194:    91 22 00 08     stw     r9,8(r2)
  198:    80 01 00 14     lwz     r0,20(r1)
  19c:    83 e1 00 0c     lwz     r31,12(r1)
  1a0:    7c 08 03 a6     mtlr    r0
  1a4:    38 21 00 10     addi    r1,r1,16
  1a8:    4e 80 00 20     blr

000001ac <my_account_cpu_user_exit>:
  1ac:    94 21 ff f0     stwu    r1,-16(r1)
  1b0:    7c 08 02 a6     mflr    r0
  1b4:    90 01 00 14     stw     r0,20(r1)
  1b8:    93 e1 00 0c     stw     r31,12(r1)
  1bc:    7f ec 42 e6     mftb    r31
  1c0:    48 00 00 01     bl      1c0 <my_account_cpu_user_exit+0x14> 1c0: R_PPC_REL24    get_boot_tb
  1c4:    81 02 00 0c     lwz     r8,12(r2)
  1c8:    81 22 00 24     lwz     r9,36(r2)
  1cc:    7c 84 f8 50     subf    r4,r4,r31
  1d0:    7d 29 40 50     subf    r9,r9,r8
  1d4:    7d 29 22 14     add     r9,r9,r4
  1d8:    90 82 00 28     stw     r4,40(r2)
  1dc:    91 22 00 0c     stw     r9,12(r2)
  1e0:    80 01 00 14     lwz     r0,20(r1)
  1e4:    83 e1 00 0c     lwz     r31,12(r1)
  1e8:    7c 08 03 a6     mtlr    r0
  1ec:    38 21 00 10     addi    r1,r1,16
  1f0:    4e 80 00 20     blr

I really still can't see the point of this substraction.

At one place we do

     tb1 = mftb1;

     acct->utime += (tb1 - acct->starttime_user);
     acct->starttime = tb1;

At the other place we do

     tb2 = mftb2;

     acct->stime += (tb2 - acct->starttime);
     acct->starttime_user = tb2;

So at the end we have

     acct->utime += mftb1 - mftb2;
     acct->stime += mftb2 - mftb1;

You want to change to
     tb1 = mftb1 - boot_tb;
     tb2 = mftb2 - boot_tb;

Quoted 7 lines

At the end we would get

     acct->utime += mftb1 - boot_tb - mftb2 + boot_tb = mftb1 - mftb2; acct->stime += mftb2 - boot_tb - mftb1 + boot_tb = mftb2 - mftb1;

So what's the point in doing such a useless substract that disappears at the end ? What am I missing ?

I had similar thought, but I saw this data below when i do exec on the system.

This was the stats seen on PowerNV system with 144 CPUs. Nothing is running on the system after boot. So it is mostly idle.

======== With the series applied ===

cat /proc/stat | head
cpu  1494 0 135607576 9628633227 16876 142 63 0 0 0 cpu0 0 0 8 67807311 0 2 40 0 0 0
cpu1 0 0 6 67807349 0 0 0 0 0 0

cat /proc/uptime
48.32 96286332.82   << Note this value is too huge. Also system value is also huge.

========= without the series(tip/master) =============== cat /proc/stat | head
cpu  2003 0 67866261 859414 15923 249 66 0 0 0 cpu0 5 0 23 5595 461 2 38 0 0 0
cpu1 0 0 9 6092 21 0 3 0 0 0

cat /proc/uptime
61.29 8594.82    << This is right. 144*61 = 8784.

But note, the system time reported. i.e 67866261. It is too huge again. And very close to actual mftb value rather than the diff. i.e we have paths were tb1 is not done. tb2 is effectively mftb - 0

========= with proposed fix of mftb - boot_tb =============== cat /proc/stat | head
cpu  5187 0 10996 2025690 16566 765 184 0 0 0
cpu0 9 0 28 14096 65 6 108 0 0 0
cpu1 4 0 15 14277 0 0 2 0 0 0

cat /proc/uptime
142.97 20257.42     << Looks correct, since 142*144 is close to 20448

=============================================================

Now lets go to CONFIG_VIRT_CPU_ACCOUNTING_GEN=y

cat /proc/stat | head
cpu  1804 0 3003 791760 15695 0 0 0 0 0
cpu0 22 0 46 5535 0 0 0 0 0 0
cpu1 0 0 7 5637 0 0 0 0 0 0

cat /proc/uptime
56.49 7918.05      << Looks correct. close 56*144

================================================

I think I'm starting to understand now.

I think the problem is that acct->starttime has an invalid value the very first time it is used.

We are probably lacking an initial value in paca->accounting.starttime.
This should likely be initialised from mftb in head_64.S in start_here_common for main CPU and __secondary_start for other CPUs or maybe at higher level in C in setup_arch() and start_secondary()

Christophe

Hi Christophe.

Quoted 2 lines

I think I'm starting to understand now.

Quoted 6 lines

I think the problem is that acct->starttime has an invalid value the very first time it is used.

We are probably lacking an initial value in paca->accounting.starttime.
This should likely be initialised from mftb in head_64.S in start_here_common for main CPU and __secondary_start for other CPUs or maybe at higher level in C in setup_arch() and start_secondary()

Christophe

How about below? this works too.

---

arch/powerpc/kernel/time.c +4 -0

index 18506740f4a4..af129645b7f7 100644
@@ -928,9 +928,24 @@ static void __init set_decrementer_max(void)
                 bits, decrementer_max);
  }
 
+#ifdef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE
+/*
+ * This is done to initialize the starttime correctly. with this
+ * /proc/stat show correct values similar to 

CONFIG_VIRT_CPU_ACCOUNTING_GEN
+ */

arch/powerpc/kernel/time.c +12 -0

+static void init_cpu_accounting_startime(void)
+{
+       struct cpu_accounting_data *acct = get_accounting(current);
+       acct->starttime = mftb();
+}
+#else
+static void init_cpu_accounting_startime(void) { };
+#endif
+
  static void __init init_decrementer_clockevent(void)
  {
         register_decrementer_clockevent(smp_processor_id());
+       init_cpu_accounting_startime();
  }
 
  void secondary_cpu_time_init(void)

@@ -946,6 +961,8 @@ void secondary_cpu_time_init(void)
         /* FIME: Should make unrelated change to move snapshot_timebase
          * call here ! */
         register_decrementer_clockevent(smp_processor_id());
+
+       init_cpu_accounting_startime();
  }
 
  /*

Le 25/02/2026 à 18:47, Shrikanth Hegde a écrit :

Quoted 9 lines

Hi Christophe.

Quoted 7 lines

I think I'm starting to understand now.

I think the problem is that acct->starttime has an invalid value the very first time it is used.

We are probably lacking an initial value in paca->accounting.starttime.
This should likely be initialised from mftb in head_64.S in start_here_common for main CPU and __secondary_start for other CPUs or maybe at higher level in C in setup_arch() and start_secondary()

Quoted 3 lines

Quoted 1 line

Christophe

How about below? this works too.

Fine it is works, it means we found the real problem.

What about using the newly added vtime_reset() ? See below (untested)

arch/powerpc/kernel/time.c +3 -1

index 9b3167274653..f4aef85106ac 100644
@@ -377,7 +377,6 @@ void vtime_task_switch(struct task_struct *prev)
      }
  }
 
-#ifdef CONFIG_NO_HZ_COMMON
  /**
   * vtime_reset - Fast forward vtime entry clocks
   *

@@ -394,6 +393,7 @@ void vtime_reset(void)
  #endif
  }
 
+#ifdef CONFIG_NO_HZ_COMMON
  /**
   * vtime_dyntick_start - Inform vtime about entry to idle-dynticks
   *

@@ -931,6 +931,7 @@ static void __init set_decrementer_max(void)
  static void __init init_decrementer_clockevent(void)
  {
      register_decrementer_clockevent(smp_processor_id());
+    vtime_reset();
  }
 
  void secondary_cpu_time_init(void)

@@ -946,6 +947,7 @@ void secondary_cpu_time_init(void)
      /* FIME: Should make unrelated change to move snapshot_timebase
       * call here ! */
      register_decrementer_clockevent(smp_processor_id());
+    vtime_reset();
  }
 
  /*

Hi Christophe,

Quoted 133 lines · Christophe Leroy (CS GROUP)

Hi Hegde,

Le 19/02/2026 à 19:30, Shrikanth Hegde a écrit :

Quoted 122 lines · Frederic Weisbecker

Quoted 21 lines

Currently the tick subsystem stores the idle cputime accounting in private fields, allowing cohabitation with architecture idle vtime accounting. The former is fetched on online CPUs, the latter on offline CPUs.

For consolidation purpose, architecture vtime accounting will continue to account the cputime but will make a break when the idle tick is stopped. The dyntick cputime accounting will then be relayed by the tick subsystem so that the idle cputime is still seen advancing coherently even when the tick isn't there to flush the idle vtime.

Prepare for that and introduce three new APIs which will be used in subsequent patches:

_ vtime_dynticks_start() is deemed to be called when idle enters in dyntick mode. The idle cputime that elapsed so far is accumulated.

- vtime_dynticks_stop() is deemed to be called when idle exits from dyntick mode. The vtime entry clocks are fast-forward to current time so that idle accounting restarts elapsing from now.

Quoted 8 lines

- vtime_reset() is deemed to be called from dynticks idle IRQ entry to fast-forward the clock to current time so that the IRQ time is still accounted by vtime while nohz cputime is paused.

Also accumulated vtime won't be flushed from dyntick-idle ticks to avoid accounting twice the idle cputime, along with nohz accounting.

Signed-off-by Frederic Weisbecker <[email protected]>

Reviewed-by Shrikanth Hegde <[email protected]>

Quoted 24 lines

---
  arch/powerpc/kernel/time.c | 41 ++++++++++++++++++++++++++++++++++
++++
  include/linux/vtime.h      |  6 ++++++

  2 files changed, 47 insertions(+)

arch/powerpc/kernel/time.c +6 -0

index 4bbeb8644d3d..18506740f4a4 100644
@@ -376,6 +376,47 @@ void vtime_task_switch(struct task_struct *prev)
           acct->starttime = acct0->starttime;
       }
   }
+
+#ifdef CONFIG_NO_HZ_COMMON
+/**
+ * vtime_reset - Fast forward vtime entry clocks
+ *
+ * Called from dynticks idle IRQ entry to fast-forward the clocks 

to current time
+ * so that the IRQ time is still accounted by vtime while nohz cputime is paused.
+ */

arch/powerpc/kernel/time.c

Quoted 5 lines

arch/powerpc/kernel/time.c +5 -0

+void vtime_reset(void)
+{
+    struct cpu_accounting_data *acct = get_accounting(current);
+
+    acct->starttime = mftb();

I figured out why those huge values happen.

This happens because mftb is from when the system is booted. I was doing kexec to start the new kernel and mftb wasn't getting reset.

I thought about this. This is concern for pseries too, where LPAR's restart but system won't restart and mftb will continue to run instead of reset.

I think we should be using sched_clock instead of mftb here. Though we need it a few more places and some cosmetic changes around it.

Note: Some values being huge exists without series for few CPUs, with series it shows up in most of the CPUs.

So I am planning send out fix below fix separately keeping your series as dependency.

---
  arch/powerpc/include/asm/accounting.h |  4 ++-- arch/powerpc/include/asm/cputime.h    | 14 +++++++------- arch/powerpc/kernel/time.c            | 22 +++++++++++-----------

  3 files changed, 20 insertions(+), 20 deletions(-)

arch/powerpc/include/asm/accounting.h +2 -2

index 6d79c31700e2..50f120646e6d 100644
@@ -21,8 +21,8 @@ struct cpu_accounting_data {
       unsigned long steal_time;
       unsigned long idle_time;
       /* Internal counters */
-    unsigned long starttime;    /* TB value snapshot */
-    unsigned long starttime_user;    /* TB value on exit to usermode */
+    unsigned long starttime;    /* Time value snapshot */
+    unsigned long starttime_user;    /* Time value on exit to 

usermode */
  #ifdef CONFIG_ARCH_HAS_SCALED_CPUTIME
      unsigned long startspurr;    /* SPURR value snapshot */ unsigned long utime_sspurr;    /* ->user_time when ->startspurr set */

arch/powerpc/include/asm/cputime.h +1 -1

index aff858ca99c0..eb6b629b113f 100644
@@ -20,9 +20,9 @@
   #include <asm/time.h>
   #include <asm/param.h>
   #include <asm/firmware.h>
+#include <linux/sched/clock.h>
 
   #ifdef __KERNEL__
-#define cputime_to_nsecs(cputime) tb_to_ns(cputime)
 
   /*
    * PPC64 uses PACA which is task independent for storing accounting data while

arch/powerpc/include/asm/cputime.h line 47

Quoted 5 lines

arch/powerpc/include/asm/cputime.h +1 -1

@@ -44,20 +44,20 @@
    */
   static notrace inline void account_cpu_user_entry(void)
   {
-    unsigned long tb = mftb();
+    unsigned long now = sched_clock();

Now way !

Quoted 2 lines

By doing that you'll kill performance for no reason. All we need when accounting time spent in kernel or in user is the difference between time at entry and time at exit, no mater what the time was at boot time.

No. With this patch there will not be any performance difference. All it does is, instead of using mftb uses sched_clock at those places.

In arch/powerpc/kernel/time.c we have sched_clock(). notrace unsigned long long sched_clock(void)
{
        return mulhdu(get_tb() - boot_tb, tb_to_ns_scale) <<
tb_to_ns_shift;
}

It does the same mftb call, and accounts only the time after boot, which is what /proc/stat should do as well.

"
the amount of time, measured in units of USER_HZ
(1/100ths of a second on most architectures

user   (1) Time spent in user mode.

idle   (4) Time spent in the idle task.  This value
       should be USER_HZ times the second entry in
       the /proc/uptime pseudo-file.
"
/proc/uptime is based on sched_clock, so i infer /proc/stat also should show values w.r.t to boot of the OS.

Quoted 1 line

Also sched_clock() returns nanoseconds which implies calculation from timebase. This is pointless CPU consumption. The current implementation calculates nanoseconds at task switch when calling vtime_flush().Your change will now do it at every kernel entry and kernel exit by calling sched_clock().

This change doesn't add any additional paths. Even without patches, mftb would have been called in every kernel entry/exit.  See mftb usage account_cpu_user_exit/enter

Now instead of mftb sched_clock is used, that's all. No additional entry/exit points. And previously when accounting we would have done cputime_to_nsecs, now that conversion is done automatically in sched_clock. So overall computation-wise it should be same.

What i am missing to see it here?

Quoted 2 lines

Another point is that sched_clock() returns a long long not a long.

Thanks for pointing that out.

Ok. Let me change some of those variables into unsigned long long. Compiler didn't warn me, so i didn't see it.

Quoted 3 lines

And also sched_clock() uses get_tb() which does mftb and mftbu. Which is pointless for calculating time deltas unless your application spends hours without being re-scheduled.

I didn't get this. At current also, we use mftb, that functionality should be the same. Could you please explain how?

Quoted 91 lines

Quoted 91 lines

arch/powerpc/include/asm/cputime.h +5 -5

       struct cpu_accounting_data *acct = raw_get_accounting(current);
 
-    acct->utime += (tb - acct->starttime_user);
-    acct->starttime = tb;
+    acct->utime += (now - acct->starttime_user);
+    acct->starttime = now;
   }
 
   static notrace inline void account_cpu_user_exit(void)
   {
-    unsigned long tb = mftb();
+    unsigned long now = sched_clock();
       struct cpu_accounting_data *acct = raw_get_accounting(current);
 
-    acct->stime += (tb - acct->starttime);
-    acct->starttime_user = tb;
+    acct->stime += (now - acct->starttime);
+    acct->starttime_user = now;
   }
 
   static notrace inline void account_stolen_time(void)

arch/powerpc/kernel/time.c +3 -3

index 18506740f4a4..fb67cdae3bcb 100644
@@ -215,7 +215,7 @@ static unsigned long vtime_delta(struct 
 cpu_accounting_data *acct,
 
       WARN_ON_ONCE(!irqs_disabled());
 
-    now = mftb();
+    now = sched_clock();
       stime = now - acct->starttime;
       acct->starttime = now;

@@ -299,9 +299,9 @@ static void vtime_flush_scaled(struct task_struct 
 *tsk,
   {
   #ifdef CONFIG_ARCH_HAS_SCALED_CPUTIME
       if (acct->utime_scaled)
-        tsk->utimescaled += cputime_to_nsecs(acct->utime_scaled);
+        tsk->utimescaled += acct->utime_scaled;
       if (acct->stime_scaled)
-        tsk->stimescaled += cputime_to_nsecs(acct->stime_scaled);
+        tsk->stimescaled += acct->stime_scaled;
 
       acct->utime_scaled = 0;

      acct->utime_sspurr = 0;

arch/powerpc/kernel/time.c +7 -7

@@ -321,28 +321,28 @@ void vtime_flush(struct task_struct *tsk)
       struct cpu_accounting_data *acct = get_accounting(tsk);
 
       if (acct->utime)
-        account_user_time(tsk, cputime_to_nsecs(acct->utime));
+        account_user_time(tsk, acct->utime);
 
       if (acct->gtime)
-        account_guest_time(tsk, cputime_to_nsecs(acct->gtime));
+        account_guest_time(tsk, acct->gtime);
 
       if (IS_ENABLED(CONFIG_PPC_SPLPAR) && acct->steal_time) {
-        account_steal_time(cputime_to_nsecs(acct->steal_time));
+        account_steal_time(acct->steal_time);
           acct->steal_time = 0;
       }
 
       if (acct->idle_time)
-        account_idle_time(cputime_to_nsecs(acct->idle_time));
+        account_idle_time(acct->idle_time);
 
       if (acct->stime)
-        account_system_index_time(tsk, cputime_to_nsecs(acct->stime),
+        account_system_index_time(tsk, acct->stime,
                         CPUTIME_SYSTEM);
 
       if (acct->hardirq_time)
-        account_system_index_time(tsk, cputime_to_nsecs(acct- 
  >hardirq_time),
+        account_system_index_time(tsk, acct->hardirq_time,
                         CPUTIME_IRQ);
       if (acct->softirq_time)
-        account_system_index_time(tsk, cputime_to_nsecs(acct- 
  >softirq_time),
+        account_system_index_time(tsk, acct->softirq_time,
                         CPUTIME_SOFTIRQ);

      vtime_flush_scaled(tsk, acct);

arch/powerpc/kernel/time.c +0 -0

@@ -388,7 +388,7 @@ void vtime_reset(void)
   {
       struct cpu_accounting_data *acct = get_accounting(current);
 

Quoted 6 lines

arch/powerpc/kernel/time.c void vtime_reset(void) · line 394

Quoted 5 lines

arch/powerpc/kernel/time.c +1 -1

-    acct->starttime = mftb();
+    acct->starttime = sched_clock();
   #ifdef CONFIG_ARCH_HAS_SCALED_CPUTIME
       acct->startspurr = read_spurr(acct->starttime);
   #endif

PS: I measured the performance with hackbench. I don't see any degradation.

Quoted 3 lines

No. With this patch there will not be any performance difference. All it does is, instead of using mftb uses sched_clock at those places.

For the record, I did some benchmark test with tools/testing/selftests/ powerpc/benchmarks/null_syscall on powerpc 885 microcontroller:

Without your proposed patch:

root@vgoip:~# ./null_syscall
    2729.98 ns     360.36 cycles

With your proposed patch below:

root@vgoip:~# ./null_syscall
    3370.80 ns     444.95 cycles

So as expected it is a huge regression, almost 25% more time to run the syscall.

Christophe

Quoted 1 line

kernel/sched/cputime.c +5 -0

+static u64 get_cpu_sleep_time_us(int cpu, enum cpu_usage_stat idx,
+				 bool compute_delta, u64 *last_update_time)
+{
+	ktime_t now = ktime_get();
+	u64 res;

The dyntick-idle cputime accounting always assumes that IRQ time accounting is enabled and consequently stops elapsing the idle time during dyntick-idle IRQs.

This doesn't mix up well with disabled IRQ time accounting because then idle IRQs become a cputime blind-spot. Also this feature is disabled on most configurations and the overhead of pausing dyntick-idle accounting while in idle IRQs could then be avoided.

Fix the situation with conditionally pausing dyntick-idle accounting during idle IRQs only if neither native vtime (which does IRQ time accounting) nor generic IRQ time accounting are enabled.

Also make sure that the accumulated IRQ time is not accidentally substracted from later accounting.

Signed-off-by Frederic Weisbecker <[email protected]>

---
  kernel/sched/cputime.c | 24 +++++++++++++++++++++---
  kernel/sched/sched.h   |  1 +
  2 files changed, 22 insertions(+), 3 deletions(-)

kernel/sched/cputime.c +0 -0

index d588a4a50e57..92fa2f037b6e 100644

kernel/sched/cputime.c +15 -0

  	u64_stats_update_end(&irqtime->sync);
  }
 

@@ -81,6 +82,16 @@ void irqtime_account_irq(struct task_struct *curr, unsigned int offset)
  		irqtime_account_delta(irqtime, delta, CPUTIME_SOFTIRQ);
  }
 
+static inline void irqtime_dyntick_start(void)
+{
+	__this_cpu_write(cpu_irqtime.idle_dyntick, true);
+}
+
+static inline void irqtime_dyntick_stop(void)
+{
+	__this_cpu_write(cpu_irqtime.idle_dyntick, false);
+}
+
  static u64 irqtime_tick_accounted(u64 maxtime)
  {
  	struct irqtime *irqtime = this_cpu_ptr(&cpu_irqtime);

@@ -94,6 +105,9 @@ static u64 irqtime_tick_accounted(u64 maxtime)
 
  #else /* !CONFIG_IRQ_TIME_ACCOUNTING: */
 
+static inline void irqtime_dyntick_start(void) { }
+static inline void irqtime_dyntick_stop(void) { }
+
  static u64 irqtime_tick_accounted(u64 dummy)
  {
  	return 0;

@@ -444,6 +458,7 @@ void kcpustat_dyntick_stop(u64 now)
  		WARN_ON_ONCE(!kc->idle_dyntick);
  		kcpustat_idle_stop(kc, now);
  		kc->idle_dyntick = false;
+		irqtime_dyntick_stop();
  		vtime_dyntick_stop();
  		steal_account_process_time(ULONG_MAX);
  	}

@@ -455,6 +470,7 @@ void kcpustat_dyntick_start(u64 now)
 
  	if (!vtime_generic_enabled_this_cpu()) {
  		vtime_dyntick_start();
+		irqtime_dyntick_start();
  		kc->idle_dyntick = true;
  		kcpustat_idle_start(kc, now);
  	}

kernel/sched/cputime.c +2 -1

@@ -472,7 +489,8 @@ void kcpustat_irq_exit(u64 now)
  {
  	struct kernel_cpustat *kc = kcpustat_this_cpu;
 
-	if (!vtime_generic_enabled_this_cpu())
+	if (!vtime_generic_enabled_this_cpu() &&
+	    (irqtime_enabled() || vtime_accounting_enabled_this_cpu()))
  		kcpustat_idle_start(kc, now);
  }
 

kernel/sched/sched.h +1 -0

index d30cca6870f5..cf677ff12b10 100644
@@ -3307,6 +3307,7 @@ static inline void sched_core_tick(struct rq *rq) { }
  #ifdef CONFIG_IRQ_TIME_ACCOUNTING
 
  struct irqtime {
+	bool			idle_dyntick;
  	u64			total;
  	u64			tick_delta;
  	u64			irq_start_time;

Hi Frederic,

Quoted 22 lines · Frederic Weisbecker

The dyntick-idle cputime accounting always assumes that IRQ time accounting is enabled and consequently stops elapsing the idle time during dyntick-idle IRQs.

This doesn't mix up well with disabled IRQ time accounting because then idle IRQs become a cputime blind-spot. Also this feature is disabled on most configurations and the overhead of pausing dyntick-idle accounting while in idle IRQs could then be avoided.

Fix the situation with conditionally pausing dyntick-idle accounting during idle IRQs only if neither native vtime (which does IRQ time accounting) nor generic IRQ time accounting are enabled.

Also make sure that the accumulated IRQ time is not accidentally substracted from later accounting.

Signed-off-by Frederic Weisbecker <[email protected]>

---
  kernel/sched/cputime.c | 24 +++++++++++++++++++++---
  kernel/sched/sched.h   |  1 +
  2 files changed, 22 insertions(+), 3 deletions(-)

kernel/sched/cputime.c static void irqtime_account_delta(struct irqtime *irqtime, u64 delta, · line 50

Quoted 11 lines

kernel/sched/cputime.c +2 -1

index d588a4a50e57..92fa2f037b6e 100644
@@ -46,7 +46,8 @@ static void irqtime_account_delta(struct irqtime *irqtime, u64 delta,
  	u64_stats_update_begin(&irqtime->sync);
  	cpustat[idx] += delta;
  	irqtime->total += delta;
-	irqtime->tick_delta += delta;
+	if (!irqtime->idle_dyntick)
+		irqtime->tick_delta += delta;

Wouldn't kcpustat_idle_dyntick achieve the same thing?

Quoted 43 lines

kernel/sched/cputime.c +15 -0

  	u64_stats_update_end(&irqtime->sync);
  }

@@ -81,6 +82,16 @@ void irqtime_account_irq(struct task_struct *curr, unsigned int offset)
  		irqtime_account_delta(irqtime, delta, CPUTIME_SOFTIRQ);
  }
+static inline void irqtime_dyntick_start(void)
+{
+	__this_cpu_write(cpu_irqtime.idle_dyntick, true);
+}
+
+static inline void irqtime_dyntick_stop(void)
+{
+	__this_cpu_write(cpu_irqtime.idle_dyntick, false);
+}
+
  static u64 irqtime_tick_accounted(u64 maxtime)
  {
  	struct irqtime *irqtime = this_cpu_ptr(&cpu_irqtime);

@@ -94,6 +105,9 @@ static u64 irqtime_tick_accounted(u64 maxtime)
  #else /* !CONFIG_IRQ_TIME_ACCOUNTING: */
+static inline void irqtime_dyntick_start(void) { }
+static inline void irqtime_dyntick_stop(void) { }
+
  static u64 irqtime_tick_accounted(u64 dummy)
  {
  	return 0;

@@ -444,6 +458,7 @@ void kcpustat_dyntick_stop(u64 now)
  		WARN_ON_ONCE(!kc->idle_dyntick);
  		kcpustat_idle_stop(kc, now);
  		kc->idle_dyntick = false;
+		irqtime_dyntick_stop();
  		vtime_dyntick_stop();
  		steal_account_process_time(ULONG_MAX);
  	}

@@ -455,6 +470,7 @@ void kcpustat_dyntick_start(u64 now)
  	if (!vtime_generic_enabled_this_cpu()) {
  		vtime_dyntick_start();
+		irqtime_dyntick_start();
  		kc->idle_dyntick = true;
  		kcpustat_idle_start(kc, now);
  	}

kernel/sched/cputime.c void kcpustat_irq_enter(u64 now) · line 485

Quoted 7 lines

kernel/sched/cputime.c +2 -1

@@ -464,7 +480,8 @@ void kcpustat_irq_enter(u64 now)
  {
  	struct kernel_cpustat *kc = kcpustat_this_cpu;
-	if (!vtime_generic_enabled_this_cpu())
+	if (!vtime_generic_enabled_this_cpu() &&
+	    (irqtime_enabled() || vtime_accounting_enabled_this_cpu()))
  		kcpustat_idle_stop(kc, now);
  }

Scenario: context_tracking is not enabled(since nohz_full or isolcpus not specified) and irqtime/native is not enabled. ( config is CONFIG_VIRT_CPU_ACCOUNTING_GEN + IRQ_TIME=n)

cpu goes into tickless mode. Gets irqs, but kcpustat_irq_enter/exit is nop. Then the time it spent in irq is still accounted for idle time, during kcpustat_dyntick_stop?

Who is going to account the irq time in this case?

The dyntick-idle steal time is currently accounted when the tick restarts but the stolen idle time is not substracted from the idle time that was already accounted. This is to avoid observing the idle time going backward as the dyntick-idle cputime accessors can't reliably know in advance the stolen idle time.

In order to maintain a forward progressing idle cputime while substracting idle steal time from it, keep track of the previously accounted idle stolen time and substract it from _later_ idle cputime accounting.

Signed-off-by Frederic Weisbecker <[email protected]>

---
  include/linux/kernel_stat.h |  1 +
  kernel/sched/cputime.c      | 21 +++++++++++++++------
  2 files changed, 16 insertions(+), 6 deletions(-)

include/linux/kernel_stat.h +1 -0

index 512104b0ff49..24a54a6151ba 100644
@@ -39,6 +39,7 @@ struct kernel_cpustat {
  	bool		idle_elapse;
  	seqcount_t	idle_sleeptime_seq;
  	u64		idle_entrytime;
+	u64		idle_stealtime;
  #endif
  	u64		cpustat[NR_STATS];
  };

kernel/sched/cputime.c +1 -1

index 92fa2f037b6e..7e79288eb327 100644
@@ -424,19 +424,25 @@ static inline void irqtime_account_process_tick(struct task_struct *p, int user_
  static void kcpustat_idle_stop(struct kernel_cpustat *kc, u64 now)
  {
  	u64 *cpustat = kc->cpustat;
-	u64 delta;
+	u64 delta, steal, steal_delta;

kernel/sched/cputime.c +11 -5

+	kc->idle_stealtime -= steal_delta;
+
  	if (nr_iowait_cpu(smp_processor_id()) > 0)
  		cpustat[CPUTIME_IOWAIT] += delta;
  	else
  		cpustat[CPUTIME_IDLE] += delta;
 
+	kc->idle_stealtime += steal;
  	kc->idle_entrytime = now;
  	kc->idle_elapse = false;
  	write_seqcount_end(&kc->idle_sleeptime_seq);

@@ -460,7 +466,6 @@ void kcpustat_dyntick_stop(u64 now)
  		kc->idle_dyntick = false;
  		irqtime_dyntick_stop();
  		vtime_dyntick_stop();
-		steal_account_process_time(ULONG_MAX);
  	}
  }
 

@@ -505,10 +510,14 @@ static u64 kcpustat_field_dyntick(int cpu, enum cpu_usage_stat idx,
  	do {
  		seq = read_seqcount_begin(&kc->idle_sleeptime_seq);
 
-		if (kc->idle_elapse && compute_delta)
-			idle = cpustat[idx] + (now - kc->idle_entrytime);
-		else
-			idle = cpustat[idx];
+		idle = cpustat[idx];
+
+		if (kc->idle_elapse && compute_delta) {
+			u64 delta = now - kc->idle_entrytime;
+
+			delta -= min_t(u64, kc->idle_stealtime, delta);
+			idle += delta;
+		}
  	} while (read_seqcount_retry(&kc->idle_sleeptime_seq, seq));
 
  	return idle;