8 files changed, 114 insertions, 89 deletions

diff --git a/kernel/capability.c b/kernel/capability.c
index edb845a6e8..c8d3c77620 100644
--- a/kernel/capability.c
+++ b/kernel/capability.c
@@ -92,15 +92,17 @@ out:
  * cap_set_pg - set capabilities for all processes in a given process
  * group.  We call this holding task_capability_lock and tasklist_lock.
  */
-static inline int cap_set_pg(int pgrp, kernel_cap_t *effective,
+static inline int cap_set_pg(int pgrp_nr, kernel_cap_t *effective,
                               kernel_cap_t *inheritable,
                               kernel_cap_t *permitted)
 {
         struct task_struct *g, *target;
         int ret = -EPERM;
         int found = 0;
+        struct pid *pgrp;
 
-        do_each_task_pid(pgrp, PIDTYPE_PGID, g) {
+        pgrp = find_pid(pgrp_nr);
+        do_each_pid_task(pgrp, PIDTYPE_PGID, g) {
                 target = g;
                 while_each_thread(g, target) {
                         if (!security_capset_check(target, effective,
@@ -113,7 +115,7 @@ static inline int cap_set_pg(int pgrp, kernel_cap_t *effective,
                         }
                         found = 1;
                 }
-        } while_each_task_pid(pgrp, PIDTYPE_PGID, g);
+        } while_each_pid_task(pgrp, PIDTYPE_PGID, g);
 
         if (!found)
              ret = 0;
diff --git a/kernel/cpuset.c b/kernel/cpuset.c
index 6b05dc69c9..f382b0f775 100644
--- a/kernel/cpuset.c
+++ b/kernel/cpuset.c
@@ -1540,7 +1540,7 @@ static const struct file_operations cpuset_file_operations = {
         .release = cpuset_file_release,
 };
 
-static struct inode_operations cpuset_dir_inode_operations = {
+static const struct inode_operations cpuset_dir_inode_operations = {
         .lookup = simple_lookup,
         .mkdir = cpuset_mkdir,
         .rmdir = cpuset_rmdir,
@@ -2656,7 +2656,7 @@ static int cpuset_open(struct inode *inode, struct file *file)
         return single_open(file, proc_cpuset_show, pid);
 }
 
-struct file_operations proc_cpuset_operations = {
+const struct file_operations proc_cpuset_operations = {
         .open           = cpuset_open,
         .read           = seq_read,
         .llseek         = seq_lseek,
diff --git a/kernel/exit.c b/kernel/exit.c
index bc71fdfcd8..f132349c03 100644
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -185,21 +185,19 @@ repeat:
  * This checks not only the pgrp, but falls back on the pid if no
  * satisfactory pgrp is found. I dunno - gdb doesn't work correctly
  * without this...
+ *
+ * The caller must hold rcu lock or the tasklist lock.
  */
-int session_of_pgrp(int pgrp)
+struct pid *session_of_pgrp(struct pid *pgrp)
 {
         struct task_struct *p;
-        int sid = 0;
-
-        read_lock(&tasklist_lock);
+        struct pid *sid = NULL;
 
-        p = find_task_by_pid_type(PIDTYPE_PGID, pgrp);
+        p = pid_task(pgrp, PIDTYPE_PGID);
         if (p == NULL)
-                p = find_task_by_pid(pgrp);
+                p = pid_task(pgrp, PIDTYPE_PID);
         if (p != NULL)
-                sid = process_session(p);
-
-        read_unlock(&tasklist_lock);
+                sid = task_session(p);
 
         return sid;
 }
@@ -212,47 +210,47 @@ int session_of_pgrp(int pgrp)
  *
  * "I ask you, have you ever known what it is to be an orphan?"
  */
-static int will_become_orphaned_pgrp(int pgrp, struct task_struct *ignored_task)
+static int will_become_orphaned_pgrp(struct pid *pgrp, struct task_struct *ignored_task)
 {
         struct task_struct *p;
         int ret = 1;
 
-        do_each_task_pid(pgrp, PIDTYPE_PGID, p) {
+        do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
                 if (p == ignored_task
                                 || p->exit_state
                                 || is_init(p->real_parent))
                         continue;
-                if (process_group(p->real_parent) != pgrp &&
-                    process_session(p->real_parent) == process_session(p)) {
+                if (task_pgrp(p->real_parent) != pgrp &&
+                    task_session(p->real_parent) == task_session(p)) {
                         ret = 0;
                         break;
                 }
-        } while_each_task_pid(pgrp, PIDTYPE_PGID, p);
+        } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
         return ret;     /* (sighing) "Often!" */
 }
 
-int is_orphaned_pgrp(int pgrp)
+int is_current_pgrp_orphaned(void)
 {
         int retval;
 
         read_lock(&tasklist_lock);
-        retval = will_become_orphaned_pgrp(pgrp, NULL);
+        retval = will_become_orphaned_pgrp(task_pgrp(current), NULL);
         read_unlock(&tasklist_lock);
 
         return retval;
 }
 
-static int has_stopped_jobs(int pgrp)
+static int has_stopped_jobs(struct pid *pgrp)
 {
         int retval = 0;
         struct task_struct *p;
 
-        do_each_task_pid(pgrp, PIDTYPE_PGID, p) {
+        do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
                 if (p->state != TASK_STOPPED)
                         continue;
                 retval = 1;
                 break;
-        } while_each_task_pid(pgrp, PIDTYPE_PGID, p);
+        } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
         return retval;
 }
 
@@ -430,8 +428,10 @@ static void close_files(struct files_struct * files)
                 while (set) {
                         if (set & 1) {
                                 struct file * file = xchg(&fdt->fd[i], NULL);
-                                if (file)
+                                if (file) {
                                         filp_close(file, files);
+                                        cond_resched();
+                                }
                         }
                         i++;
                         set >>= 1;
@@ -648,14 +648,14 @@ reparent_thread(struct task_struct *p, struct task_struct *father, int traced)
          * than we are, and it was the only connection
          * outside, so the child pgrp is now orphaned.
          */
-        if ((process_group(p) != process_group(father)) &&
-            (process_session(p) == process_session(father))) {
-                int pgrp = process_group(p);
+        if ((task_pgrp(p) != task_pgrp(father)) &&
+            (task_session(p) == task_session(father))) {
+                struct pid *pgrp = task_pgrp(p);
 
                 if (will_become_orphaned_pgrp(pgrp, NULL) &&
                     has_stopped_jobs(pgrp)) {
-                        __kill_pg_info(SIGHUP, SEND_SIG_PRIV, pgrp);
-                        __kill_pg_info(SIGCONT, SEND_SIG_PRIV, pgrp);
+                        __kill_pgrp_info(SIGHUP, SEND_SIG_PRIV, pgrp);
+                        __kill_pgrp_info(SIGCONT, SEND_SIG_PRIV, pgrp);
                 }
         }
 }
@@ -735,6 +735,7 @@ static void exit_notify(struct task_struct *tsk)
         int state;
         struct task_struct *t;
         struct list_head ptrace_dead, *_p, *_n;
+        struct pid *pgrp;
 
         if (signal_pending(tsk) && !(tsk->signal->flags & SIGNAL_GROUP_EXIT)
             && !thread_group_empty(tsk)) {
@@ -787,12 +788,13 @@ static void exit_notify(struct task_struct *tsk)
          
         t = tsk->real_parent;
         
-        if ((process_group(t) != process_group(tsk)) &&
-            (process_session(t) == process_session(tsk)) &&
-            will_become_orphaned_pgrp(process_group(tsk), tsk) &&
-            has_stopped_jobs(process_group(tsk))) {
-                __kill_pg_info(SIGHUP, SEND_SIG_PRIV, process_group(tsk));
-                __kill_pg_info(SIGCONT, SEND_SIG_PRIV, process_group(tsk));
+        pgrp = task_pgrp(tsk);
+        if ((task_pgrp(t) != pgrp) &&
+            (task_session(t) != task_session(tsk)) &&
+            will_become_orphaned_pgrp(pgrp, tsk) &&
+            has_stopped_jobs(pgrp)) {
+                __kill_pgrp_info(SIGHUP, SEND_SIG_PRIV, pgrp);
+                __kill_pgrp_info(SIGCONT, SEND_SIG_PRIV, pgrp);
         }
 
         /* Let father know we died 
diff --git a/kernel/fork.c b/kernel/fork.c
index 80284eb488..0b6293d94d 100644
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -869,7 +869,7 @@ static inline int copy_signal(unsigned long clone_flags, struct task_struct * ts
         sig->it_prof_incr = cputime_zero;
 
         sig->leader = 0;        /* session leadership doesn't inherit */
-        sig->tty_old_pgrp = 0;
+        sig->tty_old_pgrp = NULL;
 
         sig->utime = sig->stime = sig->cutime = sig->cstime = cputime_zero;
         sig->nvcsw = sig->nivcsw = sig->cnvcsw = sig->cnivcsw = 0;
diff --git a/kernel/irq/manage.c b/kernel/irq/manage.c
index 8b961adc3b..7c85d69188 100644
--- a/kernel/irq/manage.c
+++ b/kernel/irq/manage.c
@@ -328,12 +328,14 @@ int setup_irq(unsigned int irq, struct irqaction *new)
         return 0;
 
 mismatch:
+#ifdef CONFIG_DEBUG_SHIRQ
         if (!(new->flags & IRQF_PROBE_SHARED)) {
                 printk(KERN_ERR "IRQ handler type mismatch for IRQ %d\n", irq);
                 if (old_name)
                         printk(KERN_ERR "current handler: %s\n", old_name);
                 dump_stack();
         }
+#endif
         spin_unlock_irqrestore(&desc->lock, flags);
         return -EBUSY;
 }
@@ -357,6 +359,7 @@ void free_irq(unsigned int irq, void *dev_id)
         struct irq_desc *desc;
         struct irqaction **p;
         unsigned long flags;
+        irqreturn_t (*handler)(int, void *) = NULL;
 
         WARN_ON(in_interrupt());
         if (irq >= NR_IRQS)
@@ -396,6 +399,8 @@ void free_irq(unsigned int irq, void *dev_id)
 
                         /* Make sure it's not being used on another CPU */
                         synchronize_irq(irq);
+                        if (action->flags & IRQF_SHARED)
+                                handler = action->handler;
                         kfree(action);
                         return;
                 }
@@ -403,6 +408,17 @@ void free_irq(unsigned int irq, void *dev_id)
                 spin_unlock_irqrestore(&desc->lock, flags);
                 return;
         }
+#ifdef CONFIG_DEBUG_SHIRQ
+        if (handler) {
+                /*
+                 * It's a shared IRQ -- the driver ought to be prepared for it
+                 * to happen even now it's being freed, so let's make sure....
+                 * We do this after actually deregistering it, to make sure that
+                 * a 'real' IRQ doesn't run in parallel with our fake
+                 */
+                handler(irq, dev_id);
+        }
+#endif
 }
 EXPORT_SYMBOL(free_irq);
 
@@ -475,6 +491,25 @@ int request_irq(unsigned int irq, irq_handler_t handler,
 
         select_smp_affinity(irq);
 
+#ifdef CONFIG_DEBUG_SHIRQ
+        if (irqflags & IRQF_SHARED) {
+                /*
+                 * It's a shared IRQ -- the driver ought to be prepared for it
+                 * to happen immediately, so let's make sure....
+                 * 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;
+
+                        local_irq_save(flags);
+                        handler(irq, dev_id);
+                        local_irq_restore(flags);
+                } else
+                        handler(irq, dev_id);
+        }
+#endif
+
         retval = setup_irq(irq, action);
         if (retval)
                 kfree(action);
diff --git a/kernel/sched.c b/kernel/sched.c
index 1fd67e16cd..08f86178aa 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -2897,14 +2897,16 @@ static void active_load_balance(struct rq *busiest_rq, int busiest_cpu)
 static void update_load(struct rq *this_rq)
 {
         unsigned long this_load;
-        int i, scale;
+        unsigned int i, scale;
 
         this_load = this_rq->raw_weighted_load;
 
         /* Update our load: */
-        for (i = 0, scale = 1; i < 3; i++, scale <<= 1) {
+        for (i = 0, scale = 1; i < 3; i++, scale += scale) {
                 unsigned long old_load, new_load;
 
+                /* scale is effectively 1 << i now, and >> i divides by scale */
+
                 old_load = this_rq->cpu_load[i];
                 new_load = this_load;
                 /*
@@ -2914,7 +2916,7 @@ static void update_load(struct rq *this_rq)
                  */
                 if (new_load > old_load)
                         new_load += scale-1;
-                this_rq->cpu_load[i] = (old_load*(scale-1) + new_load) / scale;
+                this_rq->cpu_load[i] = (old_load*(scale-1) + new_load) >> i;
         }
 }
 
diff --git a/kernel/signal.c b/kernel/signal.c
index 228fdb5c01..8072e568bb 100644
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -1096,26 +1096,6 @@ int kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp)
         return retval;
 }
 
-int __kill_pg_info(int sig, struct siginfo *info, pid_t pgrp)
-{
-        if (pgrp <= 0)
-                return -EINVAL;
-
-        return __kill_pgrp_info(sig, info, find_pid(pgrp));
-}
-
-int
-kill_pg_info(int sig, struct siginfo *info, pid_t pgrp)
-{
-        int retval;
-
-        read_lock(&tasklist_lock);
-        retval = __kill_pg_info(sig, info, pgrp);
-        read_unlock(&tasklist_lock);
-
-        return retval;
-}
-
 int kill_pid_info(int sig, struct siginfo *info, struct pid *pid)
 {
         int error;
@@ -1191,8 +1171,10 @@ EXPORT_SYMBOL_GPL(kill_pid_info_as_uid);
 
 static int kill_something_info(int sig, struct siginfo *info, int pid)
 {
+        int ret;
+        rcu_read_lock();
         if (!pid) {
-                return kill_pg_info(sig, info, process_group(current));
+                ret = kill_pgrp_info(sig, info, task_pgrp(current));
         } else if (pid == -1) {
                 int retval = 0, count = 0;
                 struct task_struct * p;
@@ -1207,12 +1189,14 @@ static int kill_something_info(int sig, struct siginfo *info, int pid)
                         }
                 }
                 read_unlock(&tasklist_lock);
-                return count ? retval : -ESRCH;
+                ret = count ? retval : -ESRCH;
         } else if (pid < 0) {
-                return kill_pg_info(sig, info, -pid);
+                ret = kill_pgrp_info(sig, info, find_pid(-pid));
         } else {
-                return kill_proc_info(sig, info, pid);
+                ret = kill_pid_info(sig, info, find_pid(pid));
         }
+        rcu_read_unlock();
+        return ret;
 }
 
 /*
@@ -1311,12 +1295,6 @@ int kill_pid(struct pid *pid, int sig, int priv)
 EXPORT_SYMBOL(kill_pid);
 
 int
-kill_pg(pid_t pgrp, int sig, int priv)
-{
-        return kill_pg_info(sig, __si_special(priv), pgrp);
-}
-
-int
 kill_proc(pid_t pid, int sig, int priv)
 {
         return kill_proc_info(sig, __si_special(priv), pid);
@@ -1905,7 +1883,7 @@ relock:
 
                                 /* signals can be posted during this window */
 
-                                if (is_orphaned_pgrp(process_group(current)))
+                                if (is_current_pgrp_orphaned())
                                         goto relock;
 
                                 spin_lock_irq(&current->sighand->siglock);
@@ -1955,7 +1933,6 @@ EXPORT_SYMBOL(recalc_sigpending);
 EXPORT_SYMBOL_GPL(dequeue_signal);
 EXPORT_SYMBOL(flush_signals);
 EXPORT_SYMBOL(force_sig);
-EXPORT_SYMBOL(kill_pg);
 EXPORT_SYMBOL(kill_proc);
 EXPORT_SYMBOL(ptrace_notify);
 EXPORT_SYMBOL(send_sig);
diff --git a/kernel/sys.c b/kernel/sys.c
index e102438331..123b165080 100644
--- a/kernel/sys.c
+++ b/kernel/sys.c
@@ -596,6 +596,7 @@ asmlinkage long sys_setpriority(int which, int who, int niceval)
         struct task_struct *g, *p;
         struct user_struct *user;
         int error = -EINVAL;
+        struct pid *pgrp;
 
         if (which > 2 || which < 0)
                 goto out;
@@ -610,18 +611,21 @@ asmlinkage long sys_setpriority(int which, int who, int niceval)
         read_lock(&tasklist_lock);
         switch (which) {
                 case PRIO_PROCESS:
-                        if (!who)
-                                who = current->pid;
-                        p = find_task_by_pid(who);
+                        if (who)
+                                p = find_task_by_pid(who);
+                        else
+                                p = current;
                         if (p)
                                 error = set_one_prio(p, niceval, error);
                         break;
                 case PRIO_PGRP:
-                        if (!who)
-                                who = process_group(current);
-                        do_each_task_pid(who, PIDTYPE_PGID, p) {
+                        if (who)
+                                pgrp = find_pid(who);
+                        else
+                                pgrp = task_pgrp(current);
+                        do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
                                 error = set_one_prio(p, niceval, error);
-                        } while_each_task_pid(who, PIDTYPE_PGID, p);
+                        } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
                         break;
                 case PRIO_USER:
                         user = current->user;
@@ -656,6 +660,7 @@ asmlinkage long sys_getpriority(int which, int who)
         struct task_struct *g, *p;
         struct user_struct *user;
         long niceval, retval = -ESRCH;
+        struct pid *pgrp;
 
         if (which > 2 || which < 0)
                 return -EINVAL;
@@ -663,9 +668,10 @@ asmlinkage long sys_getpriority(int which, int who)
         read_lock(&tasklist_lock);
         switch (which) {
                 case PRIO_PROCESS:
-                        if (!who)
-                                who = current->pid;
-                        p = find_task_by_pid(who);
+                        if (who)
+                                p = find_task_by_pid(who);
+                        else
+                                p = current;
                         if (p) {
                                 niceval = 20 - task_nice(p);
                                 if (niceval > retval)
@@ -673,13 +679,15 @@ asmlinkage long sys_getpriority(int which, int who)
                         }
                         break;
                 case PRIO_PGRP:
-                        if (!who)
-                                who = process_group(current);
-                        do_each_task_pid(who, PIDTYPE_PGID, p) {
+                        if (who)
+                                pgrp = find_pid(who);
+                        else
+                                pgrp = task_pgrp(current);
+                        do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
                                 niceval = 20 - task_nice(p);
                                 if (niceval > retval)
                                         retval = niceval;
-                        } while_each_task_pid(who, PIDTYPE_PGID, p);
+                        } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
                         break;
                 case PRIO_USER:
                         user = current->user;
@@ -1388,7 +1396,7 @@ asmlinkage long sys_setpgid(pid_t pid, pid_t pgid)
 
         if (p->real_parent == group_leader) {
                 err = -EPERM;
-                if (process_session(p) != process_session(group_leader))
+                if (task_session(p) != task_session(group_leader))
                         goto out;
                 err = -EACCES;
                 if (p->did_exec)
@@ -1407,7 +1415,7 @@ asmlinkage long sys_setpgid(pid_t pid, pid_t pgid)
                 struct task_struct *g =
                         find_task_by_pid_type(PIDTYPE_PGID, pgid);
 
-                if (!g || process_session(g) != process_session(group_leader))
+                if (!g || task_session(g) != task_session(group_leader))
                         goto out;
         }
 
@@ -1510,7 +1518,6 @@ asmlinkage long sys_setsid(void)
 
         spin_lock(&group_leader->sighand->siglock);
         group_leader->signal->tty = NULL;
-        group_leader->signal->tty_old_pgrp = 0;
         spin_unlock(&group_leader->sighand->siglock);
 
         err = process_group(group_leader);