9 files changed, 85 insertions, 43 deletions

diff --git a/kernel/cpu.c b/kernel/cpu.c
index 181ae7086029..38033db8d8ec 100644
--- a/kernel/cpu.c
+++ b/kernel/cpu.c
@@ -273,7 +273,7 @@ int __cpuinit cpu_up(unsigned int cpu)
         return err;
 }
 
-#ifdef CONFIG_SUSPEND_SMP
+#ifdef CONFIG_PM_SLEEP_SMP
 static cpumask_t frozen_cpus;
 
 int disable_nonboot_cpus(void)
@@ -334,4 +334,4 @@ void enable_nonboot_cpus(void)
 out:
         mutex_unlock(&cpu_add_remove_lock);
 }
-#endif
+#endif /* CONFIG_PM_SLEEP_SMP */
diff --git a/kernel/exit.c b/kernel/exit.c
index 9578c1ae19ca..06b24b3aa370 100644
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -975,6 +975,7 @@ fastcall NORET_TYPE void do_exit(long code)
         if (unlikely(tsk->audit_context))
                 audit_free(tsk);
 
+        tsk->exit_code = code;
         taskstats_exit(tsk, group_dead);
 
         exit_mm(tsk);
@@ -996,7 +997,6 @@ fastcall NORET_TYPE void do_exit(long code)
         if (tsk->binfmt)
                 module_put(tsk->binfmt->module);
 
-        tsk->exit_code = code;
         proc_exit_connector(tsk);
         exit_task_namespaces(tsk);
         exit_notify(tsk);
diff --git a/kernel/irq/manage.c b/kernel/irq/manage.c
index 853aefbd184b..7230d914eaa2 100644
--- a/kernel/irq/manage.c
+++ b/kernel/irq/manage.c
@@ -547,14 +547,11 @@ int request_irq(unsigned int irq, irq_handler_t handler,
                  * We do this before actually registering it, to make sure that
                  * a 'real' IRQ doesn't run in parallel with our fake
                  */
-                if (irqflags & IRQF_DISABLED) {
-                        unsigned long flags;
+                unsigned long flags;
 
-                        local_irq_save(flags);
-                        handler(irq, dev_id);
-                        local_irq_restore(flags);
-                } else
-                        handler(irq, dev_id);
+                local_irq_save(flags);
+                handler(irq, dev_id);
+                local_irq_restore(flags);
         }
 #endif
 
diff --git a/kernel/power/Kconfig b/kernel/power/Kconfig
index 412859f8d94a..c8580a1e6873 100644
--- a/kernel/power/Kconfig
+++ b/kernel/power/Kconfig
@@ -72,15 +72,10 @@ config PM_TRACE
         CAUTION: this option will cause your machine's real-time clock to be
         set to an invalid time after a resume.
 
-config SUSPEND_SMP_POSSIBLE
-        bool
-        depends on (X86 && !X86_VOYAGER) || (PPC64 && (PPC_PSERIES || PPC_PMAC))
-        depends on SMP
-        default y
-
-config SUSPEND_SMP
+config PM_SLEEP_SMP
         bool
-        depends on SUSPEND_SMP_POSSIBLE && PM_SLEEP
+        depends on SUSPEND_SMP_POSSIBLE || HIBERNATION_SMP_POSSIBLE
+        depends on PM_SLEEP
         select HOTPLUG_CPU
         default y
 
@@ -89,20 +84,46 @@ config PM_SLEEP
         depends on SUSPEND || HIBERNATION
         default y
 
+config SUSPEND_UP_POSSIBLE
+        bool
+        depends on (X86 && !X86_VOYAGER) || PPC || ARM || BLACKFIN || MIPS \
+                   || SUPERH || FRV
+        depends on !SMP
+        default y
+
+config SUSPEND_SMP_POSSIBLE
+        bool
+        depends on (X86 && !X86_VOYAGER) \
+                   || (PPC && (PPC_PSERIES || PPC_PMAC)) || ARM
+        depends on SMP
+        default y
+
 config SUSPEND
         bool "Suspend to RAM and standby"
         depends on PM
-        depends on !SMP || SUSPEND_SMP_POSSIBLE
+        depends on SUSPEND_UP_POSSIBLE || SUSPEND_SMP_POSSIBLE
         default y
         ---help---
           Allow the system to enter sleep states in which main memory is
           powered and thus its contents are preserved, such as the
           suspend-to-RAM state (i.e. the ACPI S3 state).
 
+config HIBERNATION_UP_POSSIBLE
+        bool
+        depends on X86 || PPC64_SWSUSP || FRV || PPC32
+        depends on !SMP
+        default y
+
+config HIBERNATION_SMP_POSSIBLE
+        bool
+        depends on (X86 && !X86_VOYAGER) || PPC64_SWSUSP
+        depends on SMP
+        default y
+
 config HIBERNATION
         bool "Hibernation (aka 'suspend to disk')"
         depends on PM && SWAP
-        depends on ((X86 || PPC64_SWSUSP || FRV || PPC32) && !SMP) || SUSPEND_SMP_POSSIBLE
+        depends on HIBERNATION_UP_POSSIBLE || HIBERNATION_SMP_POSSIBLE
         ---help---
           Enable the suspend to disk (STD) functionality, which is usually
           called "hibernation" in user interfaces.  STD checkpoints the
diff --git a/kernel/sched.c b/kernel/sched.c
index 9fe473a190de..b533d6db78aa 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -1587,6 +1587,7 @@ static void __sched_fork(struct task_struct *p)
         p->se.wait_start_fair           = 0;
         p->se.exec_start                = 0;
         p->se.sum_exec_runtime          = 0;
+        p->se.prev_sum_exec_runtime     = 0;
         p->se.delta_exec                = 0;
         p->se.delta_fair_run            = 0;
         p->se.delta_fair_sleep          = 0;
diff --git a/kernel/sched_fair.c b/kernel/sched_fair.c
index ee3771850aaf..ce39282d9c0d 100644
--- a/kernel/sched_fair.c
+++ b/kernel/sched_fair.c
@@ -354,7 +354,7 @@ __update_curr(struct cfs_rq *cfs_rq, struct sched_entity *curr)
         delta_fair = calc_delta_fair(delta_exec, lw);
         delta_mine = calc_delta_mine(delta_exec, curr->load.weight, lw);
 
-        if (cfs_rq->sleeper_bonus > sysctl_sched_latency) {
+        if (cfs_rq->sleeper_bonus > sysctl_sched_min_granularity) {
                 delta = min((u64)delta_mine, cfs_rq->sleeper_bonus);
                 delta = min(delta, (unsigned long)(
                         (long)sysctl_sched_runtime_limit - curr->wait_runtime));
@@ -489,6 +489,9 @@ update_stats_wait_end(struct cfs_rq *cfs_rq, struct sched_entity *se)
 {
         unsigned long delta_fair;
 
+        if (unlikely(!se->wait_start_fair))
+                return;
+
         delta_fair = (unsigned long)min((u64)(2*sysctl_sched_runtime_limit),
                         (u64)(cfs_rq->fair_clock - se->wait_start_fair));
 
@@ -668,7 +671,7 @@ dequeue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int sleep)
 /*
  * Preempt the current task with a newly woken task if needed:
  */
-static void
+static int
 __check_preempt_curr_fair(struct cfs_rq *cfs_rq, struct sched_entity *se,
                           struct sched_entity *curr, unsigned long granularity)
 {
@@ -679,8 +682,11 @@ __check_preempt_curr_fair(struct cfs_rq *cfs_rq, struct sched_entity *se,
          * preempt the current task unless the best task has
          * a larger than sched_granularity fairness advantage:
          */
-        if (__delta > niced_granularity(curr, granularity))
+        if (__delta > niced_granularity(curr, granularity)) {
                 resched_task(rq_of(cfs_rq)->curr);
+                return 1;
+        }
+        return 0;
 }
 
 static inline void
@@ -725,6 +731,7 @@ static void put_prev_entity(struct cfs_rq *cfs_rq, struct sched_entity *prev)
 
 static void entity_tick(struct cfs_rq *cfs_rq, struct sched_entity *curr)
 {
+        unsigned long gran, ideal_runtime, delta_exec;
         struct sched_entity *next;
 
         /*
@@ -741,8 +748,22 @@ static void entity_tick(struct cfs_rq *cfs_rq, struct sched_entity *curr)
         if (next == curr)
                 return;
 
-        __check_preempt_curr_fair(cfs_rq, next, curr,
-                        sched_granularity(cfs_rq));
+        gran = sched_granularity(cfs_rq);
+        ideal_runtime = niced_granularity(curr,
+                max(sysctl_sched_latency / cfs_rq->nr_running,
+                    (unsigned long)sysctl_sched_min_granularity));
+        /*
+         * If we executed more than what the latency constraint suggests,
+         * reduce the rescheduling granularity. This way the total latency
+         * of how much a task is not scheduled converges to
+         * sysctl_sched_latency:
+         */
+        delta_exec = curr->sum_exec_runtime - curr->prev_sum_exec_runtime;
+        if (delta_exec > ideal_runtime)
+                gran = 0;
+
+        if (__check_preempt_curr_fair(cfs_rq, next, curr, gran))
+                curr->prev_sum_exec_runtime = curr->sum_exec_runtime;
 }
 
 /**************************************************
@@ -1076,31 +1097,34 @@ static void task_tick_fair(struct rq *rq, struct task_struct *curr)
 static void task_new_fair(struct rq *rq, struct task_struct *p)
 {
         struct cfs_rq *cfs_rq = task_cfs_rq(p);
-        struct sched_entity *se = &p->se;
+        struct sched_entity *se = &p->se, *curr = cfs_rq_curr(cfs_rq);
 
         sched_info_queued(p);
 
+        update_curr(cfs_rq);
         update_stats_enqueue(cfs_rq, se);
         /*
          * Child runs first: we let it run before the parent
          * until it reschedules once. We set up the key so that
          * it will preempt the parent:
          */
-        p->se.fair_key = current->se.fair_key -
-                niced_granularity(&rq->curr->se, sched_granularity(cfs_rq)) - 1;
+        se->fair_key = curr->fair_key -
+                niced_granularity(curr, sched_granularity(cfs_rq)) - 1;
         /*
          * The first wait is dominated by the child-runs-first logic,
          * so do not credit it with that waiting time yet:
          */
         if (sysctl_sched_features & SCHED_FEAT_SKIP_INITIAL)
-                p->se.wait_start_fair = 0;
+                se->wait_start_fair = 0;
 
         /*
          * The statistical average of wait_runtime is about
          * -granularity/2, so initialize the task with that:
          */
-        if (sysctl_sched_features & SCHED_FEAT_START_DEBIT)
-                p->se.wait_runtime = -(sched_granularity(cfs_rq) / 2);
+        if (sysctl_sched_features & SCHED_FEAT_START_DEBIT) {
+                se->wait_runtime = -(sched_granularity(cfs_rq) / 2);
+                schedstat_add(cfs_rq, wait_runtime, se->wait_runtime);
+        }
 
         __enqueue_entity(cfs_rq, se);
 }
diff --git a/kernel/signal.c b/kernel/signal.c
index ad63109e413c..3169bed0b4d0 100644
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -1300,20 +1300,19 @@ struct sigqueue *sigqueue_alloc(void)
 void sigqueue_free(struct sigqueue *q)
 {
         unsigned long flags;
+        spinlock_t *lock = &current->sighand->siglock;
+
         BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
         /*
          * If the signal is still pending remove it from the
-         * pending queue.
+         * pending queue. We must hold ->siglock while testing
+         * q->list to serialize with collect_signal().
          */
-        if (unlikely(!list_empty(&q->list))) {
-                spinlock_t *lock = &current->sighand->siglock;
-                read_lock(&tasklist_lock);
-                spin_lock_irqsave(lock, flags);
-                if (!list_empty(&q->list))
-                        list_del_init(&q->list);
-                spin_unlock_irqrestore(lock, flags);
-                read_unlock(&tasklist_lock);
-        }
+        spin_lock_irqsave(lock, flags);
+        if (!list_empty(&q->list))
+                list_del_init(&q->list);
+        spin_unlock_irqrestore(lock, flags);
+
         q->flags &= ~SIGQUEUE_PREALLOC;
         __sigqueue_free(q);
 }
diff --git a/kernel/sys.c b/kernel/sys.c
index 449b81b98b3d..1b33b05d346b 100644
--- a/kernel/sys.c
+++ b/kernel/sys.c
@@ -1442,7 +1442,6 @@ asmlinkage long sys_times(struct tms __user * tbuf)
  * Auch. Had to add the 'did_exec' flag to conform completely to POSIX.
  * LBT 04.03.94
  */
-
 asmlinkage long sys_setpgid(pid_t pid, pid_t pgid)
 {
         struct task_struct *p;
@@ -1470,7 +1469,7 @@ asmlinkage long sys_setpgid(pid_t pid, pid_t pgid)
         if (!thread_group_leader(p))
                 goto out;
 
-        if (p->real_parent == group_leader) {
+        if (p->real_parent->tgid == group_leader->tgid) {
                 err = -EPERM;
                 if (task_session(p) != task_session(group_leader))
                         goto out;
diff --git a/kernel/user_namespace.c b/kernel/user_namespace.c
index d055d987850c..85af9422ea6e 100644
--- a/kernel/user_namespace.c
+++ b/kernel/user_namespace.c
@@ -81,6 +81,7 @@ void free_user_ns(struct kref *kref)
         struct user_namespace *ns;
 
         ns = container_of(kref, struct user_namespace, kref);
+        free_uid(ns->root_user);
         kfree(ns);
 }