Merge branch 'sched/core' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip...
Martin Schwidefsky [Mon, 19 Dec 2011 18:23:15 +0000 (19:23 +0100)]
Conflicts:
drivers/cpufreq/cpufreq_conservative.c
drivers/cpufreq/cpufreq_ondemand.c
drivers/macintosh/rack-meter.c
fs/proc/stat.c
fs/proc/uptime.c
kernel/sched/core.c

1  2 
drivers/cpufreq/cpufreq_conservative.c
drivers/cpufreq/cpufreq_ondemand.c
drivers/macintosh/rack-meter.c
fs/proc/uptime.c
include/linux/sched.h
kernel/sched/core.c
kernel/sched/stats.h

@@@ -95,26 -95,26 +95,26 @@@ static struct dbs_tuners 
        .freq_step = 5,
  };
  
- static inline cputime64_t get_cpu_idle_time_jiffy(unsigned int cpu,
-                                                       cputime64_t *wall)
+ static inline u64 get_cpu_idle_time_jiffy(unsigned int cpu, u64 *wall)
  {
-       cputime64_t idle_time;
-       cputime64_t cur_wall_time;
-       cputime64_t busy_time;
+       u64 idle_time;
 -      cputime64_t cur_wall_time;
++      u64 cur_wall_time;
+       u64 busy_time;
  
        cur_wall_time = jiffies64_to_cputime64(get_jiffies_64());
-       busy_time  = kstat_cpu(cpu).cpustat.user;
-       busy_time += kstat_cpu(cpu).cpustat.system;
-       busy_time += kstat_cpu(cpu).cpustat.irq;
-       busy_time += kstat_cpu(cpu).cpustat.softirq;
-       busy_time += kstat_cpu(cpu).cpustat.steal;
-       busy_time += kstat_cpu(cpu).cpustat.nice;
 -      busy_time = kcpustat_cpu(cpu).cpustat[CPUTIME_USER] +
 -                  kcpustat_cpu(cpu).cpustat[CPUTIME_SYSTEM];
++      busy_time  = kcpustat_cpu(cpu).cpustat[CPUTIME_USER];
++      busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_SYSTEM];
+       busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_IRQ];
+       busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_SOFTIRQ];
+       busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_STEAL];
+       busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_NICE];
  
 -      idle_time = cputime64_sub(cur_wall_time, busy_time);
 +      idle_time = cur_wall_time - busy_time;
        if (wall)
-               *wall = (cputime64_t)jiffies_to_usecs(cur_wall_time);
+               *wall = jiffies_to_usecs(cur_wall_time);
  
-       return (cputime64_t)jiffies_to_usecs(idle_time);
+       return jiffies_to_usecs(idle_time);
  }
  
  static inline cputime64_t get_cpu_idle_time(unsigned int cpu, cputime64_t *wall)
@@@ -119,26 -119,26 +119,26 @@@ static struct dbs_tuners 
        .powersave_bias = 0,
  };
  
- static inline cputime64_t get_cpu_idle_time_jiffy(unsigned int cpu,
-                                                       cputime64_t *wall)
+ static inline u64 get_cpu_idle_time_jiffy(unsigned int cpu, u64 *wall)
  {
-       cputime64_t idle_time;
-       cputime64_t cur_wall_time;
-       cputime64_t busy_time;
+       u64 idle_time;
 -      cputime64_t cur_wall_time;
++      u64 cur_wall_time;
+       u64 busy_time;
  
        cur_wall_time = jiffies64_to_cputime64(get_jiffies_64());
-       busy_time  = kstat_cpu(cpu).cpustat.user;
-       busy_time += kstat_cpu(cpu).cpustat.system;
-       busy_time += kstat_cpu(cpu).cpustat.irq;
-       busy_time += kstat_cpu(cpu).cpustat.softirq;
-       busy_time += kstat_cpu(cpu).cpustat.steal;
-       busy_time += kstat_cpu(cpu).cpustat.nice;
 -      busy_time = kcpustat_cpu(cpu).cpustat[CPUTIME_USER] +
 -                  kcpustat_cpu(cpu).cpustat[CPUTIME_SYSTEM];
++      busy_time  = kcpustat_cpu(cpu).cpustat[CPUTIME_USER];
++      busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_SYSTEM];
+       busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_IRQ];
+       busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_SOFTIRQ];
+       busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_STEAL];
+       busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_NICE];
  
 -      idle_time = cputime64_sub(cur_wall_time, busy_time);
 +      idle_time = cur_wall_time - busy_time;
        if (wall)
-               *wall = (cputime64_t)jiffies_to_usecs(cur_wall_time);
+               *wall = jiffies_to_usecs(cur_wall_time);
  
-       return (cputime64_t)jiffies_to_usecs(idle_time);
+       return jiffies_to_usecs(idle_time);
  }
  
  static inline cputime64_t get_cpu_idle_time(unsigned int cpu, cputime64_t *wall)
Simple merge
@@@ -11,14 -11,11 +11,14 @@@ static int uptime_proc_show(struct seq_
  {
        struct timespec uptime;
        struct timespec idle;
-       cputime64_t idletime;
++      u64 idletime;
 +      u64 nsec;
 +      u32 rem;
        int i;
 -      u64 idletime = 0;
  
 +      idletime = 0;
        for_each_possible_cpu(i)
-               idletime += kstat_cpu(i).cpustat.idle;
 -              idletime += kcpustat_cpu(i).cpustat[CPUTIME_IDLE];
++              idletime += (__force u64) kcpustat_cpu(i).cpustat[CPUTIME_IDLE];
  
        do_posix_clock_monotonic_gettime(&uptime);
        monotonic_to_bootbased(&uptime);
Simple merge
@@@ -2166,7 -935,7 +935,7 @@@ static int irqtime_account_hi_update(vo
  
        local_irq_save(flags);
        latest_ns = this_cpu_read(cpu_hardirq_time);
-       if (nsecs_to_cputime64(latest_ns) > cpustat->irq)
 -      if (cputime64_gt(nsecs_to_cputime64(latest_ns), cpustat[CPUTIME_IRQ]))
++      if (nsecs_to_cputime64(latest_ns) > cpustat[CPUTIME_IRQ])
                ret = 1;
        local_irq_restore(flags);
        return ret;
@@@ -2181,7 -950,7 +950,7 @@@ static int irqtime_account_si_update(vo
  
        local_irq_save(flags);
        latest_ns = this_cpu_read(cpu_softirq_time);
-       if (nsecs_to_cputime64(latest_ns) > cpustat->softirq)
 -      if (cputime64_gt(nsecs_to_cputime64(latest_ns), cpustat[CPUTIME_SOFTIRQ]))
++      if (nsecs_to_cputime64(latest_ns) > cpustat[CPUTIME_SOFTIRQ])
                ret = 1;
        local_irq_restore(flags);
        return ret;
@@@ -3867,20 -2633,18 +2633,18 @@@ static inline void task_group_account_f
  void account_user_time(struct task_struct *p, cputime_t cputime,
                       cputime_t cputime_scaled)
  {
-       struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
+       int index;
  
        /* 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);
  
+       index = (TASK_NICE(p) > 0) ? CPUTIME_NICE : CPUTIME_USER;
        /* Add user time to cpustat. */
-       if (TASK_NICE(p) > 0)
-               cpustat->nice += (__force cputime64_t) cputime;
-       else
-               cpustat->user += (__force cputime64_t) cputime;
 -      task_group_account_field(p, index, cputime);
++      task_group_account_field(p, index, (__force u64) cputime);
  
-       cpuacct_update_stats(p, CPUACCT_STAT_USER, cputime);
        /* Account for user time used */
        acct_update_integrals(p);
  }
  static void account_guest_time(struct task_struct *p, cputime_t cputime,
                               cputime_t cputime_scaled)
  {
-       struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
 -      u64 tmp;
+       u64 *cpustat = kcpustat_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 += (__force cputime64_t) cputime;
-               cpustat->guest_nice += (__force cputime64_t) cputime;
 -              cpustat[CPUTIME_NICE] += tmp;
 -              cpustat[CPUTIME_GUEST_NICE] += tmp;
++              cpustat[CPUTIME_NICE] += (__force u64) cputime;
++              cpustat[CPUTIME_GUEST_NICE] += (__force u64) cputime;
        } else {
-               cpustat->user += (__force cputime64_t) cputime;
-               cpustat->guest += (__force cputime64_t) cputime;
 -              cpustat[CPUTIME_USER] += tmp;
 -              cpustat[CPUTIME_GUEST] += tmp;
++              cpustat[CPUTIME_USER] += (__force u64) cputime;
++              cpustat[CPUTIME_GUEST] += (__force u64) cputime;
        }
  }
  
   */
  static inline
  void __account_system_time(struct task_struct *p, cputime_t cputime,
-                       cputime_t cputime_scaled, cputime64_t *target_cputime64)
+                       cputime_t cputime_scaled, int index)
  {
        /* 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 += (__force cputime64_t) cputime;
-       cpuacct_update_stats(p, CPUACCT_STAT_SYSTEM, cputime);
 -      task_group_account_field(p, index, cputime);
++      task_group_account_field(p, index, (__force u64) cputime);
  
        /* Account for system time used */
        acct_update_integrals(p);
@@@ -3970,9 -2735,10 +2732,9 @@@ void account_system_time(struct task_st
   */
  void account_steal_time(cputime_t cputime)
  {
-       struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
+       u64 *cpustat = kcpustat_this_cpu->cpustat;
 -      u64 cputime64 = cputime_to_cputime64(cputime);
  
-       cpustat->steal += (__force cputime64_t) cputime;
 -      cpustat[CPUTIME_STEAL] += cputime64;
++      cpustat[CPUTIME_STEAL] += (__force u64) cputime;
  }
  
  /*
   */
  void account_idle_time(cputime_t cputime)
  {
-       struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
+       u64 *cpustat = kcpustat_this_cpu->cpustat;
        struct rq *rq = this_rq();
  
        if (atomic_read(&rq->nr_iowait) > 0)
-               cpustat->iowait += (__force cputime64_t) cputime;
 -              cpustat[CPUTIME_IOWAIT] += cputime64;
++              cpustat[CPUTIME_IOWAIT] += (__force u64) cputime;
        else
-               cpustat->idle += (__force cputime64_t) cputime;
 -              cpustat[CPUTIME_IDLE] += cputime64;
++              cpustat[CPUTIME_IDLE] += (__force u64) cputime;
  }
  
  static __always_inline bool steal_account_process_tick(void)
@@@ -4037,15 -2804,16 +2799,15 @@@ static void irqtime_account_process_tic
                                                struct rq *rq)
  {
        cputime_t one_jiffy_scaled = cputime_to_scaled(cputime_one_jiffy);
-       struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
 -      u64 tmp = cputime_to_cputime64(cputime_one_jiffy);
+       u64 *cpustat = kcpustat_this_cpu->cpustat;
  
        if (steal_account_process_tick())
                return;
  
        if (irqtime_account_hi_update()) {
-               cpustat->irq += (__force cputime64_t) cputime_one_jiffy;
 -              cpustat[CPUTIME_IRQ] += tmp;
++              cpustat[CPUTIME_IRQ] += (__force u64) cputime_one_jiffy;
        } else if (irqtime_account_si_update()) {
-               cpustat->softirq += (__force cputime64_t) cputime_one_jiffy;
 -              cpustat[CPUTIME_SOFTIRQ] += tmp;
++              cpustat[CPUTIME_SOFTIRQ] += (__force u64) cputime_one_jiffy;
        } else if (this_cpu_ksoftirqd() == p) {
                /*
                 * ksoftirqd time do not get accounted in cpu_softirq_time.
Simple merge