Merge branch 'linus' into sched/core, to pick up fixes

Signed-off-by: Ingo Molnar <[email protected]>

diff --combined kernel/sched/fair.c
index 7b0da7007da33c3b3a1b6748d7b71a056a04fb54,35f3ea3750844c2a8789e7b6312bf8432caa1e5a..f35930f5e528a8e1ca8e5f8ed5a6556c86a54701
--- 1/kernel/sched/fair.c
--- 2/kernel/sched/fair.c
+++ b/kernel/sched/fair.c
@@@ -2007,6 -2007,10 +2007,10 @@@ static u64 numa_get_avg_runtime(struct 
        if (p->last_task_numa_placement) {
                delta = runtime - p->last_sum_exec_runtime;
                *period = now - p->last_task_numa_placement;
+ 
+               /* Avoid time going backwards, prevent potential divide error: */
+               if (unlikely((s64)*period < 0))
+                       *period = 0;
        } else {
                delta = p->se.avg.load_sum;
                *period = LOAD_AVG_MAX;
@@@ -2593,7 -2597,7 +2597,7 @@@ out
  /*
   * Drive the periodic memory faults..
   */
 -void task_tick_numa(struct rq *rq, struct task_struct *curr)
 +static void task_tick_numa(struct rq *rq, struct task_struct *curr)
  {
        struct callback_head *work = &curr->numa_work;
        u64 period, now;
@@@ -3567,7 -3571,7 +3571,7 @@@ static inline u64 cfs_rq_last_update_ti
   * Synchronize entity load avg of dequeued entity without locking
   * the previous rq.
   */
 -void sync_entity_load_avg(struct sched_entity *se)
 +static void sync_entity_load_avg(struct sched_entity *se)
  {
        struct cfs_rq *cfs_rq = cfs_rq_of(se);
        u64 last_update_time;
@@@ -3580,7 -3584,7 +3584,7 @@@
   * Task first catches up with cfs_rq, and then subtract
   * itself from the cfs_rq (task must be off the queue now).
   */
 -void remove_entity_load_avg(struct sched_entity *se)
 +static void remove_entity_load_avg(struct sched_entity *se)
  {
        struct cfs_rq *cfs_rq = cfs_rq_of(se);
        unsigned long flags;
@@@ -4885,6 -4889,8 +4889,8 @@@ static enum hrtimer_restart sched_cfs_s
        return HRTIMER_NORESTART;
  }
  
+ extern const u64 max_cfs_quota_period;
+ 
  static enum hrtimer_restart sched_cfs_period_timer(struct hrtimer *timer)
  {
        struct cfs_bandwidth *cfs_b =
@@@ -4892,6 -4898,7 +4898,7 @@@
        unsigned long flags;
        int overrun;
        int idle = 0;
+       int count = 0;
  
        raw_spin_lock_irqsave(&cfs_b->lock, flags);
        for (;;) {
@@@ -4899,6 -4906,28 +4906,28 @@@
                if (!overrun)
                        break;
  
+               if (++count > 3) {
+                       u64 new, old = ktime_to_ns(cfs_b->period);
+ 
+                       new = (old * 147) / 128; /* ~115% */
+                       new = min(new, max_cfs_quota_period);
+ 
+                       cfs_b->period = ns_to_ktime(new);
+ 
+                       /* since max is 1s, this is limited to 1e9^2, which fits in u64 */
+                       cfs_b->quota *= new;
+                       cfs_b->quota = div64_u64(cfs_b->quota, old);
+ 
+                       pr_warn_ratelimited(
+       "cfs_period_timer[cpu%d]: period too short, scaling up (new cfs_period_us %lld, cfs_quota_us = %lld)\n",
+                               smp_processor_id(),
+                               div_u64(new, NSEC_PER_USEC),
+                               div_u64(cfs_b->quota, NSEC_PER_USEC));
+ 
+                       /* reset count so we don't come right back in here */
+                       count = 0;
+               }
+ 
                idle = do_sched_cfs_period_timer(cfs_b, overrun, flags);
        }
        if (idle)
@@@ -5116,6 -5145,7 +5145,6 @@@ static inline void hrtick_update(struc
  
  #ifdef CONFIG_SMP
  static inline unsigned long cpu_util(int cpu);
 -static unsigned long capacity_of(int cpu);
  
  static inline bool cpu_overutilized(int cpu)
  {
@@@ -7491,6 -7521,7 +7520,6 @@@ static void detach_task(struct task_str
  {
        lockdep_assert_held(&env->src_rq->lock);
  
 -      p->on_rq = TASK_ON_RQ_MIGRATING;
        deactivate_task(env->src_rq, p, DEQUEUE_NOCLOCK);
        set_task_cpu(p, env->dst_cpu);
  }
@@@ -7626,6 -7657,7 +7655,6 @@@ static void attach_task(struct rq *rq, 
  
        BUG_ON(task_rq(p) != rq);
        activate_task(rq, p, ENQUEUE_NOCLOCK);
 -      p->on_rq = TASK_ON_RQ_QUEUED;
        check_preempt_curr(rq, p, 0);
  }
  
@@@ -9519,26 -9551,22 +9548,26 @@@ static inline int on_null_domain(struc
   * - When one of the busy CPUs notice that there may be an idle rebalancing
   *   needed, they will kick the idle load balancer, which then does idle
   *   load balancing for all the idle CPUs.
 + * - HK_FLAG_MISC CPUs are used for this task, because HK_FLAG_SCHED not set
 + *   anywhere yet.
   */
  
  static inline int find_new_ilb(void)
  {
 -      int ilb = cpumask_first(nohz.idle_cpus_mask);
 +      int ilb;
  
 -      if (ilb < nr_cpu_ids && idle_cpu(ilb))
 -              return ilb;
 +      for_each_cpu_and(ilb, nohz.idle_cpus_mask,
 +                            housekeeping_cpumask(HK_FLAG_MISC)) {
 +              if (idle_cpu(ilb))
 +                      return ilb;
 +      }
  
        return nr_cpu_ids;
  }
  
  /*
 - * Kick a CPU to do the nohz balancing, if it is time for it. We pick the
 - * nohz_load_balancer CPU (if there is one) otherwise fallback to any idle
 - * CPU (if there is one).
 + * Kick a CPU to do the nohz balancing, if it is time for it. We pick any
 + * idle CPU in the HK_FLAG_MISC housekeeping set (if there is one).
   */
  static void kick_ilb(unsigned int flags)
  {