posix-timers: Remove dead thread posix cpu timers caching

When a task is exiting or has exited, its posix cpu timers
don't tick anymore and won't elapse further. It's too late
for them to expire.

So any further call to timer_gettime() on these timers will
return the same remaining expiry time.

The current code optimize this by caching the remaining delta
and storing it where we use to save the absolute expiration time.
This way, the future calls to timer_gettime() won't need to
compute the difference between the absolute expiration time and
the current time anymore.

Now this optimization doesn't seem to bring much value. Computing
the timer remaining delta is not very costly. Fetching the timer
value OTOH can be costly in two ways:

* CPUCLOCK_SCHED read requires to lock the target's rq. But some
optimizations are on the way to make task_sched_runtime() not holding
the rq lock of a non-running target.

* CPUCLOCK_VIRT/CPUCLOCK_PROF read simply consist in fetching
current->utime/current->stime except when the system uses full
dynticks cputime accounting. The latter requires a per task lock
in order to correctly compute user and system time. But once the
target is dead, this lock shouldn't be contended anyway.

All in one this caching doesn't seem to be justified.
Given that it complicates the code significantly for
few wins, let's remove it on single thread timers.

Signed-off-by: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Ingo Molnar <mingo@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Kosaki Motohiro <kosaki.motohiro@jp.fujitsu.com>
Cc: Andrew Morton <akpm@linux-foundation.org>

1 files changed, 16 insertions, 18 deletions

diff --git a/kernel/posix-cpu-timers.c b/kernel/posix-cpu-timers.c
index 79747b7d9420..3b7df8653913 100644
--- a/kernel/posix-cpu-timers.c
+++ b/kernel/posix-cpu-timers.c
@@ -788,7 +788,6 @@ static void posix_cpu_timer_get(struct k_itimer *timer, struct itimerspec *itp)
 {
         unsigned long long now;
         struct task_struct *p = timer->it.cpu.task;
-        int clear_dead;
 
         /*
          * Easy part: convert the reload time.
@@ -802,6 +801,7 @@ static void posix_cpu_timer_get(struct k_itimer *timer, struct itimerspec *itp)
         }
 
         if (unlikely(p == NULL)) {
+                WARN_ON_ONCE(CPUCLOCK_PERTHREAD(timer->it_clock));
                 /*
                  * This task already died and the timer will never fire.
                  * In this case, expires is actually the dead value.
@@ -817,7 +817,6 @@ static void posix_cpu_timer_get(struct k_itimer *timer, struct itimerspec *itp)
          */
         if (CPUCLOCK_PERTHREAD(timer->it_clock)) {
                 cpu_clock_sample(timer->it_clock, p, &now);
-                clear_dead = p->exit_state;
         } else {
                 read_lock(&tasklist_lock);
                 if (unlikely(p->sighand == NULL)) {
@@ -833,22 +832,20 @@ static void posix_cpu_timer_get(struct k_itimer *timer, struct itimerspec *itp)
                         goto dead;
                 } else {
                         cpu_timer_sample_group(timer->it_clock, p, &now);
-                        clear_dead = (unlikely(p->exit_state) &&
-                                      thread_group_empty(p));
+                        if (unlikely(p->exit_state) && thread_group_empty(p)) {
+                                read_unlock(&tasklist_lock);
+                                /*
+                                 * We've noticed that the thread is dead, but
+                                 * not yet reaped.  Take this opportunity to
+                                 * drop our task ref.
+                                 */
+                                clear_dead_task(timer, now);
+                                goto dead;
+                        }
                 }
                 read_unlock(&tasklist_lock);
         }
 
-        if (unlikely(clear_dead)) {
-                /*
-                 * We've noticed that the thread is dead, but
-                 * not yet reaped.  Take this opportunity to
-                 * drop our task ref.
-                 */
-                clear_dead_task(timer, now);
-                goto dead;
-        }
-
         if (now < timer->it.cpu.expires) {
                 sample_to_timespec(timer->it_clock,
                                    timer->it.cpu.expires - now,
@@ -1063,11 +1060,13 @@ void posix_cpu_timer_schedule(struct k_itimer *timer)
         struct task_struct *p = timer->it.cpu.task;
         unsigned long long now;
 
-        if (unlikely(p == NULL))
+        if (unlikely(p == NULL)) {
+                WARN_ON_ONCE(CPUCLOCK_PERTHREAD(timer->it_clock));
                 /*
                  * The task was cleaned up already, no future firings.
                  */
                 goto out;
+        }
 
         /*
          * Fetch the current sample and update the timer's expiry time.
@@ -1075,10 +1074,9 @@ void posix_cpu_timer_schedule(struct k_itimer *timer)
         if (CPUCLOCK_PERTHREAD(timer->it_clock)) {
                 cpu_clock_sample(timer->it_clock, p, &now);
                 bump_cpu_timer(timer, now);
-                if (unlikely(p->exit_state)) {
-                        clear_dead_task(timer, now);
+                if (unlikely(p->exit_state))
                         goto out;
-                }
+
                 read_lock(&tasklist_lock); /* arm_timer needs it.  */
                 spin_lock(&p->sighand->siglock);
         } else {