19 files changed, 226 insertions, 126 deletions

diff --git a/kernel/acct.c b/kernel/acct.c
index 6802020e0ceb..368c4f03fe0e 100644
--- a/kernel/acct.c
+++ b/kernel/acct.c
@@ -75,7 +75,7 @@ int acct_parm[3] = {4, 2, 30};
 /*
  * External references and all of the globals.
  */
-static void do_acct_process(long, struct file *);
+static void do_acct_process(struct file *);
 
 /*
  * This structure is used so that all the data protected by lock
@@ -196,7 +196,7 @@ static void acct_file_reopen(struct file *file)
         if (old_acct) {
                 mnt_unpin(old_acct->f_vfsmnt);
                 spin_unlock(&acct_globals.lock);
-                do_acct_process(0, old_acct);
+                do_acct_process(old_acct);
                 filp_close(old_acct, NULL);
                 spin_lock(&acct_globals.lock);
         }
@@ -419,16 +419,15 @@ static u32 encode_float(u64 value)
 /*
  *  do_acct_process does all actual work. Caller holds the reference to file.
  */
-static void do_acct_process(long exitcode, struct file *file)
+static void do_acct_process(struct file *file)
 {
+        struct pacct_struct *pacct = &current->signal->pacct;
         acct_t ac;
         mm_segment_t fs;
-        unsigned long vsize;
         unsigned long flim;
         u64 elapsed;
         u64 run_time;
         struct timespec uptime;
-        unsigned long jiffies;
 
         /*
          * First check to see if there is enough free_space to continue
@@ -469,12 +468,6 @@ static void do_acct_process(long exitcode, struct file *file)
 #endif
         do_div(elapsed, AHZ);
         ac.ac_btime = xtime.tv_sec - elapsed;
-        jiffies = cputime_to_jiffies(cputime_add(current->utime,
-                                                 current->signal->utime));
-        ac.ac_utime = encode_comp_t(jiffies_to_AHZ(jiffies));
-        jiffies = cputime_to_jiffies(cputime_add(current->stime,
-                                                 current->signal->stime));
-        ac.ac_stime = encode_comp_t(jiffies_to_AHZ(jiffies));
         /* we really need to bite the bullet and change layout */
         ac.ac_uid = current->uid;
         ac.ac_gid = current->gid;
@@ -496,37 +489,18 @@ static void do_acct_process(long exitcode, struct file *file)
                 old_encode_dev(tty_devnum(current->signal->tty)) : 0;
         read_unlock(&tasklist_lock);
 
-        ac.ac_flag = 0;
-        if (current->flags & PF_FORKNOEXEC)
-                ac.ac_flag |= AFORK;
-        if (current->flags & PF_SUPERPRIV)
-                ac.ac_flag |= ASU;
-        if (current->flags & PF_DUMPCORE)
-                ac.ac_flag |= ACORE;
-        if (current->flags & PF_SIGNALED)
-                ac.ac_flag |= AXSIG;
-
-        vsize = 0;
-        if (current->mm) {
-                struct vm_area_struct *vma;
-                down_read(&current->mm->mmap_sem);
-                vma = current->mm->mmap;
-                while (vma) {
-                        vsize += vma->vm_end - vma->vm_start;
-                        vma = vma->vm_next;
-                }
-                up_read(&current->mm->mmap_sem);
-        }
-        vsize = vsize / 1024;
-        ac.ac_mem = encode_comp_t(vsize);
+        spin_lock(&current->sighand->siglock);
+        ac.ac_utime = encode_comp_t(jiffies_to_AHZ(cputime_to_jiffies(pacct->ac_utime)));
+        ac.ac_stime = encode_comp_t(jiffies_to_AHZ(cputime_to_jiffies(pacct->ac_stime)));
+        ac.ac_flag = pacct->ac_flag;
+        ac.ac_mem = encode_comp_t(pacct->ac_mem);
+        ac.ac_minflt = encode_comp_t(pacct->ac_minflt);
+        ac.ac_majflt = encode_comp_t(pacct->ac_majflt);
+        ac.ac_exitcode = pacct->ac_exitcode;
+        spin_unlock(&current->sighand->siglock);
         ac.ac_io = encode_comp_t(0 /* current->io_usage */);    /* %% */
         ac.ac_rw = encode_comp_t(ac.ac_io / 1024);
-        ac.ac_minflt = encode_comp_t(current->signal->min_flt +
-                                     current->min_flt);
-        ac.ac_majflt = encode_comp_t(current->signal->maj_flt +
-                                     current->maj_flt);
         ac.ac_swaps = encode_comp_t(0);
-        ac.ac_exitcode = exitcode;
 
         /*
          * Kernel segment override to datasegment and write it
@@ -546,12 +520,63 @@ static void do_acct_process(long exitcode, struct file *file)
 }
 
 /**
+ * acct_init_pacct - initialize a new pacct_struct
+ */
+void acct_init_pacct(struct pacct_struct *pacct)
+{
+        memset(pacct, 0, sizeof(struct pacct_struct));
+        pacct->ac_utime = pacct->ac_stime = cputime_zero;
+}
+
+/**
+ * acct_collect - collect accounting information into pacct_struct
+ * @exitcode: task exit code
+ * @group_dead: not 0, if this thread is the last one in the process.
+ */
+void acct_collect(long exitcode, int group_dead)
+{
+        struct pacct_struct *pacct = &current->signal->pacct;
+        unsigned long vsize = 0;
+
+        if (group_dead && current->mm) {
+                struct vm_area_struct *vma;
+                down_read(&current->mm->mmap_sem);
+                vma = current->mm->mmap;
+                while (vma) {
+                        vsize += vma->vm_end - vma->vm_start;
+                        vma = vma->vm_next;
+                }
+                up_read(&current->mm->mmap_sem);
+        }
+
+        spin_lock_irq(&current->sighand->siglock);
+        if (group_dead)
+                pacct->ac_mem = vsize / 1024;
+        if (thread_group_leader(current)) {
+                pacct->ac_exitcode = exitcode;
+                if (current->flags & PF_FORKNOEXEC)
+                        pacct->ac_flag |= AFORK;
+        }
+        if (current->flags & PF_SUPERPRIV)
+                pacct->ac_flag |= ASU;
+        if (current->flags & PF_DUMPCORE)
+                pacct->ac_flag |= ACORE;
+        if (current->flags & PF_SIGNALED)
+                pacct->ac_flag |= AXSIG;
+        pacct->ac_utime = cputime_add(pacct->ac_utime, current->utime);
+        pacct->ac_stime = cputime_add(pacct->ac_stime, current->stime);
+        pacct->ac_minflt += current->min_flt;
+        pacct->ac_majflt += current->maj_flt;
+        spin_unlock_irq(&current->sighand->siglock);
+}
+
+/**
  * acct_process - now just a wrapper around do_acct_process
  * @exitcode: task exit code
  *
  * handles process accounting for an exiting task
  */
-void acct_process(long exitcode)
+void acct_process()
 {
         struct file *file = NULL;
 
@@ -570,7 +595,7 @@ void acct_process(long exitcode)
         get_file(file);
         spin_unlock(&acct_globals.lock);
 
-        do_acct_process(exitcode, file);
+        do_acct_process(file);
         fput(file);
 }
 
@@ -599,9 +624,7 @@ void acct_update_integrals(struct task_struct *tsk)
  */
 void acct_clear_integrals(struct task_struct *tsk)
 {
-        if (tsk) {
-                tsk->acct_stimexpd = 0;
-                tsk->acct_rss_mem1 = 0;
-                tsk->acct_vm_mem1 = 0;
-        }
+        tsk->acct_stimexpd = 0;
+        tsk->acct_rss_mem1 = 0;
+        tsk->acct_vm_mem1 = 0;
 }
diff --git a/kernel/compat.c b/kernel/compat.c
index 2f672332430f..126dee9530aa 100644
--- a/kernel/compat.c
+++ b/kernel/compat.c
@@ -730,17 +730,10 @@ void
 sigset_from_compat (sigset_t *set, compat_sigset_t *compat)
 {
         switch (_NSIG_WORDS) {
-#if defined (__COMPAT_ENDIAN_SWAP__)
-        case 4: set->sig[3] = compat->sig[7] | (((long)compat->sig[6]) << 32 );
-        case 3: set->sig[2] = compat->sig[5] | (((long)compat->sig[4]) << 32 );
-        case 2: set->sig[1] = compat->sig[3] | (((long)compat->sig[2]) << 32 );
-        case 1: set->sig[0] = compat->sig[1] | (((long)compat->sig[0]) << 32 );
-#else
         case 4: set->sig[3] = compat->sig[6] | (((long)compat->sig[7]) << 32 );
         case 3: set->sig[2] = compat->sig[4] | (((long)compat->sig[5]) << 32 );
         case 2: set->sig[1] = compat->sig[2] | (((long)compat->sig[3]) << 32 );
         case 1: set->sig[0] = compat->sig[0] | (((long)compat->sig[1]) << 32 );
-#endif
         }
 }
 
diff --git a/kernel/exit.c b/kernel/exit.c
index a3baf92462bd..e76bd02e930e 100644
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -36,6 +36,7 @@
 #include <linux/compat.h>
 #include <linux/pipe_fs_i.h>
 #include <linux/audit.h> /* for audit_free() */
+#include <linux/resource.h>
 
 #include <asm/uaccess.h>
 #include <asm/unistd.h>
@@ -45,8 +46,6 @@
 extern void sem_exit (void);
 extern struct task_struct *child_reaper;
 
-int getrusage(struct task_struct *, int, struct rusage __user *);
-
 static void exit_mm(struct task_struct * tsk);
 
 static void __unhash_process(struct task_struct *p)
@@ -895,11 +894,11 @@ fastcall NORET_TYPE void do_exit(long code)
         if (group_dead) {
                 hrtimer_cancel(&tsk->signal->real_timer);
                 exit_itimers(tsk->signal);
-                acct_process(code);
         }
+        acct_collect(code, group_dead);
         if (unlikely(tsk->robust_list))
                 exit_robust_list(tsk);
-#ifdef CONFIG_COMPAT
+#if defined(CONFIG_FUTEX) && defined(CONFIG_COMPAT)
         if (unlikely(tsk->compat_robust_list))
                 compat_exit_robust_list(tsk);
 #endif
@@ -907,6 +906,8 @@ fastcall NORET_TYPE void do_exit(long code)
                 audit_free(tsk);
         exit_mm(tsk);
 
+        if (group_dead)
+                acct_process();
         exit_sem(tsk);
         __exit_files(tsk);
         __exit_fs(tsk);
diff --git a/kernel/fork.c b/kernel/fork.c
index 49adc0e8d47c..dfd10cb370c3 100644
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -874,6 +874,7 @@ static inline int copy_signal(unsigned long clone_flags, struct task_struct * ts
                 tsk->it_prof_expires =
                         secs_to_cputime(sig->rlim[RLIMIT_CPU].rlim_cur);
         }
+        acct_init_pacct(&sig->pacct);
 
         return 0;
 }
diff --git a/kernel/hrtimer.c b/kernel/hrtimer.c
index 18324305724a..55601b3ce60e 100644
--- a/kernel/hrtimer.c
+++ b/kernel/hrtimer.c
@@ -98,7 +98,6 @@ static DEFINE_PER_CPU(struct hrtimer_base, hrtimer_bases[MAX_HRTIMER_BASES]) =
 
 /**
  * ktime_get_ts - get the monotonic clock in timespec format
- *
  * @ts:         pointer to timespec variable
  *
  * The function calculates the monotonic clock from the realtime
@@ -238,7 +237,6 @@ lock_hrtimer_base(const struct hrtimer *timer, unsigned long *flags)
 # ifndef CONFIG_KTIME_SCALAR
 /**
  * ktime_add_ns - Add a scalar nanoseconds value to a ktime_t variable
- *
  * @kt:         addend
  * @nsec:       the scalar nsec value to add
  *
@@ -299,7 +297,6 @@ void unlock_hrtimer_base(const struct hrtimer *timer, unsigned long *flags)
 
 /**
  * hrtimer_forward - forward the timer expiry
- *
  * @timer:      hrtimer to forward
  * @now:        forward past this time
  * @interval:   the interval to forward
@@ -411,7 +408,6 @@ remove_hrtimer(struct hrtimer *timer, struct hrtimer_base *base)
 
 /**
  * hrtimer_start - (re)start an relative timer on the current CPU
- *
  * @timer:      the timer to be added
  * @tim:        expiry time
  * @mode:       expiry mode: absolute (HRTIMER_ABS) or relative (HRTIMER_REL)
@@ -460,14 +456,13 @@ EXPORT_SYMBOL_GPL(hrtimer_start);
 
 /**
  * hrtimer_try_to_cancel - try to deactivate a timer
- *
  * @timer:      hrtimer to stop
  *
  * Returns:
  *  0 when the timer was not active
  *  1 when the timer was active
  * -1 when the timer is currently excuting the callback function and
- *    can not be stopped
+ *    cannot be stopped
  */
 int hrtimer_try_to_cancel(struct hrtimer *timer)
 {
@@ -489,7 +484,6 @@ EXPORT_SYMBOL_GPL(hrtimer_try_to_cancel);
 
 /**
  * hrtimer_cancel - cancel a timer and wait for the handler to finish.
- *
  * @timer:      the timer to be cancelled
  *
  * Returns:
@@ -510,7 +504,6 @@ EXPORT_SYMBOL_GPL(hrtimer_cancel);
 
 /**
  * hrtimer_get_remaining - get remaining time for the timer
- *
  * @timer:      the timer to read
  */
 ktime_t hrtimer_get_remaining(const struct hrtimer *timer)
@@ -564,7 +557,6 @@ ktime_t hrtimer_get_next_event(void)
 
 /**
  * hrtimer_init - initialize a timer to the given clock
- *
  * @timer:      the timer to be initialized
  * @clock_id:   the clock to be used
  * @mode:       timer mode abs/rel
@@ -576,7 +568,7 @@ void hrtimer_init(struct hrtimer *timer, clockid_t clock_id,
 
         memset(timer, 0, sizeof(struct hrtimer));
 
-        bases = per_cpu(hrtimer_bases, raw_smp_processor_id());
+        bases = __raw_get_cpu_var(hrtimer_bases);
 
         if (clock_id == CLOCK_REALTIME && mode != HRTIMER_ABS)
                 clock_id = CLOCK_MONOTONIC;
@@ -588,7 +580,6 @@ EXPORT_SYMBOL_GPL(hrtimer_init);
 
 /**
  * hrtimer_get_res - get the timer resolution for a clock
- *
  * @which_clock: which clock to query
  * @tp:          pointer to timespec variable to store the resolution
  *
@@ -599,7 +590,7 @@ int hrtimer_get_res(const clockid_t which_clock, struct timespec *tp)
 {
         struct hrtimer_base *bases;
 
-        bases = per_cpu(hrtimer_bases, raw_smp_processor_id());
+        bases = __raw_get_cpu_var(hrtimer_bases);
         *tp = ktime_to_timespec(bases[which_clock].resolution);
 
         return 0;
diff --git a/kernel/kthread.c b/kernel/kthread.c
index c5f3c6613b6d..24be714b04c7 100644
--- a/kernel/kthread.c
+++ b/kernel/kthread.c
@@ -45,6 +45,13 @@ struct kthread_stop_info
 static DEFINE_MUTEX(kthread_stop_lock);
 static struct kthread_stop_info kthread_stop_info;
 
+/**
+ * kthread_should_stop - should this kthread return now?
+ *
+ * When someone calls kthread_stop on your kthread, it will be woken
+ * and this will return true.  You should then return, and your return
+ * value will be passed through to kthread_stop().
+ */
 int kthread_should_stop(void)
 {
         return (kthread_stop_info.k == current);
@@ -122,6 +129,25 @@ static void keventd_create_kthread(void *_create)
         complete(&create->done);
 }
 
+/**
+ * kthread_create - create a kthread.
+ * @threadfn: the function to run until signal_pending(current).
+ * @data: data ptr for @threadfn.
+ * @namefmt: printf-style name for the thread.
+ *
+ * Description: This helper function creates and names a kernel
+ * thread.  The thread will be stopped: use wake_up_process() to start
+ * it.  See also kthread_run(), kthread_create_on_cpu().
+ *
+ * When woken, the thread will run @threadfn() with @data as its
+ * argument. @threadfn can either call do_exit() directly if it is a
+ * standalone thread for which noone will call kthread_stop(), or
+ * return when 'kthread_should_stop()' is true (which means
+ * kthread_stop() has been called).  The return value should be zero
+ * or a negative error number; it will be passed to kthread_stop().
+ *
+ * Returns a task_struct or ERR_PTR(-ENOMEM).
+ */
 struct task_struct *kthread_create(int (*threadfn)(void *data),
                                    void *data,
                                    const char namefmt[],
@@ -156,6 +182,15 @@ struct task_struct *kthread_create(int (*threadfn)(void *data),
 }
 EXPORT_SYMBOL(kthread_create);
 
+/**
+ * kthread_bind - bind a just-created kthread to a cpu.
+ * @k: thread created by kthread_create().
+ * @cpu: cpu (might not be online, must be possible) for @k to run on.
+ *
+ * Description: This function is equivalent to set_cpus_allowed(),
+ * except that @cpu doesn't need to be online, and the thread must be
+ * stopped (i.e., just returned from kthread_create().
+ */
 void kthread_bind(struct task_struct *k, unsigned int cpu)
 {
         BUG_ON(k->state != TASK_INTERRUPTIBLE);
@@ -166,12 +201,36 @@ void kthread_bind(struct task_struct *k, unsigned int cpu)
 }
 EXPORT_SYMBOL(kthread_bind);
 
+/**
+ * kthread_stop - stop a thread created by kthread_create().
+ * @k: thread created by kthread_create().
+ *
+ * Sets kthread_should_stop() for @k to return true, wakes it, and
+ * waits for it to exit.  Your threadfn() must not call do_exit()
+ * itself if you use this function!  This can also be called after
+ * kthread_create() instead of calling wake_up_process(): the thread
+ * will exit without calling threadfn().
+ *
+ * Returns the result of threadfn(), or %-EINTR if wake_up_process()
+ * was never called.
+ */
 int kthread_stop(struct task_struct *k)
 {
         return kthread_stop_sem(k, NULL);
 }
 EXPORT_SYMBOL(kthread_stop);
 
+/**
+ * kthread_stop_sem - stop a thread created by kthread_create().
+ * @k: thread created by kthread_create().
+ * @s: semaphore that @k waits on while idle.
+ *
+ * Does essentially the same thing as kthread_stop() above, but wakes
+ * @k by calling up(@s).
+ *
+ * Returns the result of threadfn(), or %-EINTR if wake_up_process()
+ * was never called.
+ */
 int kthread_stop_sem(struct task_struct *k, struct semaphore *s)
 {
         int ret;
@@ -210,5 +269,5 @@ static __init int helper_init(void)
 
         return 0;
 }
-core_initcall(helper_init);
 
+core_initcall(helper_init);
diff --git a/kernel/module.c b/kernel/module.c
index bbe04862e1b0..d75275de1c28 100644
--- a/kernel/module.c
+++ b/kernel/module.c
@@ -1326,7 +1326,7 @@ int is_exported(const char *name, const struct module *mod)
         if (!mod && lookup_symbol(name, __start___ksymtab, __stop___ksymtab))
                 return 1;
         else
-                if (lookup_symbol(name, mod->syms, mod->syms + mod->num_syms))
+                if (mod && lookup_symbol(name, mod->syms, mod->syms + mod->num_syms))
                         return 1;
                 else
                         return 0;
diff --git a/kernel/power/Kconfig b/kernel/power/Kconfig
index cdf315e794ff..fc311a4673a2 100644
--- a/kernel/power/Kconfig
+++ b/kernel/power/Kconfig
@@ -38,7 +38,7 @@ config PM_DEBUG
 
 config PM_TRACE
         bool "Suspend/resume event tracing"
-        depends on PM && PM_DEBUG && X86
+        depends on PM && PM_DEBUG && X86_32
         default y
         ---help---
         This enables some cheesy code to save the last PM event point in the
diff --git a/kernel/power/disk.c b/kernel/power/disk.c
index 81d4d982f3f0..e13e74067845 100644
--- a/kernel/power/disk.c
+++ b/kernel/power/disk.c
@@ -231,7 +231,7 @@ static int software_resume(void)
 late_initcall(software_resume);
 
 
-static char * pm_disk_modes[] = {
+static const char * const pm_disk_modes[] = {
         [PM_DISK_FIRMWARE]      = "firmware",
         [PM_DISK_PLATFORM]      = "platform",
         [PM_DISK_SHUTDOWN]      = "shutdown",
diff --git a/kernel/power/main.c b/kernel/power/main.c
index cdf0f07af92f..6d295c776794 100644
--- a/kernel/power/main.c
+++ b/kernel/power/main.c
@@ -145,7 +145,7 @@ static void suspend_finish(suspend_state_t state)
 
 
 
-static char *pm_states[PM_SUSPEND_MAX] = {
+static const char * const pm_states[PM_SUSPEND_MAX] = {
         [PM_SUSPEND_STANDBY]    = "standby",
         [PM_SUSPEND_MEM]        = "mem",
 #ifdef CONFIG_SOFTWARE_SUSPEND
@@ -262,7 +262,7 @@ static ssize_t state_show(struct subsystem * subsys, char * buf)
 static ssize_t state_store(struct subsystem * subsys, const char * buf, size_t n)
 {
         suspend_state_t state = PM_SUSPEND_STANDBY;
-        char ** s;
+        const char * const *s;
         char *p;
         int error;
         int len;
diff --git a/kernel/printk.c b/kernel/printk.c
index 19a955619294..95b7fe17f124 100644
--- a/kernel/printk.c
+++ b/kernel/printk.c
@@ -24,6 +24,7 @@
 #include <linux/console.h>
 #include <linux/init.h>
 #include <linux/module.h>
+#include <linux/moduleparam.h>
 #include <linux/interrupt.h>                    /* For in_interrupt() */
 #include <linux/config.h>
 #include <linux/delay.h>
@@ -327,7 +328,9 @@ static void __call_console_drivers(unsigned long start, unsigned long end)
         struct console *con;
 
         for (con = console_drivers; con; con = con->next) {
-                if ((con->flags & CON_ENABLED) && con->write)
+                if ((con->flags & CON_ENABLED) && con->write &&
+                                (cpu_online(smp_processor_id()) ||
+                                (con->flags & CON_ANYTIME)))
                         con->write(con, &LOG_BUF(start), end - start);
         }
 }
@@ -437,6 +440,7 @@ static int printk_time = 1;
 #else
 static int printk_time = 0;
 #endif
+module_param(printk_time, int, S_IRUGO | S_IWUSR);
 
 static int __init printk_time_setup(char *str)
 {
@@ -453,6 +457,18 @@ __attribute__((weak)) unsigned long long printk_clock(void)
         return sched_clock();
 }
 
+/* Check if we have any console registered that can be called early in boot. */
+static int have_callable_console(void)
+{
+        struct console *con;
+
+        for (con = console_drivers; con; con = con->next)
+                if (con->flags & CON_ANYTIME)
+                        return 1;
+
+        return 0;
+}
+
 /**
  * printk - print a kernel message
  * @fmt: format string
@@ -566,27 +582,29 @@ asmlinkage int vprintk(const char *fmt, va_list args)
                         log_level_unknown = 1;
         }
 
-        if (!cpu_online(smp_processor_id())) {
+        if (!down_trylock(&console_sem)) {
                 /*
-                 * Some console drivers may assume that per-cpu resources have
-                 * been allocated.  So don't allow them to be called by this
-                 * CPU until it is officially up.  We shouldn't be calling into
-                 * random console drivers on a CPU which doesn't exist yet..
+                 * We own the drivers.  We can drop the spinlock and
+                 * let release_console_sem() print the text, maybe ...
                  */
+                console_locked = 1;
                 printk_cpu = UINT_MAX;
                 spin_unlock_irqrestore(&logbuf_lock, flags);
-                goto out;
-        }
-        if (!down_trylock(&console_sem)) {
-                console_locked = 1;
+
                 /*
-                 * We own the drivers.  We can drop the spinlock and let
-                 * release_console_sem() print the text
+                 * Console drivers may assume that per-cpu resources have
+                 * been allocated. So unless they're explicitly marked as
+                 * being able to cope (CON_ANYTIME) don't call them until
+                 * this CPU is officially up.
                  */
-                printk_cpu = UINT_MAX;
-                spin_unlock_irqrestore(&logbuf_lock, flags);
-                console_may_schedule = 0;
-                release_console_sem();
+                if (cpu_online(smp_processor_id()) || have_callable_console()) {
+                        console_may_schedule = 0;
+                        release_console_sem();
+                } else {
+                        /* Release by hand to avoid flushing the buffer. */
+                        console_locked = 0;
+                        up(&console_sem);
+                }
         } else {
                 /*
                  * Someone else owns the drivers.  We drop the spinlock, which
@@ -596,7 +614,7 @@ asmlinkage int vprintk(const char *fmt, va_list args)
                 printk_cpu = UINT_MAX;
                 spin_unlock_irqrestore(&logbuf_lock, flags);
         }
-out:
+
         preempt_enable();
         return printed_len;
 }
diff --git a/kernel/sched.c b/kernel/sched.c
index 5dbc42694477..f06d059edef5 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -4152,7 +4152,7 @@ EXPORT_SYMBOL(yield);
  */
 void __sched io_schedule(void)
 {
-        struct runqueue *rq = &per_cpu(runqueues, raw_smp_processor_id());
+        struct runqueue *rq = &__raw_get_cpu_var(runqueues);
 
         atomic_inc(&rq->nr_iowait);
         schedule();
@@ -4163,7 +4163,7 @@ EXPORT_SYMBOL(io_schedule);
 
 long __sched io_schedule_timeout(long timeout)
 {
-        struct runqueue *rq = &per_cpu(runqueues, raw_smp_processor_id());
+        struct runqueue *rq = &__raw_get_cpu_var(runqueues);
         long ret;
 
         atomic_inc(&rq->nr_iowait);
@@ -4756,6 +4756,8 @@ static int migration_call(struct notifier_block *nfb, unsigned long action,
                 break;
 #ifdef CONFIG_HOTPLUG_CPU
         case CPU_UP_CANCELED:
+                if (!cpu_rq(cpu)->migration_thread)
+                        break;
                 /* Unbind it from offline cpu so it can run.  Fall thru. */
                 kthread_bind(cpu_rq(cpu)->migration_thread,
                              any_online_cpu(cpu_online_map));
diff --git a/kernel/softirq.c b/kernel/softirq.c
index 336f92d64e2e..9e2f1c6e73d7 100644
--- a/kernel/softirq.c
+++ b/kernel/softirq.c
@@ -470,6 +470,8 @@ static int cpu_callback(struct notifier_block *nfb,
                 break;
 #ifdef CONFIG_HOTPLUG_CPU
         case CPU_UP_CANCELED:
+                if (!per_cpu(ksoftirqd, hotcpu))
+                        break;
                 /* Unbind so it can run.  Fall thru. */
                 kthread_bind(per_cpu(ksoftirqd, hotcpu),
                              any_online_cpu(cpu_online_map));
diff --git a/kernel/softlockup.c b/kernel/softlockup.c
index 14c7faf02909..b5c3b94e01ce 100644
--- a/kernel/softlockup.c
+++ b/kernel/softlockup.c
@@ -36,7 +36,7 @@ static struct notifier_block panic_block = {
 
 void touch_softlockup_watchdog(void)
 {
-        per_cpu(touch_timestamp, raw_smp_processor_id()) = jiffies;
+        __raw_get_cpu_var(touch_timestamp) = jiffies;
 }
 EXPORT_SYMBOL(touch_softlockup_watchdog);
 
@@ -127,6 +127,8 @@ cpu_callback(struct notifier_block *nfb, unsigned long action, void *hcpu)
                 break;
 #ifdef CONFIG_HOTPLUG_CPU
         case CPU_UP_CANCELED:
+                if (!per_cpu(watchdog_task, hotcpu))
+                        break;
                 /* Unbind so it can run.  Fall thru. */
                 kthread_bind(per_cpu(watchdog_task, hotcpu),
                              any_online_cpu(cpu_online_map));
diff --git a/kernel/stop_machine.c b/kernel/stop_machine.c
index dcfb5d731466..2c0aacc37c55 100644
--- a/kernel/stop_machine.c
+++ b/kernel/stop_machine.c
@@ -4,6 +4,7 @@
 #include <linux/cpu.h>
 #include <linux/err.h>
 #include <linux/syscalls.h>
+#include <linux/kthread.h>
 #include <asm/atomic.h>
 #include <asm/semaphore.h>
 #include <asm/uaccess.h>
@@ -25,13 +26,11 @@ static unsigned int stopmachine_num_threads;
 static atomic_t stopmachine_thread_ack;
 static DECLARE_MUTEX(stopmachine_mutex);
 
-static int stopmachine(void *cpu)
+static int stopmachine(void *unused)
 {
         int irqs_disabled = 0;
         int prepared = 0;
 
-        set_cpus_allowed(current, cpumask_of_cpu((int)(long)cpu));
-
         /* Ack: we are alive */
         smp_mb(); /* Theoretically the ack = 0 might not be on this CPU yet. */
         atomic_inc(&stopmachine_thread_ack);
@@ -85,7 +84,8 @@ static void stopmachine_set_state(enum stopmachine_state state)
 
 static int stop_machine(void)
 {
-        int i, ret = 0;
+        int ret = 0;
+        unsigned int i;
         struct sched_param param = { .sched_priority = MAX_RT_PRIO-1 };
 
         /* One high-prio thread per cpu.  We'll do this one. */
@@ -96,11 +96,16 @@ static int stop_machine(void)
         stopmachine_state = STOPMACHINE_WAIT;
 
         for_each_online_cpu(i) {
+                struct task_struct *tsk;
                 if (i == raw_smp_processor_id())
                         continue;
-                ret = kernel_thread(stopmachine, (void *)(long)i,CLONE_KERNEL);
-                if (ret < 0)
+                tsk = kthread_create(stopmachine, NULL, "stopmachine");
+                if (IS_ERR(tsk)) {
+                        ret = PTR_ERR(tsk);
                         break;
+                }
+                kthread_bind(tsk, i);
+                wake_up_process(tsk);
                 stopmachine_num_threads++;
         }
 
diff --git a/kernel/sys.c b/kernel/sys.c
index 90930b28d2ca..2d5179c67cec 100644
--- a/kernel/sys.c
+++ b/kernel/sys.c
@@ -137,14 +137,15 @@ static int __kprobes notifier_call_chain(struct notifier_block **nl,
                 unsigned long val, void *v)
 {
         int ret = NOTIFY_DONE;
-        struct notifier_block *nb;
+        struct notifier_block *nb, *next_nb;
 
         nb = rcu_dereference(*nl);
         while (nb) {
+                next_nb = rcu_dereference(nb->next);
                 ret = nb->notifier_call(nb, val, v);
                 if ((ret & NOTIFY_STOP_MASK) == NOTIFY_STOP_MASK)
                         break;
-                nb = rcu_dereference(nb->next);
+                nb = next_nb;
         }
         return ret;
 }
@@ -588,7 +589,7 @@ void emergency_restart(void)
 }
 EXPORT_SYMBOL_GPL(emergency_restart);
 
-void kernel_restart_prepare(char *cmd)
+static void kernel_restart_prepare(char *cmd)
 {
         blocking_notifier_call_chain(&reboot_notifier_list, SYS_RESTART, cmd);
         system_state = SYSTEM_RESTART;
@@ -622,7 +623,7 @@ EXPORT_SYMBOL_GPL(kernel_restart);
  *      Move into place and start executing a preloaded standalone
  *      executable.  If nothing was preloaded return an error.
  */
-void kernel_kexec(void)
+static void kernel_kexec(void)
 {
 #ifdef CONFIG_KEXEC
         struct kimage *image;
@@ -636,7 +637,6 @@ void kernel_kexec(void)
         machine_kexec(image);
 #endif
 }
-EXPORT_SYMBOL_GPL(kernel_kexec);
 
 void kernel_shutdown_prepare(enum system_states state)
 {
diff --git a/kernel/sysctl.c b/kernel/sysctl.c
index eb8bd214e7d7..2c0e65819448 100644
--- a/kernel/sysctl.c
+++ b/kernel/sysctl.c
@@ -143,7 +143,6 @@ static struct ctl_table_header root_table_header =
 
 static ctl_table kern_table[];
 static ctl_table vm_table[];
-static ctl_table proc_table[];
 static ctl_table fs_table[];
 static ctl_table debug_table[];
 static ctl_table dev_table[];
@@ -203,12 +202,6 @@ static ctl_table root_table[] = {
         },
 #endif
         {
-                .ctl_name       = CTL_PROC,
-                .procname       = "proc",
-                .mode           = 0555,
-                .child          = proc_table,
-        },
-        {
                 .ctl_name       = CTL_FS,
                 .procname       = "fs",
                 .mode           = 0555,
@@ -927,10 +920,6 @@ static ctl_table vm_table[] = {
         { .ctl_name = 0 }
 };
 
-static ctl_table proc_table[] = {
-        { .ctl_name = 0 }
-};
-
 static ctl_table fs_table[] = {
         {
                 .ctl_name       = FS_NRINODE,
diff --git a/kernel/timer.c b/kernel/timer.c
index f35b3939e937..eb97371b87d8 100644
--- a/kernel/timer.c
+++ b/kernel/timer.c
@@ -146,7 +146,7 @@ static void internal_add_timer(tvec_base_t *base, struct timer_list *timer)
 void fastcall init_timer(struct timer_list *timer)
 {
         timer->entry.next = NULL;
-        timer->base = per_cpu(tvec_bases, raw_smp_processor_id());
+        timer->base = __raw_get_cpu_var(tvec_bases);
 }
 EXPORT_SYMBOL(init_timer);
 
diff --git a/kernel/workqueue.c b/kernel/workqueue.c
index 740c5abceb07..565cf7a1febd 100644
--- a/kernel/workqueue.c
+++ b/kernel/workqueue.c
@@ -428,22 +428,34 @@ int schedule_delayed_work_on(int cpu,
         return ret;
 }
 
-int schedule_on_each_cpu(void (*func) (void *info), void *info)
+/**
+ * schedule_on_each_cpu - call a function on each online CPU from keventd
+ * @func: the function to call
+ * @info: a pointer to pass to func()
+ *
+ * Returns zero on success.
+ * Returns -ve errno on failure.
+ *
+ * Appears to be racy against CPU hotplug.
+ *
+ * schedule_on_each_cpu() is very slow.
+ */
+int schedule_on_each_cpu(void (*func)(void *info), void *info)
 {
         int cpu;
-        struct work_struct *work;
+        struct work_struct *works;
 
-        work = kmalloc(NR_CPUS * sizeof(struct work_struct), GFP_KERNEL);
-
-        if (!work)
+        works = alloc_percpu(struct work_struct);
+        if (!works)
                 return -ENOMEM;
+
         for_each_online_cpu(cpu) {
-                INIT_WORK(work + cpu, func, info);
+                INIT_WORK(per_cpu_ptr(works, cpu), func, info);
                 __queue_work(per_cpu_ptr(keventd_wq->cpu_wq, cpu),
-                                work + cpu);
+                                per_cpu_ptr(works, cpu));
         }
         flush_workqueue(keventd_wq);
-        kfree(work);
+        free_percpu(works);
         return 0;
 }
 
@@ -578,6 +590,8 @@ static int workqueue_cpu_callback(struct notifier_block *nfb,
 
         case CPU_UP_CANCELED:
                 list_for_each_entry(wq, &workqueues, list) {
+                        if (!per_cpu_ptr(wq->cpu_wq, hotcpu)->thread)
+                                continue;
                         /* Unbind so it can run. */
                         kthread_bind(per_cpu_ptr(wq->cpu_wq, hotcpu)->thread,
                                      any_online_cpu(cpu_online_map));