Merge remote-tracking branch 'tip/auto-latest'

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
	kernel/sched/fair.c

diff --cc Documentation/kernel-parameters.txt
Simple merge

diff --cc Makefile
Simple merge

diff --cc arch/arm/kernel/process.c
Simple merge

diff --cc arch/x86/Kconfig
Simple merge

diff --cc arch/x86/include/asm/thread_info.h
Simple merge

diff --cc arch/x86/include/asm/topology.h
Simple merge

diff --cc drivers/cpufreq/cpufreq_conservative.c
index 7f31a031c0b50321e79f5c3a4517b4c93d3a3aea,118bff73fed36786984aa34ba33d0b5eec131af4..5d2ee436b146dcbe62357a732db37d62615cc29a
--- 1/drivers/cpufreq/cpufreq_conservative.c
--- 2/drivers/cpufreq/cpufreq_conservative.c
+++ b/drivers/cpufreq/cpufreq_conservative.c
@@@ -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;
+       u64 idle_time;
        cputime64_t cur_wall_time;
-       cputime64_t busy_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_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)

diff --cc drivers/cpufreq/cpufreq_ondemand.c
index 17bb5b167a86a249fc69c758d019998ee109cc31,f3d327cee43f891b0c49614409266cc944947f49..25f16782485392a9489eb1b99752a707f07ebe79
--- 1/drivers/cpufreq/cpufreq_ondemand.c
--- 2/drivers/cpufreq/cpufreq_ondemand.c
+++ b/drivers/cpufreq/cpufreq_ondemand.c
@@@ -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;
+       u64 idle_time;
        cputime64_t cur_wall_time;
-       cputime64_t busy_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_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)

diff --cc drivers/macintosh/rack-meter.c
Simple merge

diff --cc fs/proc/uptime.c
index ab515109fec94457c75dfee50a1bdb5389c9198c,0fb22e464e725ed0fe154927c87ec67044c89adc..2527886db04afba7e36a58cc8a2ddd670f15e901
--- 1/fs/proc/uptime.c
--- 2/fs/proc/uptime.c
+++ b/fs/proc/uptime.c
@@@ -11,14 -11,11 +11,13 @@@ static int uptime_proc_show(struct seq_
  {
        struct timespec uptime;
        struct timespec idle;
-       cputime64_t 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];
  
        do_posix_clock_monotonic_gettime(&uptime);
        monotonic_to_bootbased(&uptime);

diff --cc include/linux/sched.h
Simple merge

diff --cc init/Kconfig
Simple merge

diff --cc kernel/cpu.c
Simple merge

diff --cc kernel/sched/core.c
index 18cad4467e61c3211ea7adda5ab5103c8c3abc66,3c5b21e2ef209886a5067791f3e8885f919a7acc..918a21c8ebe7bd3e4839dde739e9dc29c533a2cf
--- 1/kernel/sched.c
--- 2/kernel/sched/core.c
+++ b/kernel/sched/core.c
@@@ -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 cputime64_t) cputime);
  
-       cpuacct_update_stats(p, CPUACCT_STAT_USER, cputime);
        /* Account for user time used */
        acct_update_integrals(p);
  }
@@@ -3894,21 -2658,24 +2658,21 @@@
  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 cputime64_t) cputime;
++              cpustat[CPUTIME_GUEST_NICE] += (__force cputime64_t) 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 cputime64_t) cputime;
++              cpustat[CPUTIME_GUEST] += (__force cputime64_t) cputime;
        }
  }
  
@@@ -3921,16 -2688,15 +2685,15 @@@
   */
  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 cputime64_t) 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 cputime64_t) cputime;
  }
  
  /*
@@@ -3981,13 -2747,14 +2743,13 @@@
   */
  void account_idle_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);
        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 cputime64_t) cputime;
        else
-               cpustat->idle += (__force cputime64_t) cputime;
 -              cpustat[CPUTIME_IDLE] += cputime64;
++              cpustat[CPUTIME_IDLE] += (__force cputime64_t) 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 cputime64_t) 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 cputime64_t) cputime_one_jiffy;
        } else if (this_cpu_ksoftirqd() == p) {
                /*
                 * ksoftirqd time do not get accounted in cpu_softirq_time.

diff --cc kernel/sched/stats.h
Simple merge