Merge branch 'sched-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
Linus Torvalds [Fri, 22 Jul 2011 23:45:02 +0000 (16:45 -0700)]
* 'sched-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip: (24 commits)
  sched: Cleanup duplicate local variable in [enqueue|dequeue]_task_fair
  sched: Replace use of entity_key()
  sched: Separate group-scheduling code more clearly
  sched: Reorder root_domain to remove 64 bit alignment padding
  sched: Do not attempt to destroy uninitialized rt_bandwidth
  sched: Remove unused function cpu_cfs_rq()
  sched: Fix (harmless) typo 'CONFG_FAIR_GROUP_SCHED'
  sched, cgroup: Optimize load_balance_fair()
  sched: Don't update shares twice on on_rq parent
  sched: update correct entity's runtime in check_preempt_wakeup()
  xtensa: Use generic config PREEMPT definition
  h8300: Use generic config PREEMPT definition
  m32r: Use generic PREEMPT config
  sched: Skip autogroup when looking for all rt sched groups
  sched: Simplify mutex_spin_on_owner()
  sched: Remove rcu_read_lock() from wake_affine()
  sched: Generalize sleep inside spinlock detection
  sched: Make sleeping inside spinlock detection working in !CONFIG_PREEMPT
  sched: Isolate preempt counting in its own config option
  sched: Remove pointless in_atomic() definition check
  ...

1  2 
include/linux/sched.h
kernel/sched.c
lib/Kconfig.debug

diff --combined include/linux/sched.h
@@@ -1292,7 -1292,7 +1292,7 @@@ struct task_struct 
        int exit_state;
        int exit_code, exit_signal;
        int pdeath_signal;  /*  The signal sent when the parent dies  */
 -      unsigned int group_stop;        /* GROUP_STOP_*, siglock protected */
 +      unsigned int jobctl;    /* JOBCTL_*, siglock protected */
        /* ??? */
        unsigned int personality;
        unsigned did_exec:1;
@@@ -1813,34 -1813,15 +1813,34 @@@ extern void thread_group_times(struct t
  #define used_math() tsk_used_math(current)
  
  /*
 - * task->group_stop flags
 + * task->jobctl flags
   */
 -#define GROUP_STOP_SIGMASK    0xffff    /* signr of the last group stop */
 -#define GROUP_STOP_PENDING    (1 << 16) /* task should stop for group stop */
 -#define GROUP_STOP_CONSUME    (1 << 17) /* consume group stop count */
 -#define GROUP_STOP_TRAPPING   (1 << 18) /* switching from STOPPED to TRACED */
 -#define GROUP_STOP_DEQUEUED   (1 << 19) /* stop signal dequeued */
 -
 -extern void task_clear_group_stop_pending(struct task_struct *task);
 +#define JOBCTL_STOP_SIGMASK   0xffff  /* signr of the last group stop */
 +
 +#define JOBCTL_STOP_DEQUEUED_BIT 16   /* stop signal dequeued */
 +#define JOBCTL_STOP_PENDING_BIT       17      /* task should stop for group stop */
 +#define JOBCTL_STOP_CONSUME_BIT       18      /* consume group stop count */
 +#define JOBCTL_TRAP_STOP_BIT  19      /* trap for STOP */
 +#define JOBCTL_TRAP_NOTIFY_BIT        20      /* trap for NOTIFY */
 +#define JOBCTL_TRAPPING_BIT   21      /* switching to TRACED */
 +#define JOBCTL_LISTENING_BIT  22      /* ptracer is listening for events */
 +
 +#define JOBCTL_STOP_DEQUEUED  (1 << JOBCTL_STOP_DEQUEUED_BIT)
 +#define JOBCTL_STOP_PENDING   (1 << JOBCTL_STOP_PENDING_BIT)
 +#define JOBCTL_STOP_CONSUME   (1 << JOBCTL_STOP_CONSUME_BIT)
 +#define JOBCTL_TRAP_STOP      (1 << JOBCTL_TRAP_STOP_BIT)
 +#define JOBCTL_TRAP_NOTIFY    (1 << JOBCTL_TRAP_NOTIFY_BIT)
 +#define JOBCTL_TRAPPING               (1 << JOBCTL_TRAPPING_BIT)
 +#define JOBCTL_LISTENING      (1 << JOBCTL_LISTENING_BIT)
 +
 +#define JOBCTL_TRAP_MASK      (JOBCTL_TRAP_STOP | JOBCTL_TRAP_NOTIFY)
 +#define JOBCTL_PENDING_MASK   (JOBCTL_STOP_PENDING | JOBCTL_TRAP_MASK)
 +
 +extern bool task_set_jobctl_pending(struct task_struct *task,
 +                                  unsigned int mask);
 +extern void task_clear_jobctl_trapping(struct task_struct *task);
 +extern void task_clear_jobctl_pending(struct task_struct *task,
 +                                    unsigned int mask);
  
  #ifdef CONFIG_PREEMPT_RCU
  
@@@ -2155,7 -2136,7 +2155,7 @@@ static inline int dequeue_signal_lock(s
        spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
  
        return ret;
 -}     
 +}
  
  extern void block_all_signals(int (*notifier)(void *priv), void *priv,
                              sigset_t *mask);
@@@ -2170,7 -2151,7 +2170,7 @@@ extern int kill_pid_info_as_uid(int, st
  extern int kill_pgrp(struct pid *pid, int sig, int priv);
  extern int kill_pid(struct pid *pid, int sig, int priv);
  extern int kill_proc_info(int, struct siginfo *, pid_t);
 -extern int do_notify_parent(struct task_struct *, int);
 +extern __must_check bool do_notify_parent(struct task_struct *, int);
  extern void __wake_up_parent(struct task_struct *p, struct task_struct *parent);
  extern void force_sig(int, struct task_struct *);
  extern int send_sig(int, struct task_struct *, int);
@@@ -2294,10 -2275,8 +2294,10 @@@ static inline int get_nr_threads(struc
        return tsk->signal->nr_threads;
  }
  
 -/* de_thread depends on thread_group_leader not being a pid based check */
 -#define thread_group_leader(p)        (p == p->group_leader)
 +static inline bool thread_group_leader(struct task_struct *p)
 +{
 +      return p->exit_signal >= 0;
 +}
  
  /* Do to the insanities of de_thread it is possible for a process
   * to have the pid of the thread group leader without actually being
@@@ -2330,6 -2309,11 +2330,6 @@@ static inline int thread_group_empty(st
  #define delay_group_leader(p) \
                (thread_group_leader(p) && !thread_group_empty(p))
  
 -static inline int task_detached(struct task_struct *p)
 -{
 -      return p->exit_signal == -1;
 -}
 -
  /*
   * Protects ->fs, ->files, ->mm, ->group_info, ->comm, keyring
   * subscriptions and synchronises with wait4().  Also used in procfs.  Also
@@@ -2526,7 -2510,7 +2526,7 @@@ extern int _cond_resched(void)
  
  extern int __cond_resched_lock(spinlock_t *lock);
  
- #ifdef CONFIG_PREEMPT
+ #ifdef CONFIG_PREEMPT_COUNT
  #define PREEMPT_LOCK_OFFSET   PREEMPT_OFFSET
  #else
  #define PREEMPT_LOCK_OFFSET   0
diff --combined kernel/sched.c
  
  static inline int rt_policy(int policy)
  {
-       if (unlikely(policy == SCHED_FIFO || policy == SCHED_RR))
+       if (policy == SCHED_FIFO || policy == SCHED_RR)
                return 1;
        return 0;
  }
@@@ -422,6 -422,7 +422,7 @@@ struct rt_rq 
   */
  struct root_domain {
        atomic_t refcount;
+       atomic_t rto_count;
        struct rcu_head rcu;
        cpumask_var_t span;
        cpumask_var_t online;
         * one runnable RT task.
         */
        cpumask_var_t rto_mask;
-       atomic_t rto_count;
        struct cpupri cpupri;
  };
  
@@@ -1568,38 -1568,6 +1568,6 @@@ static unsigned long cpu_avg_load_per_t
        return rq->avg_load_per_task;
  }
  
- #ifdef CONFIG_FAIR_GROUP_SCHED
- /*
-  * Compute the cpu's hierarchical load factor for each task group.
-  * This needs to be done in a top-down fashion because the load of a child
-  * group is a fraction of its parents load.
-  */
- static int tg_load_down(struct task_group *tg, void *data)
- {
-       unsigned long load;
-       long cpu = (long)data;
-       if (!tg->parent) {
-               load = cpu_rq(cpu)->load.weight;
-       } else {
-               load = tg->parent->cfs_rq[cpu]->h_load;
-               load *= tg->se[cpu]->load.weight;
-               load /= tg->parent->cfs_rq[cpu]->load.weight + 1;
-       }
-       tg->cfs_rq[cpu]->h_load = load;
-       return 0;
- }
- static void update_h_load(long cpu)
- {
-       walk_tg_tree(tg_load_down, tg_nop, (void *)cpu);
- }
- #endif
  #ifdef CONFIG_PREEMPT
  
  static void double_rq_lock(struct rq *rq1, struct rq *rq2);
@@@ -2220,7 -2188,7 +2188,7 @@@ void set_task_cpu(struct task_struct *p
  
        if (task_cpu(p) != new_cpu) {
                p->se.nr_migrations++;
 -              perf_sw_event(PERF_COUNT_SW_CPU_MIGRATIONS, 1, 1, NULL, 0);
 +              perf_sw_event(PERF_COUNT_SW_CPU_MIGRATIONS, 1, NULL, 0);
        }
  
        __set_task_cpu(p, new_cpu);
@@@ -2497,7 -2465,7 +2465,7 @@@ ttwu_do_wakeup(struct rq *rq, struct ta
        if (p->sched_class->task_woken)
                p->sched_class->task_woken(rq, p);
  
-       if (unlikely(rq->idle_stamp)) {
+       if (rq->idle_stamp) {
                u64 delta = rq->clock - rq->idle_stamp;
                u64 max = 2*sysctl_sched_migration_cost;
  
@@@ -2886,7 -2854,7 +2854,7 @@@ void sched_fork(struct task_struct *p
  #if defined(CONFIG_SMP)
        p->on_cpu = 0;
  #endif
- #ifdef CONFIG_PREEMPT
+ #ifdef CONFIG_PREEMPT_COUNT
        /* Want to start with kernel preemption disabled. */
        task_thread_info(p)->preempt_count = 1;
  #endif
@@@ -4338,11 -4306,8 +4306,8 @@@ EXPORT_SYMBOL(schedule)
  
  static inline bool owner_running(struct mutex *lock, struct task_struct *owner)
  {
-       bool ret = false;
-       rcu_read_lock();
        if (lock->owner != owner)
-               goto fail;
+               return false;
  
        /*
         * Ensure we emit the owner->on_cpu, dereference _after_ checking
         */
        barrier();
  
-       ret = owner->on_cpu;
- fail:
-       rcu_read_unlock();
-       return ret;
+       return owner->on_cpu;
  }
  
  /*
@@@ -4368,21 -4329,21 +4329,21 @@@ int mutex_spin_on_owner(struct mutex *l
        if (!sched_feat(OWNER_SPIN))
                return 0;
  
+       rcu_read_lock();
        while (owner_running(lock, owner)) {
                if (need_resched())
-                       return 0;
+                       break;
  
                arch_mutex_cpu_relax();
        }
+       rcu_read_unlock();
  
        /*
-        * If the owner changed to another task there is likely
-        * heavy contention, stop spinning.
+        * We break out the loop above on need_resched() and when the
+        * owner changed, which is a sign for heavy contention. Return
+        * success only when lock->owner is NULL.
         */
-       if (lock->owner)
-               return 0;
-       return 1;
+       return lock->owner == NULL;
  }
  #endif
  
@@@ -7898,17 -7859,10 +7859,10 @@@ int in_sched_functions(unsigned long ad
                && addr < (unsigned long)__sched_text_end);
  }
  
- static void init_cfs_rq(struct cfs_rq *cfs_rq, struct rq *rq)
+ static void init_cfs_rq(struct cfs_rq *cfs_rq)
  {
        cfs_rq->tasks_timeline = RB_ROOT;
        INIT_LIST_HEAD(&cfs_rq->tasks);
- #ifdef CONFIG_FAIR_GROUP_SCHED
-       cfs_rq->rq = rq;
-       /* allow initial update_cfs_load() to truncate */
- #ifdef CONFIG_SMP
-       cfs_rq->load_stamp = 1;
- #endif
- #endif
        cfs_rq->min_vruntime = (u64)(-(1LL << 20));
  #ifndef CONFIG_64BIT
        cfs_rq->min_vruntime_copy = cfs_rq->min_vruntime;
@@@ -7928,27 -7882,18 +7882,18 @@@ static void init_rt_rq(struct rt_rq *rt
        /* delimiter for bitsearch: */
        __set_bit(MAX_RT_PRIO, array->bitmap);
  
- #if defined CONFIG_SMP || defined CONFIG_RT_GROUP_SCHED
+ #if defined CONFIG_SMP
        rt_rq->highest_prio.curr = MAX_RT_PRIO;
- #ifdef CONFIG_SMP
        rt_rq->highest_prio.next = MAX_RT_PRIO;
- #endif
- #endif
- #ifdef CONFIG_SMP
        rt_rq->rt_nr_migratory = 0;
        rt_rq->overloaded = 0;
 -      plist_head_init_raw(&rt_rq->pushable_tasks, &rq->lock);
 +      plist_head_init(&rt_rq->pushable_tasks);
  #endif
  
        rt_rq->rt_time = 0;
        rt_rq->rt_throttled = 0;
        rt_rq->rt_runtime = 0;
        raw_spin_lock_init(&rt_rq->rt_runtime_lock);
- #ifdef CONFIG_RT_GROUP_SCHED
-       rt_rq->rt_nr_boosted = 0;
-       rt_rq->rq = rq;
- #endif
  }
  
  #ifdef CONFIG_FAIR_GROUP_SCHED
@@@ -7957,11 -7902,17 +7902,17 @@@ static void init_tg_cfs_entry(struct ta
                                struct sched_entity *parent)
  {
        struct rq *rq = cpu_rq(cpu);
-       tg->cfs_rq[cpu] = cfs_rq;
-       init_cfs_rq(cfs_rq, rq);
        cfs_rq->tg = tg;
+       cfs_rq->rq = rq;
+ #ifdef CONFIG_SMP
+       /* allow initial update_cfs_load() to truncate */
+       cfs_rq->load_stamp = 1;
+ #endif
  
+       tg->cfs_rq[cpu] = cfs_rq;
        tg->se[cpu] = se;
        /* se could be NULL for root_task_group */
        if (!se)
                return;
@@@ -7984,12 -7935,14 +7935,14 @@@ static void init_tg_rt_entry(struct tas
  {
        struct rq *rq = cpu_rq(cpu);
  
-       tg->rt_rq[cpu] = rt_rq;
-       init_rt_rq(rt_rq, rq);
+       rt_rq->highest_prio.curr = MAX_RT_PRIO;
+       rt_rq->rt_nr_boosted = 0;
+       rt_rq->rq = rq;
        rt_rq->tg = tg;
-       rt_rq->rt_runtime = tg->rt_bandwidth.rt_runtime;
  
+       tg->rt_rq[cpu] = rt_rq;
        tg->rt_se[cpu] = rt_se;
        if (!rt_se)
                return;
  
@@@ -8071,7 -8024,7 +8024,7 @@@ void __init sched_init(void
                rq->nr_running = 0;
                rq->calc_load_active = 0;
                rq->calc_load_update = jiffies + LOAD_FREQ;
-               init_cfs_rq(&rq->cfs, rq);
+               init_cfs_rq(&rq->cfs);
                init_rt_rq(&rq->rt, rq);
  #ifdef CONFIG_FAIR_GROUP_SCHED
                root_task_group.shares = root_task_group_load;
  #endif
  
  #ifdef CONFIG_RT_MUTEXES
 -      plist_head_init_raw(&init_task.pi_waiters, &init_task.pi_lock);
 +      plist_head_init(&init_task.pi_waiters);
  #endif
  
        /*
        scheduler_running = 1;
  }
  
- #ifdef CONFIG_DEBUG_SPINLOCK_SLEEP
+ #ifdef CONFIG_DEBUG_ATOMIC_SLEEP
  static inline int preempt_count_equals(int preempt_offset)
  {
        int nested = (preempt_count() & ~PREEMPT_ACTIVE) + rcu_preempt_depth();
  
  void __might_sleep(const char *file, int line, int preempt_offset)
  {
- #ifdef in_atomic
        static unsigned long prev_jiffy;        /* ratelimiting */
  
        if ((preempt_count_equals(preempt_offset) && !irqs_disabled()) ||
        if (irqs_disabled())
                print_irqtrace_events(current);
        dump_stack();
- #endif
  }
  EXPORT_SYMBOL(__might_sleep);
  #endif
@@@ -8376,6 -8327,7 +8327,7 @@@ int alloc_fair_sched_group(struct task_
                if (!se)
                        goto err_free_rq;
  
+               init_cfs_rq(cfs_rq);
                init_tg_cfs_entry(tg, cfs_rq, se, i, parent->se[i]);
        }
  
@@@ -8403,7 -8355,7 +8355,7 @@@ static inline void unregister_fair_sche
        list_del_leaf_cfs_rq(tg->cfs_rq[cpu]);
        raw_spin_unlock_irqrestore(&rq->lock, flags);
  }
- #else /* !CONFG_FAIR_GROUP_SCHED */
+ #else /* !CONFIG_FAIR_GROUP_SCHED */
  static inline void free_fair_sched_group(struct task_group *tg)
  {
  }
@@@ -8424,7 -8376,8 +8376,8 @@@ static void free_rt_sched_group(struct 
  {
        int i;
  
-       destroy_rt_bandwidth(&tg->rt_bandwidth);
+       if (tg->rt_se)
+               destroy_rt_bandwidth(&tg->rt_bandwidth);
  
        for_each_possible_cpu(i) {
                if (tg->rt_rq)
@@@ -8465,6 -8418,8 +8418,8 @@@ int alloc_rt_sched_group(struct task_gr
                if (!rt_se)
                        goto err_free_rq;
  
+               init_rt_rq(rt_rq, cpu_rq(i));
+               rt_rq->rt_runtime = tg->rt_bandwidth.rt_runtime;
                init_tg_rt_entry(tg, rt_rq, rt_se, i, parent->rt_se[i]);
        }
  
diff --combined lib/Kconfig.debug
@@@ -227,7 -227,7 +227,7 @@@ config BOOTPARAM_SOFTLOCKUP_PANIC_VALU
  config DETECT_HUNG_TASK
        bool "Detect Hung Tasks"
        depends on DEBUG_KERNEL
 -      default DETECT_SOFTLOCKUP
 +      default LOCKUP_DETECTOR
        help
          Say Y here to enable the kernel to detect "hung tasks",
          which are bugs that cause the task to be stuck in
@@@ -648,12 -648,15 +648,15 @@@ config TRACE_IRQFLAG
          Enables hooks to interrupt enabling and disabling for
          either tracing or lock debugging.
  
- config DEBUG_SPINLOCK_SLEEP
-       bool "Spinlock debugging: sleep-inside-spinlock checking"
+ config DEBUG_ATOMIC_SLEEP
+       bool "Sleep inside atomic section checking"
+       select PREEMPT_COUNT
        depends on DEBUG_KERNEL
        help
          If you say Y here, various routines which may sleep will become very
-         noisy if they are called with a spinlock held.
+         noisy if they are called inside atomic sections: when a spinlock is
+         held, inside an rcu read side critical section, inside preempt disabled
+         sections, inside an interrupt, etc...
  
  config DEBUG_LOCKING_API_SELFTESTS
        bool "Locking API boot-time self-tests"
@@@ -866,7 -869,7 +869,7 @@@ config BOOT_PRINTK_DELA
          system, and then set "lpj=M" before setting "boot_delay=N".
          NOTE:  Using this option may adversely affect SMP systems.
          I.e., processors other than the first one may not boot up.
 -        BOOT_PRINTK_DELAY also may cause DETECT_SOFTLOCKUP to detect
 +        BOOT_PRINTK_DELAY also may cause LOCKUP_DETECTOR to detect
          what it believes to be lockup conditions.
  
  config RCU_TORTURE_TEST