[S390] cputime: add sparse checking and cleanup

Make cputime_t and cputime64_t nocast to enable sparse checking to
detect incorrect use of cputime. Drop the cputime macros for simple
scalar operations. The conversion macros are still needed.

Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>

1 files changed, 35 insertions, 45 deletions

diff --git a/kernel/sched.c b/kernel/sched.c
index d6b149ccf92..18cad4467e6 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -2166,7 +2166,7 @@ static int irqtime_account_hi_update(void)
 
         local_irq_save(flags);
         latest_ns = this_cpu_read(cpu_hardirq_time);
-        if (cputime64_gt(nsecs_to_cputime64(latest_ns), cpustat->irq))
+        if (nsecs_to_cputime64(latest_ns) > cpustat->irq)
                 ret = 1;
         local_irq_restore(flags);
         return ret;
@@ -2181,7 +2181,7 @@ static int irqtime_account_si_update(void)
 
         local_irq_save(flags);
         latest_ns = this_cpu_read(cpu_softirq_time);
-        if (cputime64_gt(nsecs_to_cputime64(latest_ns), cpustat->softirq))
+        if (nsecs_to_cputime64(latest_ns) > cpustat->softirq)
                 ret = 1;
         local_irq_restore(flags);
         return ret;
@@ -3868,19 +3868,17 @@ void account_user_time(struct task_struct *p, cputime_t cputime,
                        cputime_t cputime_scaled)
 {
         struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
-        cputime64_t tmp;
 
         /* Add user time to process. */
-        p->utime = cputime_add(p->utime, cputime);
-        p->utimescaled = cputime_add(p->utimescaled, cputime_scaled);
+        p->utime += cputime;
+        p->utimescaled += cputime_scaled;
         account_group_user_time(p, cputime);
 
         /* Add user time to cpustat. */
-        tmp = cputime_to_cputime64(cputime);
         if (TASK_NICE(p) > 0)
-                cpustat->nice = cputime64_add(cpustat->nice, tmp);
+                cpustat->nice += (__force cputime64_t) cputime;
         else
-                cpustat->user = cputime64_add(cpustat->user, tmp);
+                cpustat->user += (__force cputime64_t) cputime;
 
         cpuacct_update_stats(p, CPUACCT_STAT_USER, cputime);
         /* Account for user time used */
@@ -3896,24 +3894,21 @@ void account_user_time(struct task_struct *p, cputime_t cputime,
 static void account_guest_time(struct task_struct *p, cputime_t cputime,
                                cputime_t cputime_scaled)
 {
-        cputime64_t tmp;
         struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
 
-        tmp = cputime_to_cputime64(cputime);
-
         /* Add guest time to process. */
-        p->utime = cputime_add(p->utime, cputime);
-        p->utimescaled = cputime_add(p->utimescaled, cputime_scaled);
+        p->utime += cputime;
+        p->utimescaled += cputime_scaled;
         account_group_user_time(p, cputime);
-        p->gtime = cputime_add(p->gtime, cputime);
+        p->gtime += cputime;
 
         /* Add guest time to cpustat. */
         if (TASK_NICE(p) > 0) {
-                cpustat->nice = cputime64_add(cpustat->nice, tmp);
-                cpustat->guest_nice = cputime64_add(cpustat->guest_nice, tmp);
+                cpustat->nice += (__force cputime64_t) cputime;
+                cpustat->guest_nice += (__force cputime64_t) cputime;
         } else {
-                cpustat->user = cputime64_add(cpustat->user, tmp);
-                cpustat->guest = cputime64_add(cpustat->guest, tmp);
+                cpustat->user += (__force cputime64_t) cputime;
+                cpustat->guest += (__force cputime64_t) cputime;
         }
 }
 
@@ -3928,15 +3923,13 @@ static inline
 void __account_system_time(struct task_struct *p, cputime_t cputime,
                         cputime_t cputime_scaled, cputime64_t *target_cputime64)
 {
-        cputime64_t tmp = cputime_to_cputime64(cputime);
-
         /* Add system time to process. */
-        p->stime = cputime_add(p->stime, cputime);
-        p->stimescaled = cputime_add(p->stimescaled, cputime_scaled);
+        p->stime += cputime;
+        p->stimescaled += cputime_scaled;
         account_group_system_time(p, cputime);
 
         /* Add system time to cpustat. */
-        *target_cputime64 = cputime64_add(*target_cputime64, tmp);
+        *target_cputime64 += (__force cputime64_t) cputime;
         cpuacct_update_stats(p, CPUACCT_STAT_SYSTEM, cputime);
 
         /* Account for system time used */
@@ -3978,9 +3971,8 @@ void account_system_time(struct task_struct *p, int hardirq_offset,
 void account_steal_time(cputime_t cputime)
 {
         struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
-        cputime64_t cputime64 = cputime_to_cputime64(cputime);
 
-        cpustat->steal = cputime64_add(cpustat->steal, cputime64);
+        cpustat->steal += (__force cputime64_t) cputime;
 }
 
 /*
@@ -3990,13 +3982,12 @@ void account_steal_time(cputime_t cputime)
 void account_idle_time(cputime_t cputime)
 {
         struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
-        cputime64_t cputime64 = cputime_to_cputime64(cputime);
         struct rq *rq = this_rq();
 
         if (atomic_read(&rq->nr_iowait) > 0)
-                cpustat->iowait = cputime64_add(cpustat->iowait, cputime64);
+                cpustat->iowait += (__force cputime64_t) cputime;
         else
-                cpustat->idle = cputime64_add(cpustat->idle, cputime64);
+                cpustat->idle += (__force cputime64_t) cputime;
 }
 
 static __always_inline bool steal_account_process_tick(void)
@@ -4046,16 +4037,15 @@ static void irqtime_account_process_tick(struct task_struct *p, int user_tick,
                                                 struct rq *rq)
 {
         cputime_t one_jiffy_scaled = cputime_to_scaled(cputime_one_jiffy);
-        cputime64_t tmp = cputime_to_cputime64(cputime_one_jiffy);
         struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
 
         if (steal_account_process_tick())
                 return;
 
         if (irqtime_account_hi_update()) {
-                cpustat->irq = cputime64_add(cpustat->irq, tmp);
+                cpustat->irq += (__force cputime64_t) cputime_one_jiffy;
         } else if (irqtime_account_si_update()) {
-                cpustat->softirq = cputime64_add(cpustat->softirq, tmp);
+                cpustat->softirq += (__force cputime64_t) cputime_one_jiffy;
         } else if (this_cpu_ksoftirqd() == p) {
                 /*
                  * ksoftirqd time do not get accounted in cpu_softirq_time.
@@ -4171,7 +4161,7 @@ void thread_group_times(struct task_struct *p, cputime_t *ut, cputime_t *st)
 
 void task_times(struct task_struct *p, cputime_t *ut, cputime_t *st)
 {
-        cputime_t rtime, utime = p->utime, total = cputime_add(utime, p->stime);
+        cputime_t rtime, utime = p->utime, total = utime + p->stime;
 
         /*
          * Use CFS's precise accounting:
@@ -4179,11 +4169,11 @@ void task_times(struct task_struct *p, cputime_t *ut, cputime_t *st)
         rtime = nsecs_to_cputime(p->se.sum_exec_runtime);
 
         if (total) {
-                u64 temp = rtime;
+                u64 temp = (__force u64) rtime;
 
-                temp *= utime;
-                do_div(temp, total);
-                utime = (cputime_t)temp;
+                temp *= (__force u64) utime;
+                do_div(temp, (__force u32) total);
+                utime = (__force cputime_t) temp;
         } else
                 utime = rtime;
 
@@ -4191,7 +4181,7 @@ void task_times(struct task_struct *p, cputime_t *ut, cputime_t *st)
          * Compare with previous values, to keep monotonicity:
          */
         p->prev_utime = max(p->prev_utime, utime);
-        p->prev_stime = max(p->prev_stime, cputime_sub(rtime, p->prev_utime));
+        p->prev_stime = max(p->prev_stime, rtime - p->prev_utime);
 
         *ut = p->prev_utime;
         *st = p->prev_stime;
@@ -4208,21 +4198,20 @@ void thread_group_times(struct task_struct *p, cputime_t *ut, cputime_t *st)
 
         thread_group_cputime(p, &cputime);
 
-        total = cputime_add(cputime.utime, cputime.stime);
+        total = cputime.utime + cputime.stime;
         rtime = nsecs_to_cputime(cputime.sum_exec_runtime);
 
         if (total) {
-                u64 temp = rtime;
+                u64 temp = (__force u64) rtime;
 
-                temp *= cputime.utime;
-                do_div(temp, total);
-                utime = (cputime_t)temp;
+                temp *= (__force u64) cputime.utime;
+                do_div(temp, (__force u32) total);
+                utime = (__force cputime_t) temp;
         } else
                 utime = rtime;
 
         sig->prev_utime = max(sig->prev_utime, utime);
-        sig->prev_stime = max(sig->prev_stime,
-                              cputime_sub(rtime, sig->prev_utime));
+        sig->prev_stime = max(sig->prev_stime, rtime - sig->prev_utime);
 
         *ut = sig->prev_utime;
         *st = sig->prev_stime;
@@ -9769,7 +9758,8 @@ static void cpuacct_update_stats(struct task_struct *tsk,
         ca = task_ca(tsk);
 
         do {
-                __percpu_counter_add(&ca->cpustat[idx], val, batch);
+                __percpu_counter_add(&ca->cpustat[idx],
+                                     (__force s64) val, batch);
                 ca = ca->parent;
         } while (ca);
         rcu_read_unlock();