sched/cputime: Push time to account_user_time() in nsecs

This is one more step toward converting cputime accounting to pure nsecs.

Signed-off-by: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: Fenghua Yu <fenghua.yu@intel.com>
Cc: Heiko Carstens <heiko.carstens@de.ibm.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Martin Schwidefsky <schwidefsky@de.ibm.com>
Cc: Michael Ellerman <mpe@ellerman.id.au>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Rik van Riel <riel@redhat.com>
Cc: Stanislaw Gruszka <sgruszka@redhat.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Tony Luck <tony.luck@intel.com>
Cc: Wanpeng Li <wanpeng.li@hotmail.com>
Link: http://lkml.kernel.org/r/1485832191-26889-22-git-send-email-fweisbec@gmail.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>

diff --git a/arch/ia64/kernel/time.c b/arch/ia64/kernel/time.c
index d040f12ea9f96373f21f3162f8a4b321951256b4..ed98b26047c2bba57b0733d32c8ba5e0ffb2d9a7 100644 (file)
--- a/arch/ia64/kernel/time.c
+++ b/arch/ia64/kernel/time.c
@@ -67,7 +67,7 @@ void vtime_flush(struct task_struct *tsk)
        cputime_t delta;
 
        if (ti->utime)
-               account_user_time(tsk, cycle_to_cputime(ti->utime));
+               account_user_time(tsk, cputime_to_nsecs(cycle_to_cputime(ti->utime)));
 
        if (ti->gtime)
                account_guest_time(tsk, cycle_to_cputime(ti->gtime));

diff --git a/arch/powerpc/kernel/time.c b/arch/powerpc/kernel/time.c
index 3cca82e065c96ba99e25e32a13ec37e9fac05027..c3931d8161900fb5701a8bfcde1f4df120f8bf62 100644 (file)
--- a/arch/powerpc/kernel/time.c
+++ b/arch/powerpc/kernel/time.c
@@ -393,7 +393,7 @@ void vtime_flush(struct task_struct *tsk)
        struct cpu_accounting_data *acct = get_accounting(tsk);
 
        if (acct->utime)
-               account_user_time(tsk, acct->utime);
+               account_user_time(tsk, cputime_to_nsecs(acct->utime));
 
        if (acct->utime_scaled)
                tsk->utimescaled += cputime_to_nsecs(acct->utime_scaled);

diff --git a/arch/s390/kernel/vtime.c b/arch/s390/kernel/vtime.c
index f2fc27491604f8a445e908faf11dcdc77d34b156..ca206d1223025d3344f308ec5e86092db3266318 100644 (file)
--- a/arch/s390/kernel/vtime.c
+++ b/arch/s390/kernel/vtime.c
@@ -166,7 +166,7 @@ static int do_account_vtime(struct task_struct *tsk)
 
        /* Push account value */
        if (user) {
-               account_user_time(tsk, user);
+               account_user_time(tsk, cputime_to_nsecs(user));
                tsk->utimescaled += cputime_to_nsecs(scale_vtime(user));
        }
 

diff --git a/include/linux/kernel_stat.h b/include/linux/kernel_stat.h
index c3e38ded2d73451485e99b228d021563f7394660..b716001ac23e2ad4bd990df01d6f2cfc7a6c8c5b 100644 (file)
--- a/include/linux/kernel_stat.h
+++ b/include/linux/kernel_stat.h
@@ -78,7 +78,7 @@ static inline unsigned int kstat_cpu_irqs_sum(unsigned int cpu)
        return kstat_cpu(cpu).irqs_sum;
 }
 
-extern void account_user_time(struct task_struct *, cputime_t);
+extern void account_user_time(struct task_struct *, u64);
 extern void account_guest_time(struct task_struct *, cputime_t);
 extern void account_system_time(struct task_struct *, int, cputime_t);
 extern void account_system_index_time(struct task_struct *, cputime_t,

diff --git a/kernel/sched/cputime.c b/kernel/sched/cputime.c
index f7b9624c7df0941d9426d7e1d40b423f2b534b40..55d31c35833afa2de918d1d87a83d80db5d5f9aa 100644 (file)
--- a/kernel/sched/cputime.c
+++ b/kernel/sched/cputime.c
@@ -116,18 +116,18 @@ static inline void task_group_account_field(struct task_struct *p, int index,
  * @p: the process that the cpu time gets accounted to
  * @cputime: the cpu time spent in user space since the last update
  */
-void account_user_time(struct task_struct *p, cputime_t cputime)
+void account_user_time(struct task_struct *p, u64 cputime)
 {
        int index;
 
        /* Add user time to process. */
-       p->utime += cputime_to_nsecs(cputime);
-       account_group_user_time(p, cputime_to_nsecs(cputime));
+       p->utime += cputime;
+       account_group_user_time(p, cputime);
 
        index = (task_nice(p) > 0) ? CPUTIME_NICE : CPUTIME_USER;
 
        /* Add user time to cpustat. */
-       task_group_account_field(p, index, cputime_to_nsecs(cputime));
+       task_group_account_field(p, index, cputime);
 
        /* Account for user time used */
        acct_account_cputime(p);
@@ -363,8 +363,9 @@ void thread_group_cputime(struct task_struct *tsk, struct task_cputime *times)
 static void irqtime_account_process_tick(struct task_struct *p, int user_tick,
                                         struct rq *rq, int ticks)
 {
-       u64 cputime = (__force u64) cputime_one_jiffy * ticks;
+       u64 old_cputime = (__force u64) cputime_one_jiffy * ticks;
        cputime_t other;
+       u64 cputime;
 
        /*
         * When returning from idle, many ticks can get accounted at
@@ -374,9 +375,11 @@ static void irqtime_account_process_tick(struct task_struct *p, int user_tick,
         * other time can exceed ticks occasionally.
         */
        other = account_other_time(ULONG_MAX);
-       if (other >= cputime)
+       if (other >= old_cputime)
                return;
-       cputime -= other;
+
+       old_cputime -= other;
+       cputime = cputime_to_nsecs(old_cputime);
 
        if (this_cpu_ksoftirqd() == p) {
                /*
@@ -384,15 +387,16 @@ static void irqtime_account_process_tick(struct task_struct *p, int user_tick,
                 * So, we have to handle it separately here.
                 * Also, p->stime needs to be updated for ksoftirqd.
                 */
-               account_system_index_time(p, cputime, CPUTIME_SOFTIRQ);
+               account_system_index_time(p, old_cputime, CPUTIME_SOFTIRQ);
        } else if (user_tick) {
                account_user_time(p, cputime);
        } else if (p == rq->idle) {
-               account_idle_time(cputime);
+               account_idle_time(old_cputime);
        } else if (p->flags & PF_VCPU) { /* System time or guest time */
-               account_guest_time(p, cputime);
+
+               account_guest_time(p, old_cputime);
        } else {
-               account_system_index_time(p, cputime, CPUTIME_SYSTEM);
+               account_system_index_time(p, old_cputime, CPUTIME_SYSTEM);
        }
 }
 
@@ -473,7 +477,8 @@ void thread_group_cputime_adjusted(struct task_struct *p, u64 *ut, u64 *st)
  */
 void account_process_tick(struct task_struct *p, int user_tick)
 {
-       cputime_t cputime, steal;
+       cputime_t old_cputime, steal;
+       u64 cputime;
        struct rq *rq = this_rq();
 
        if (vtime_accounting_cpu_enabled())
@@ -484,20 +489,21 @@ void account_process_tick(struct task_struct *p, int user_tick)
                return;
        }
 
-       cputime = cputime_one_jiffy;
+       old_cputime = cputime_one_jiffy;
        steal = steal_account_process_time(ULONG_MAX);
 
-       if (steal >= cputime)
+       if (steal >= old_cputime)
                return;
 
-       cputime -= steal;
+       old_cputime -= steal;
+       cputime = cputime_to_nsecs(old_cputime);
 
        if (user_tick)
                account_user_time(p, cputime);
        else if ((p != rq->idle) || (irq_count() != HARDIRQ_OFFSET))
-               account_system_time(p, HARDIRQ_OFFSET, cputime);
+               account_system_time(p, HARDIRQ_OFFSET, old_cputime);
        else
-               account_idle_time(cputime);
+               account_idle_time(old_cputime);
 }
 
 /*
@@ -736,7 +742,7 @@ void vtime_account_user(struct task_struct *tsk)
        tsk->vtime_snap_whence = VTIME_SYS;
        if (vtime_delta(tsk)) {
                delta_cpu = get_vtime_delta(tsk);
-               account_user_time(tsk, delta_cpu);
+               account_user_time(tsk, cputime_to_nsecs(delta_cpu));
        }
        write_seqcount_end(&tsk->vtime_seqcount);
 }