posix-cpu-timers: Switch thread group sampling to array

That allows more simplifications in various places.

Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Reviewed-by: Frederic Weisbecker <frederic@kernel.org>
Link: https://lkml.kernel.org/r/20190821192921.988426956@linutronix.de

diff --git a/include/linux/sched/cputime.h b/include/linux/sched/cputime.h
index 2638fd0ab3f273643fcadb14a751d469a4b1f7c1..eefa5dff16b4ac5df3c859a495ff550bae0d5b03 100644 (file)
--- a/include/linux/sched/cputime.h
+++ b/include/linux/sched/cputime.h
@@ -61,7 +61,7 @@ extern void cputime_adjust(struct task_cputime *curr, struct prev_cputime *prev,
  * Thread group CPU time accounting.
  */
 void thread_group_cputime(struct task_struct *tsk, struct task_cputime *times);
-void thread_group_sample_cputime(struct task_struct *tsk, struct task_cputime *times);
+void thread_group_sample_cputime(struct task_struct *tsk, u64 *samples);
 
 /*
  * The following are functions that support scheduler-internal time accounting.

diff --git a/kernel/time/itimer.c b/kernel/time/itimer.c
index ae04bc259240d2576a6fb91b91b137f685d8b7a1..77f1e5635cc18829d5cc68d176fb334a1ba107c5 100644 (file)
--- a/kernel/time/itimer.c
+++ b/kernel/time/itimer.c
@@ -55,15 +55,10 @@ static void get_cpu_itimer(struct task_struct *tsk, unsigned int clock_id,
        val = it->expires;
        interval = it->incr;
        if (val) {
-               struct task_cputime cputime;
-               u64 t;
+               u64 t, samples[CPUCLOCK_MAX];
 
-               thread_group_sample_cputime(tsk, &cputime);
-               if (clock_id == CPUCLOCK_PROF)
-                       t = cputime.utime + cputime.stime;
-               else
-                       /* CPUCLOCK_VIRT */
-                       t = cputime.utime;
+               thread_group_sample_cputime(tsk, samples);
+               t = samples[clock_id];
 
                if (val < t)
                        /* about to fire */

diff --git a/kernel/time/posix-cpu-timers.c b/kernel/time/posix-cpu-timers.c
index 9ac601abc4c4904a4f1853b6bf2d5811adebd174..e62139a89375720bd4e82cfb7256afbb925acb2e 100644 (file)
--- a/kernel/time/posix-cpu-timers.c
+++ b/kernel/time/posix-cpu-timers.c
@@ -225,22 +225,14 @@ 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 *sum)
 {
        __update_gt_cputime(&cputime_atomic->utime, sum->utime);
        __update_gt_cputime(&cputime_atomic->stime, sum->stime);
        __update_gt_cputime(&cputime_atomic->sum_exec_runtime, sum->sum_exec_runtime);
 }
 
-/* Sample task_cputime_atomic values in "atomic_timers", store results in "times". */
-static inline void sample_cputime_atomic(struct task_cputime *times,
-                                        struct task_cputime_atomic *atomic_times)
-{
-       times->utime = atomic64_read(&atomic_times->utime);
-       times->stime = atomic64_read(&atomic_times->stime);
-       times->sum_exec_runtime = atomic64_read(&atomic_times->sum_exec_runtime);
-}
-
 /**
  * thread_group_sample_cputime - Sample cputime for a given task
  * @tsk:       Task for which cputime needs to be started
@@ -252,20 +244,19 @@ static inline void sample_cputime_atomic(struct task_cputime *times,
  *
  * Updates @times with an uptodate sample of the thread group cputimes.
  */
-void thread_group_sample_cputime(struct task_struct *tsk,
-                               struct task_cputime *times)
+void thread_group_sample_cputime(struct task_struct *tsk, u64 *samples)
 {
        struct thread_group_cputimer *cputimer = &tsk->signal->cputimer;
 
        WARN_ON_ONCE(!cputimer->running);
 
-       sample_cputime_atomic(times, &cputimer->cputime_atomic);
+       proc_sample_cputime_atomic(&cputimer->cputime_atomic, samples);
 }
 
 /**
  * thread_group_start_cputime - Start cputime and return a sample
  * @tsk:       Task for which cputime needs to be started
- * @iimes:     Storage for time samples
+ * @samples:   Storage for time samples
  *
  * The thread group cputime accouting is avoided when there are no posix
  * CPU timers armed. Before starting a timer it's required to check whether
@@ -274,14 +265,14 @@ void thread_group_sample_cputime(struct task_struct *tsk,
  *
  * Updates @times with an uptodate sample of the thread group cputimes.
  */
-static void
-thread_group_start_cputime(struct task_struct *tsk, struct task_cputime *times)
+static void thread_group_start_cputime(struct task_struct *tsk, u64 *samples)
 {
        struct thread_group_cputimer *cputimer = &tsk->signal->cputimer;
-       struct task_cputime sum;
 
        /* Check if cputimer isn't running. This is accessed without locking. */
        if (!READ_ONCE(cputimer->running)) {
+               struct task_cputime sum;
+
                /*
                 * The POSIX timer interface allows for absolute time expiry
                 * values through the TIMER_ABSTIME flag, therefore we have
@@ -299,7 +290,15 @@ thread_group_start_cputime(struct task_struct *tsk, struct task_cputime *times)
                 */
                WRITE_ONCE(cputimer->running, true);
        }
-       sample_cputime_atomic(times, &cputimer->cputime_atomic);
+       proc_sample_cputime_atomic(&cputimer->cputime_atomic, samples);
+}
+
+static void __thread_group_cputime(struct task_struct *tsk, u64 *samples)
+{
+       struct task_cputime ct;
+
+       thread_group_cputime(tsk, &ct);
+       store_samples(samples, ct.stime, ct.utime, ct.sum_exec_runtime);
 }
 
 /*
@@ -313,28 +312,18 @@ static u64 cpu_clock_sample_group(const clockid_t clkid, struct task_struct *p,
                                  bool start)
 {
        struct thread_group_cputimer *cputimer = &p->signal->cputimer;
-       struct task_cputime cputime;
+       u64 samples[CPUCLOCK_MAX];
 
        if (!READ_ONCE(cputimer->running)) {
                if (start)
-                       thread_group_start_cputime(p, &cputime);
+                       thread_group_start_cputime(p, samples);
                else
-                       thread_group_cputime(p, &cputime);
+                       __thread_group_cputime(p, samples);
        } else {
-               sample_cputime_atomic(&cputime, &cputimer->cputime_atomic);
+               proc_sample_cputime_atomic(&cputimer->cputime_atomic, samples);
        }
 
-       switch (clkid) {
-       case CPUCLOCK_PROF:
-               return cputime.utime + cputime.stime;
-       case CPUCLOCK_VIRT:
-               return cputime.utime;
-       case CPUCLOCK_SCHED:
-               return cputime.sum_exec_runtime;
-       default:
-               WARN_ON_ONCE(1);
-       }
-       return 0;
+       return samples[clkid];
 }
 
 static int posix_cpu_clock_get(const clockid_t clock, struct timespec64 *tp)
@@ -889,9 +878,7 @@ static void check_process_timers(struct task_struct *tsk,
 {
        struct signal_struct *const sig = tsk->signal;
        struct posix_cputimer_base *base = sig->posix_cputimers.bases;
-       u64 utime, ptime, virt_expires, prof_expires;
-       u64 sum_sched_runtime, sched_expires;
-       struct task_cputime cputime;
+       u64 virt_exp, prof_exp, sched_exp, samples[CPUCLOCK_MAX];
        unsigned long soft;
 
        /*
@@ -911,30 +898,29 @@ static void check_process_timers(struct task_struct *tsk,
         * Collect the current process totals. Group accounting is active
         * so the sample can be taken directly.
         */
-       sample_cputime_atomic(&cputime, &sig->cputimer.cputime_atomic);
-       utime = cputime.utime;
-       ptime = utime + cputime.stime;
-       sum_sched_runtime = cputime.sum_exec_runtime;
-
-       prof_expires = check_timers_list(&base[CPUCLOCK_PROF].cpu_timers,
-                                        firing, ptime);
-       virt_expires = check_timers_list(&base[CPUCLOCK_VIRT].cpu_timers,
-                                        firing, utime);
-       sched_expires = check_timers_list(&base[CPUCLOCK_SCHED].cpu_timers,
-                                         firing, sum_sched_runtime);
+       proc_sample_cputime_atomic(&sig->cputimer.cputime_atomic, samples);
+
+       prof_exp = check_timers_list(&base[CPUCLOCK_PROF].cpu_timers,
+                                    firing, samples[CPUCLOCK_PROF]);
+       virt_exp = check_timers_list(&base[CPUCLOCK_VIRT].cpu_timers,
+                                    firing, samples[CPUCLOCK_VIRT]);
+       sched_exp = check_timers_list(&base[CPUCLOCK_SCHED].cpu_timers,
+                                     firing, samples[CPUCLOCK_SCHED]);
 
        /*
         * Check for the special case process timers.
         */
-       check_cpu_itimer(tsk, &sig->it[CPUCLOCK_PROF], &prof_expires, ptime,
-                        SIGPROF);
-       check_cpu_itimer(tsk, &sig->it[CPUCLOCK_VIRT], &virt_expires, utime,
-                        SIGVTALRM);
+       check_cpu_itimer(tsk, &sig->it[CPUCLOCK_PROF], &prof_exp,
+                        samples[CPUCLOCK_PROF], SIGPROF);
+       check_cpu_itimer(tsk, &sig->it[CPUCLOCK_VIRT], &virt_exp,
+                        samples[CPUCLOCK_PROF], SIGVTALRM);
+
        soft = task_rlimit(tsk, RLIMIT_CPU);
        if (soft != RLIM_INFINITY) {
-               unsigned long psecs = div_u64(ptime, NSEC_PER_SEC);
+               u64 softns, ptime = samples[CPUCLOCK_PROF];
                unsigned long hard = task_rlimit_max(tsk, RLIMIT_CPU);
-               u64 x;
+               unsigned long psecs = div_u64(ptime, NSEC_PER_SEC);
+
                if (psecs >= hard) {
                        /*
                         * At the hard limit, we just die.
@@ -961,14 +947,14 @@ static void check_process_timers(struct task_struct *tsk,
                                sig->rlim[RLIMIT_CPU].rlim_cur = soft;
                        }
                }
-               x = soft * NSEC_PER_SEC;
-               if (!prof_expires || x < prof_expires)
-                       prof_expires = x;
+               softns = soft * NSEC_PER_SEC;
+               if (!prof_exp || softns < prof_exp)
+                       prof_exp = softns;
        }
 
-       base[CPUCLOCK_PROF].nextevt = prof_expires;
-       base[CPUCLOCK_VIRT].nextevt = virt_expires;
-       base[CPUCLOCK_SCHED].nextevt = sched_expires;
+       base[CPUCLOCK_PROF].nextevt = prof_exp;
+       base[CPUCLOCK_VIRT].nextevt = virt_exp;
+       base[CPUCLOCK_SCHED].nextevt = sched_exp;
 
        if (expiry_cache_is_zero(&sig->posix_cputimers))
                stop_process_timers(sig);