sched/cputime: Introduce special task_cputime_t() API to return old-typed cputime

This API returns a task's cputime in cputime_t in order to ease the
conversion of cputime internals to use nsecs units instead. Blindly
converting all cputime readers to use this API now will later let us
convert more smoothly and step by step all these places to use the
new nsec based cputime.

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-7-git-send-email-fweisbec@gmail.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>

diff --git a/arch/alpha/kernel/osf_sys.c b/arch/alpha/kernel/osf_sys.c
index 54d8616644e2dfd510846b30b52e2b7e21c1c888..0f92438d736b0d794955d4765d894d55f5d32976 100644 (file)
--- a/arch/alpha/kernel/osf_sys.c
+++ b/arch/alpha/kernel/osf_sys.c
@@ -1154,7 +1154,7 @@ SYSCALL_DEFINE2(osf_getrusage, int, who, struct rusage32 __user *, ru)
        memset(&r, 0, sizeof(r));
        switch (who) {
        case RUSAGE_SELF:
-               task_cputime(current, &utime, &stime);
+               task_cputime_t(current, &utime, &stime);
                utime_jiffies = cputime_to_jiffies(utime);
                stime_jiffies = cputime_to_jiffies(stime);
                jiffies_to_timeval32(utime_jiffies, &r.ru_utime);

diff --git a/arch/x86/kernel/apm_32.c b/arch/x86/kernel/apm_32.c
index 45d44c173cf9e125df6f6b4bf9ae50d6ad19f393..89c84fcdd3c072d936d3094ada4e802c23c1f2a8 100644 (file)
--- a/arch/x86/kernel/apm_32.c
+++ b/arch/x86/kernel/apm_32.c
@@ -913,7 +913,7 @@ static int apm_cpu_idle(struct cpuidle_device *dev,
        unsigned int bucket;
 
 recalc:
-       task_cputime(current, &utime, &stime);
+       task_cputime_t(current, &utime, &stime);
        if (jiffies_since_last_check > IDLE_CALC_LIMIT) {
                use_apm_idle = 0;
        } else if (jiffies_since_last_check > idle_period) {

diff --git a/drivers/isdn/mISDN/stack.c b/drivers/isdn/mISDN/stack.c
index 9cb4b621fbc3cffe0bceb770bde7dbdac292dd95..0a366176753107db7ee0b6e2e556e4ce501937a9 100644 (file)
--- a/drivers/isdn/mISDN/stack.c
+++ b/drivers/isdn/mISDN/stack.c
@@ -306,7 +306,7 @@ mISDNStackd(void *data)
               "msg %d sleep %d stopped\n",
               dev_name(&st->dev->dev), st->msg_cnt, st->sleep_cnt,
               st->stopped_cnt);
-       task_cputime(st->thread, &utime, &stime);
+       task_cputime_t(st->thread, &utime, &stime);
        printk(KERN_DEBUG
               "mISDNStackd daemon for %s utime(%ld) stime(%ld)\n",
               dev_name(&st->dev->dev), utime, stime);

diff --git a/fs/binfmt_elf.c b/fs/binfmt_elf.c
index 422370293cfd8cfc9b0f527f73498ce7c28244be..68b915650cae76fa3bd14774d7dd39c7ab23d78a 100644 (file)
--- a/fs/binfmt_elf.c
+++ b/fs/binfmt_elf.c
@@ -1421,19 +1421,19 @@ static void fill_prstatus(struct elf_prstatus *prstatus,
        prstatus->pr_pgrp = task_pgrp_vnr(p);
        prstatus->pr_sid = task_session_vnr(p);
        if (thread_group_leader(p)) {
-               struct task_cputime cputime;
+               struct task_cputime_t cputime;
 
                /*
                 * This is the record for the group leader.  It shows the
                 * group-wide total, not its individual thread total.
                 */
-               thread_group_cputime(p, &cputime);
+               thread_group_cputime_t(p, &cputime);
                cputime_to_timeval(cputime.utime, &prstatus->pr_utime);
                cputime_to_timeval(cputime.stime, &prstatus->pr_stime);
        } else {
                cputime_t utime, stime;
 
-               task_cputime(p, &utime, &stime);
+               task_cputime_t(p, &utime, &stime);
                cputime_to_timeval(utime, &prstatus->pr_utime);
                cputime_to_timeval(stime, &prstatus->pr_stime);
        }

diff --git a/fs/binfmt_elf_fdpic.c b/fs/binfmt_elf_fdpic.c
index d2e36f82c35d3ac5d96e00b22392926bdd1990e9..6ccd9df7247ae32b63cf8bba905f2ba9dfd5816c 100644 (file)
--- a/fs/binfmt_elf_fdpic.c
+++ b/fs/binfmt_elf_fdpic.c
@@ -1342,19 +1342,19 @@ static void fill_prstatus(struct elf_prstatus *prstatus,
        prstatus->pr_pgrp = task_pgrp_vnr(p);
        prstatus->pr_sid = task_session_vnr(p);
        if (thread_group_leader(p)) {
-               struct task_cputime cputime;
+               struct task_cputime_t cputime;
 
                /*
                 * This is the record for the group leader.  It shows the
                 * group-wide total, not its individual thread total.
                 */
-               thread_group_cputime(p, &cputime);
+               thread_group_cputime_t(p, &cputime);
                cputime_to_timeval(cputime.utime, &prstatus->pr_utime);
                cputime_to_timeval(cputime.stime, &prstatus->pr_stime);
        } else {
                cputime_t utime, stime;
 
-               task_cputime(p, &utime, &stime);
+               task_cputime_t(p, &utime, &stime);
                cputime_to_timeval(utime, &prstatus->pr_utime);
                cputime_to_timeval(stime, &prstatus->pr_stime);
        }

diff --git a/include/linux/sched.h b/include/linux/sched.h
index 252ff25983c82d938df976f2758d3a3fab508a24..9cc722f77799c77bf18321c07c4b9d750b9e0dc0 100644 (file)
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -615,6 +615,13 @@ struct task_cputime {
        unsigned long long sum_exec_runtime;
 };
 
+/* Temporary type to ease cputime_t to nsecs conversion */
+struct task_cputime_t {
+       cputime_t utime;
+       cputime_t stime;
+       unsigned long long sum_exec_runtime;
+};
+
 /* Alternate field names when used to cache expirations. */
 #define virt_exp       utime
 #define prof_exp       stime
@@ -748,7 +755,7 @@ struct signal_struct {
        struct thread_group_cputimer cputimer;
 
        /* Earliest-expiration cache. */
-       struct task_cputime cputime_expires;
+       struct task_cputime_t cputime_expires;
 
 #ifdef CONFIG_NO_HZ_FULL
        atomic_t tick_dep_mask;
@@ -1682,7 +1689,7 @@ struct task_struct {
 /* mm fault and swap info: this can arguably be seen as either mm-specific or thread-specific */
        unsigned long min_flt, maj_flt;
 
-       struct task_cputime cputime_expires;
+       struct task_cputime_t cputime_expires;
        struct list_head cpu_timers[3];
 
 /* process credentials */
@@ -2286,6 +2293,19 @@ static inline void task_cputime_scaled(struct task_struct *t,
 }
 #endif
 
+static inline void task_cputime_t(struct task_struct *t,
+                                 cputime_t *utime, cputime_t *stime)
+{
+       task_cputime(t, utime, stime);
+}
+
+static inline void task_cputime_t_scaled(struct task_struct *t,
+                                        cputime_t *utimescaled,
+                                        cputime_t *stimescaled)
+{
+       task_cputime_scaled(t, utimescaled, stimescaled);
+}
+
 extern void task_cputime_adjusted(struct task_struct *p, cputime_t *ut, cputime_t *st);
 extern void thread_group_cputime_adjusted(struct task_struct *p, cputime_t *ut, cputime_t *st);
 
@@ -3499,7 +3519,13 @@ static __always_inline bool need_resched(void)
  * Thread group CPU time accounting.
  */
 void thread_group_cputime(struct task_struct *tsk, struct task_cputime *times);
-void thread_group_cputimer(struct task_struct *tsk, struct task_cputime *times);
+void thread_group_cputimer(struct task_struct *tsk, struct task_cputime_t *times);
+
+static inline void thread_group_cputime_t(struct task_struct *tsk,
+                                         struct task_cputime_t *times)
+{
+       thread_group_cputime(tsk, (struct task_cputime *)times);
+}
 
 /*
  * Reevaluate whether the task has signals pending delivery.

diff --git a/kernel/acct.c b/kernel/acct.c
index 74963d192c5d96ce3674f0adbf554c95af4867ec..b9b190a8eecf084968a7c7628897eccd7cae1ea6 100644 (file)
--- a/kernel/acct.c
+++ b/kernel/acct.c
@@ -559,7 +559,7 @@ void acct_collect(long exitcode, int group_dead)
                pacct->ac_flag |= ACORE;
        if (current->flags & PF_SIGNALED)
                pacct->ac_flag |= AXSIG;
-       task_cputime(current, &utime, &stime);
+       task_cputime_t(current, &utime, &stime);
        pacct->ac_utime += utime;
        pacct->ac_stime += stime;
        pacct->ac_minflt += current->min_flt;

diff --git a/kernel/delayacct.c b/kernel/delayacct.c
index 435c14a451181c7a69fb49d513d5d659cd75e814..228640f2b3d25204ca4c0b93af21e21b08316170 100644 (file)
--- a/kernel/delayacct.c
+++ b/kernel/delayacct.c
@@ -87,12 +87,12 @@ int __delayacct_add_tsk(struct taskstats *d, struct task_struct *tsk)
        unsigned long flags, t1;
        s64 tmp;
 
-       task_cputime(tsk, &utime, &stime);
+       task_cputime_t(tsk, &utime, &stime);
        tmp = (s64)d->cpu_run_real_total;
        tmp += cputime_to_nsecs(utime + stime);
        d->cpu_run_real_total = (tmp < (s64)d->cpu_run_real_total) ? 0 : tmp;
 
-       task_cputime_scaled(tsk, &utimescaled, &stimescaled);
+       task_cputime_t_scaled(tsk, &utimescaled, &stimescaled);
        tmp = (s64)d->cpu_scaled_run_real_total;
        tmp += cputime_to_nsecs(utimescaled + stimescaled);
        d->cpu_scaled_run_real_total =

diff --git a/kernel/signal.c b/kernel/signal.c
index 3603d93a19689be7188a004f2b999b27e0ebdf2f..218048a837ea53747e602dee1f74bc9697b0aca9 100644 (file)
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -1619,7 +1619,7 @@ bool do_notify_parent(struct task_struct *tsk, int sig)
                                       task_uid(tsk));
        rcu_read_unlock();
 
-       task_cputime(tsk, &utime, &stime);
+       task_cputime_t(tsk, &utime, &stime);
        info.si_utime = cputime_to_clock_t(utime + tsk->signal->utime);
        info.si_stime = cputime_to_clock_t(stime + tsk->signal->stime);
 
@@ -1704,7 +1704,7 @@ static void do_notify_parent_cldstop(struct task_struct *tsk,
        info.si_uid = from_kuid_munged(task_cred_xxx(parent, user_ns), task_uid(tsk));
        rcu_read_unlock();
 
-       task_cputime(tsk, &utime, &stime);
+       task_cputime_t(tsk, &utime, &stime);
        info.si_utime = cputime_to_clock_t(utime);
        info.si_stime = cputime_to_clock_t(stime);
 

diff --git a/kernel/time/itimer.c b/kernel/time/itimer.c
index 8c89143f9ebf19fb96ac47b9c22be08fbafdc583..f2d5097bcb6d9078cd650dc5686a4ba9a6307c0a 100644 (file)
--- a/kernel/time/itimer.c
+++ b/kernel/time/itimer.c
@@ -53,7 +53,7 @@ static void get_cpu_itimer(struct task_struct *tsk, unsigned int clock_id,
        cval = it->expires;
        cinterval = it->incr;
        if (cval) {
-               struct task_cputime cputime;
+               struct task_cputime_t cputime;
                cputime_t t;
 
                thread_group_cputimer(tsk, &cputime);

diff --git a/kernel/time/posix-cpu-timers.c b/kernel/time/posix-cpu-timers.c
index e9e8c10f0d9abc351ce78025c3719a98b64c9e53..d53ff711a2a87d24077d71f7ab2b19d74c097713 100644 (file)
--- a/kernel/time/posix-cpu-timers.c
+++ b/kernel/time/posix-cpu-timers.c
@@ -115,7 +115,7 @@ static void bump_cpu_timer(struct k_itimer *timer,
  * Checks @cputime to see if all fields are zero.  Returns true if all fields
  * are zero, false if any field is nonzero.
  */
-static inline int task_cputime_zero(const struct task_cputime *cputime)
+static inline int task_cputime_zero(const struct task_cputime_t *cputime)
 {
        if (!cputime->utime && !cputime->stime && !cputime->sum_exec_runtime)
                return 1;
@@ -126,7 +126,7 @@ static inline unsigned long long prof_ticks(struct task_struct *p)
 {
        cputime_t utime, stime;
 
-       task_cputime(p, &utime, &stime);
+       task_cputime_t(p, &utime, &stime);
 
        return cputime_to_expires(utime + stime);
 }
@@ -134,7 +134,7 @@ static inline unsigned long long virt_ticks(struct task_struct *p)
 {
        cputime_t utime, stime;
 
-       task_cputime(p, &utime, &stime);
+       task_cputime_t(p, &utime, &stime);
 
        return cputime_to_expires(utime);
 }
@@ -210,7 +210,7 @@ retry:
        }
 }
 
-static void update_gt_cputime(struct task_cputime_atomic *cputime_atomic, struct task_cputime *sum)
+static void update_gt_cputime(struct task_cputime_atomic *cputime_atomic, struct task_cputime_t *sum)
 {
        __update_gt_cputime(&cputime_atomic->utime, sum->utime);
        __update_gt_cputime(&cputime_atomic->stime, sum->stime);
@@ -218,7 +218,7 @@ static void update_gt_cputime(struct task_cputime_atomic *cputime_atomic, struct
 }
 
 /* Sample task_cputime_atomic values in "atomic_timers", store results in "times". */
-static inline void sample_cputime_atomic(struct task_cputime *times,
+static inline void sample_cputime_atomic(struct task_cputime_t *times,
                                         struct task_cputime_atomic *atomic_times)
 {
        times->utime = atomic64_read(&atomic_times->utime);
@@ -226,10 +226,10 @@ static inline void sample_cputime_atomic(struct task_cputime *times,
        times->sum_exec_runtime = atomic64_read(&atomic_times->sum_exec_runtime);
 }
 
-void thread_group_cputimer(struct task_struct *tsk, struct task_cputime *times)
+void thread_group_cputimer(struct task_struct *tsk, struct task_cputime_t *times)
 {
        struct thread_group_cputimer *cputimer = &tsk->signal->cputimer;
-       struct task_cputime sum;
+       struct task_cputime_t sum;
 
        /* Check if cputimer isn't running. This is accessed without locking. */
        if (!READ_ONCE(cputimer->running)) {
@@ -238,7 +238,7 @@ void thread_group_cputimer(struct task_struct *tsk, struct task_cputime *times)
                 * values through the TIMER_ABSTIME flag, therefore we have
                 * to synchronize the timer to the clock every time we start it.
                 */
-               thread_group_cputime(tsk, &sum);
+               thread_group_cputime_t(tsk, &sum);
                update_gt_cputime(&cputimer->cputime_atomic, &sum);
 
                /*
@@ -262,21 +262,21 @@ static int cpu_clock_sample_group(const clockid_t which_clock,
                                  struct task_struct *p,
                                  unsigned long long *sample)
 {
-       struct task_cputime cputime;
+       struct task_cputime_t cputime;
 
        switch (CPUCLOCK_WHICH(which_clock)) {
        default:
                return -EINVAL;
        case CPUCLOCK_PROF:
-               thread_group_cputime(p, &cputime);
+               thread_group_cputime_t(p, &cputime);
                *sample = cputime_to_expires(cputime.utime + cputime.stime);
                break;
        case CPUCLOCK_VIRT:
-               thread_group_cputime(p, &cputime);
+               thread_group_cputime_t(p, &cputime);
                *sample = cputime_to_expires(cputime.utime);
                break;
        case CPUCLOCK_SCHED:
-               thread_group_cputime(p, &cputime);
+               thread_group_cputime_t(p, &cputime);
                *sample = cputime.sum_exec_runtime;
                break;
        }
@@ -466,7 +466,7 @@ static void arm_timer(struct k_itimer *timer)
 {
        struct task_struct *p = timer->it.cpu.task;
        struct list_head *head, *listpos;
-       struct task_cputime *cputime_expires;
+       struct task_cputime_t *cputime_expires;
        struct cpu_timer_list *const nt = &timer->it.cpu;
        struct cpu_timer_list *next;
 
@@ -562,7 +562,7 @@ static int cpu_timer_sample_group(const clockid_t which_clock,
                                  struct task_struct *p,
                                  unsigned long long *sample)
 {
-       struct task_cputime cputime;
+       struct task_cputime_t cputime;
 
        thread_group_cputimer(p, &cputime);
        switch (CPUCLOCK_WHICH(which_clock)) {
@@ -761,7 +761,7 @@ static void posix_cpu_timer_get(struct k_itimer *timer, struct itimerspec *itp)
                /*
                 * Protect against sighand release/switch in exit/exec and
                 * also make timer sampling safe if it ends up calling
-                * thread_group_cputime().
+                * thread_group_cputime_t().
                 */
                sighand = lock_task_sighand(p, &flags);
                if (unlikely(sighand == NULL)) {
@@ -826,7 +826,7 @@ static void check_thread_timers(struct task_struct *tsk,
 {
        struct list_head *timers = tsk->cpu_timers;
        struct signal_struct *const sig = tsk->signal;
-       struct task_cputime *tsk_expires = &tsk->cputime_expires;
+       struct task_cputime_t *tsk_expires = &tsk->cputime_expires;
        unsigned long long expires;
        unsigned long soft;
 
@@ -934,7 +934,7 @@ static void check_process_timers(struct task_struct *tsk,
        unsigned long long utime, ptime, virt_expires, prof_expires;
        unsigned long long sum_sched_runtime, sched_expires;
        struct list_head *timers = sig->cpu_timers;
-       struct task_cputime cputime;
+       struct task_cputime_t cputime;
        unsigned long soft;
 
        /*
@@ -1037,7 +1037,7 @@ void posix_cpu_timer_schedule(struct k_itimer *timer)
        } else {
                /*
                 * Protect arm_timer() and timer sampling in case of call to
-                * thread_group_cputime().
+                * thread_group_cputime_t().
                 */
                sighand = lock_task_sighand(p, &flags);
                if (unlikely(sighand == NULL)) {
@@ -1080,8 +1080,8 @@ out:
  * Returns true if any field of the former is greater than the corresponding
  * field of the latter if the latter field is set.  Otherwise returns false.
  */
-static inline int task_cputime_expired(const struct task_cputime *sample,
-                                       const struct task_cputime *expires)
+static inline int task_cputime_expired(const struct task_cputime_t *sample,
+                                       const struct task_cputime_t *expires)
 {
        if (expires->utime && sample->utime >= expires->utime)
                return 1;
@@ -1108,9 +1108,9 @@ static inline int fastpath_timer_check(struct task_struct *tsk)
        struct signal_struct *sig;
 
        if (!task_cputime_zero(&tsk->cputime_expires)) {
-               struct task_cputime task_sample;
+               struct task_cputime_t task_sample;
 
-               task_cputime(tsk, &task_sample.utime, &task_sample.stime);
+               task_cputime_t(tsk, &task_sample.utime, &task_sample.stime);
                task_sample.sum_exec_runtime = tsk->se.sum_exec_runtime;
                if (task_cputime_expired(&task_sample, &tsk->cputime_expires))
                        return 1;
@@ -1133,7 +1133,7 @@ static inline int fastpath_timer_check(struct task_struct *tsk)
         */
        if (READ_ONCE(sig->cputimer.running) &&
            !READ_ONCE(sig->cputimer.checking_timer)) {
-               struct task_cputime group_sample;
+               struct task_cputime_t group_sample;
 
                sample_cputime_atomic(&group_sample, &sig->cputimer.cputime_atomic);
 

diff --git a/kernel/tsacct.c b/kernel/tsacct.c
index f8e26ab963ed2fc057db395bee59d6f25307b5d5..040d0a64d0d1849ad06beb0846cfd8aedea90975 100644 (file)
--- a/kernel/tsacct.c
+++ b/kernel/tsacct.c
@@ -66,11 +66,11 @@ void bacct_add_tsk(struct user_namespace *user_ns,
                task_tgid_nr_ns(rcu_dereference(tsk->real_parent), pid_ns) : 0;
        rcu_read_unlock();
 
-       task_cputime(tsk, &utime, &stime);
+       task_cputime_t(tsk, &utime, &stime);
        stats->ac_utime = cputime_to_usecs(utime);
        stats->ac_stime = cputime_to_usecs(stime);
 
-       task_cputime_scaled(tsk, &utimescaled, &stimescaled);
+       task_cputime_t_scaled(tsk, &utimescaled, &stimescaled);
        stats->ac_utimescaled = cputime_to_usecs(utimescaled);
        stats->ac_stimescaled = cputime_to_usecs(stimescaled);
 
@@ -159,7 +159,7 @@ void acct_update_integrals(struct task_struct *tsk)
        unsigned long flags;
 
        local_irq_save(flags);
-       task_cputime(tsk, &utime, &stime);
+       task_cputime_t(tsk, &utime, &stime);
        __acct_update_integrals(tsk, utime, stime);
        local_irq_restore(flags);
 }