Merge /spare/repo/linux-2.6/

17 files changed, 221 insertions, 136 deletions

diff --git a/kernel/capability.c b/kernel/capability.c
index 64db1ee820c2..8986a37a67ea 100644
--- a/kernel/capability.c
+++ b/kernel/capability.c
@@ -31,8 +31,14 @@ static DEFINE_SPINLOCK(task_capability_lock);
  * uninteresting and/or not to be changed.
  */
 
-/*
+/**
  * sys_capget - get the capabilities of a given process.
+ * @header: pointer to struct that contains capability version and
+ *      target pid data
+ * @dataptr: pointer to struct that contains the effective, permitted,
+ *      and inheritable capabilities that are returned
+ *
+ * Returns 0 on success and < 0 on error.
  */
 asmlinkage long sys_capget(cap_user_header_t header, cap_user_data_t dataptr)
 {
@@ -141,8 +147,14 @@ static inline int cap_set_all(kernel_cap_t *effective,
      return ret;
 }
 
-/*
- * sys_capset - set capabilities for a given process, all processes, or all
+/**
+ * sys_capset - set capabilities for a process or a group of processes
+ * @header: pointer to struct that contains capability version and
+ *      target pid data
+ * @data: pointer to struct that contains the effective, permitted,
+ *      and inheritable capabilities
+ *
+ * Set capabilities for a given process, all processes, or all
  * processes in a given process group.
  *
  * The restrictions on setting capabilities are specified as:
@@ -152,6 +164,8 @@ static inline int cap_set_all(kernel_cap_t *effective,
  * I: any raised capabilities must be a subset of the (old current) permitted
  * P: any raised capabilities must be a subset of the (old current) permitted
  * E: must be set to a subset of (new target) permitted
+ *
+ * Returns 0 on success and < 0 on error.
  */
 asmlinkage long sys_capset(cap_user_header_t header, const cap_user_data_t data)
 {
diff --git a/kernel/cpuset.c b/kernel/cpuset.c
index 984c0bf3807f..21a4e3b2cbda 100644
--- a/kernel/cpuset.c
+++ b/kernel/cpuset.c
@@ -398,21 +398,31 @@ static int cpuset_path(const struct cpuset *cs, char *buf, int buflen)
  * to continue to serve a useful existence.  Next time it's released,
  * we will get notified again, if it still has 'notify_on_release' set.
  *
- * Note final arg to call_usermodehelper() is 0 - that means
- * don't wait.  Since we are holding the global cpuset_sem here,
- * and we are asking another thread (started from keventd) to rmdir a
- * cpuset, we can't wait - or we'd deadlock with the removing thread
- * on cpuset_sem.
+ * The final arg to call_usermodehelper() is 0, which means don't
+ * wait.  The separate /sbin/cpuset_release_agent task is forked by
+ * call_usermodehelper(), then control in this thread returns here,
+ * without waiting for the release agent task.  We don't bother to
+ * wait because the caller of this routine has no use for the exit
+ * status of the /sbin/cpuset_release_agent task, so no sense holding
+ * our caller up for that.
+ *
+ * The simple act of forking that task might require more memory,
+ * which might need cpuset_sem.  So this routine must be called while
+ * cpuset_sem is not held, to avoid a possible deadlock.  See also
+ * comments for check_for_release(), below.
  */
 
-static int cpuset_release_agent(char *cpuset_str)
+static void cpuset_release_agent(const char *pathbuf)
 {
         char *argv[3], *envp[3];
         int i;
 
+        if (!pathbuf)
+                return;
+
         i = 0;
         argv[i++] = "/sbin/cpuset_release_agent";
-        argv[i++] = cpuset_str;
+        argv[i++] = (char *)pathbuf;
         argv[i] = NULL;
 
         i = 0;
@@ -421,17 +431,29 @@ static int cpuset_release_agent(char *cpuset_str)
         envp[i++] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin";
         envp[i] = NULL;
 
-        return call_usermodehelper(argv[0], argv, envp, 0);
+        call_usermodehelper(argv[0], argv, envp, 0);
+        kfree(pathbuf);
 }
 
 /*
  * Either cs->count of using tasks transitioned to zero, or the
  * cs->children list of child cpusets just became empty.  If this
  * cs is notify_on_release() and now both the user count is zero and
- * the list of children is empty, send notice to user land.
+ * the list of children is empty, prepare cpuset path in a kmalloc'd
+ * buffer, to be returned via ppathbuf, so that the caller can invoke
+ * cpuset_release_agent() with it later on, once cpuset_sem is dropped.
+ * Call here with cpuset_sem held.
+ *
+ * This check_for_release() routine is responsible for kmalloc'ing
+ * pathbuf.  The above cpuset_release_agent() is responsible for
+ * kfree'ing pathbuf.  The caller of these routines is responsible
+ * for providing a pathbuf pointer, initialized to NULL, then
+ * calling check_for_release() with cpuset_sem held and the address
+ * of the pathbuf pointer, then dropping cpuset_sem, then calling
+ * cpuset_release_agent() with pathbuf, as set by check_for_release().
  */
 
-static void check_for_release(struct cpuset *cs)
+static void check_for_release(struct cpuset *cs, char **ppathbuf)
 {
         if (notify_on_release(cs) && atomic_read(&cs->count) == 0 &&
             list_empty(&cs->children)) {
@@ -441,10 +463,9 @@ static void check_for_release(struct cpuset *cs)
                 if (!buf)
                         return;
                 if (cpuset_path(cs, buf, PAGE_SIZE) < 0)
-                        goto out;
-                cpuset_release_agent(buf);
-out:
-                kfree(buf);
+                        kfree(buf);
+                else
+                        *ppathbuf = buf;
         }
 }
 
@@ -727,14 +748,14 @@ static int update_flag(cpuset_flagbits_t bit, struct cpuset *cs, char *buf)
         return 0;
 }
 
-static int attach_task(struct cpuset *cs, char *buf)
+static int attach_task(struct cpuset *cs, char *pidbuf, char **ppathbuf)
 {
         pid_t pid;
         struct task_struct *tsk;
         struct cpuset *oldcs;
         cpumask_t cpus;
 
-        if (sscanf(buf, "%d", &pid) != 1)
+        if (sscanf(pidbuf, "%d", &pid) != 1)
                 return -EIO;
         if (cpus_empty(cs->cpus_allowed) || nodes_empty(cs->mems_allowed))
                 return -ENOSPC;
@@ -777,7 +798,7 @@ static int attach_task(struct cpuset *cs, char *buf)
 
         put_task_struct(tsk);
         if (atomic_dec_and_test(&oldcs->count))
-                check_for_release(oldcs);
+                check_for_release(oldcs, ppathbuf);
         return 0;
 }
 
@@ -801,6 +822,7 @@ static ssize_t cpuset_common_file_write(struct file *file, const char __user *us
         struct cftype *cft = __d_cft(file->f_dentry);
         cpuset_filetype_t type = cft->private;
         char *buffer;
+        char *pathbuf = NULL;
         int retval = 0;
 
         /* Crude upper limit on largest legitimate cpulist user might write. */
@@ -841,7 +863,7 @@ static ssize_t cpuset_common_file_write(struct file *file, const char __user *us
                 retval = update_flag(CS_NOTIFY_ON_RELEASE, cs, buffer);
                 break;
         case FILE_TASKLIST:
-                retval = attach_task(cs, buffer);
+                retval = attach_task(cs, buffer, &pathbuf);
                 break;
         default:
                 retval = -EINVAL;
@@ -852,6 +874,7 @@ static ssize_t cpuset_common_file_write(struct file *file, const char __user *us
                 retval = nbytes;
 out2:
         up(&cpuset_sem);
+        cpuset_release_agent(pathbuf);
 out1:
         kfree(buffer);
         return retval;
@@ -1357,6 +1380,7 @@ static int cpuset_rmdir(struct inode *unused_dir, struct dentry *dentry)
         struct cpuset *cs = dentry->d_fsdata;
         struct dentry *d;
         struct cpuset *parent;
+        char *pathbuf = NULL;
 
         /* the vfs holds both inode->i_sem already */
 
@@ -1376,7 +1400,7 @@ static int cpuset_rmdir(struct inode *unused_dir, struct dentry *dentry)
                 update_cpu_domains(cs);
         list_del(&cs->sibling); /* delete my sibling from parent->children */
         if (list_empty(&parent->children))
-                check_for_release(parent);
+                check_for_release(parent, &pathbuf);
         spin_lock(&cs->dentry->d_lock);
         d = dget(cs->dentry);
         cs->dentry = NULL;
@@ -1384,6 +1408,7 @@ static int cpuset_rmdir(struct inode *unused_dir, struct dentry *dentry)
         cpuset_d_remove_dir(d);
         dput(d);
         up(&cpuset_sem);
+        cpuset_release_agent(pathbuf);
         return 0;
 }
 
@@ -1440,10 +1465,10 @@ void __init cpuset_init_smp(void)
 
 /**
  * cpuset_fork - attach newly forked task to its parents cpuset.
- * @p: pointer to task_struct of forking parent process.
+ * @tsk: pointer to task_struct of forking parent process.
  *
  * Description: By default, on fork, a task inherits its
- * parents cpuset.  The pointer to the shared cpuset is
+ * parent's cpuset.  The pointer to the shared cpuset is
  * automatically copied in fork.c by dup_task_struct().
  * This cpuset_fork() routine need only increment the usage
  * counter in that cpuset.
@@ -1471,7 +1496,6 @@ void cpuset_fork(struct task_struct *tsk)
  * by the cpuset_sem semaphore.  If you don't hold cpuset_sem,
  * then a zero cpuset use count is a license to any other task to
  * nuke the cpuset immediately.
- *
  **/
 
 void cpuset_exit(struct task_struct *tsk)
@@ -1484,10 +1508,13 @@ void cpuset_exit(struct task_struct *tsk)
         task_unlock(tsk);
 
         if (notify_on_release(cs)) {
+                char *pathbuf = NULL;
+
                 down(&cpuset_sem);
                 if (atomic_dec_and_test(&cs->count))
-                        check_for_release(cs);
+                        check_for_release(cs, &pathbuf);
                 up(&cpuset_sem);
+                cpuset_release_agent(pathbuf);
         } else {
                 atomic_dec(&cs->count);
         }
@@ -1521,7 +1548,9 @@ void cpuset_init_current_mems_allowed(void)
         current->mems_allowed = NODE_MASK_ALL;
 }
 
-/*
+/**
+ * cpuset_update_current_mems_allowed - update mems parameters to new values
+ *
  * If the current tasks cpusets mems_allowed changed behind our backs,
  * update current->mems_allowed and mems_generation to the new value.
  * Do not call this routine if in_interrupt().
@@ -1540,13 +1569,20 @@ void cpuset_update_current_mems_allowed(void)
         }
 }
 
+/**
+ * cpuset_restrict_to_mems_allowed - limit nodes to current mems_allowed
+ * @nodes: pointer to a node bitmap that is and-ed with mems_allowed
+ */
 void cpuset_restrict_to_mems_allowed(unsigned long *nodes)
 {
         bitmap_and(nodes, nodes, nodes_addr(current->mems_allowed),
                                                         MAX_NUMNODES);
 }
 
-/*
+/**
+ * cpuset_zonelist_valid_mems_allowed - check zonelist vs. curremt mems_allowed
+ * @zl: the zonelist to be checked
+ *
  * Are any of the nodes on zonelist zl allowed in current->mems_allowed?
  */
 int cpuset_zonelist_valid_mems_allowed(struct zonelist *zl)
@@ -1562,8 +1598,12 @@ int cpuset_zonelist_valid_mems_allowed(struct zonelist *zl)
         return 0;
 }
 
-/*
- * Is 'current' valid, and is zone z allowed in current->mems_allowed?
+/**
+ * cpuset_zone_allowed - is zone z allowed in current->mems_allowed
+ * @z: zone in question
+ *
+ * Is zone z allowed in current->mems_allowed, or is
+ * the CPU in interrupt context? (zone is always allowed in this case)
  */
 int cpuset_zone_allowed(struct zone *z)
 {
diff --git a/kernel/crash_dump.c b/kernel/crash_dump.c
index 459ba49e376a..334c37f5218a 100644
--- a/kernel/crash_dump.c
+++ b/kernel/crash_dump.c
@@ -18,7 +18,16 @@
 /* Stores the physical address of elf header of crash image. */
 unsigned long long elfcorehdr_addr = ELFCORE_ADDR_MAX;
 
-/*
+/**
+ * copy_oldmem_page - copy one page from "oldmem"
+ * @pfn: page frame number to be copied
+ * @buf: target memory address for the copy; this can be in kernel address
+ *      space or user address space (see @userbuf)
+ * @csize: number of bytes to copy
+ * @offset: offset in bytes into the page (based on pfn) to begin the copy
+ * @userbuf: if set, @buf is in user address space, use copy_to_user(),
+ *      otherwise @buf is in kernel address space, use memcpy().
+ *
  * Copy a page from "oldmem". For this page, there is no pte mapped
  * in the current kernel. We stitch up a pte, similar to kmap_atomic.
  */
diff --git a/kernel/exit.c b/kernel/exit.c
index 9d1b10ed0135..5b0fb9f09f21 100644
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -829,8 +829,10 @@ fastcall NORET_TYPE void do_exit(long code)
         acct_update_integrals(tsk);
         update_mem_hiwater(tsk);
         group_dead = atomic_dec_and_test(&tsk->signal->live);
-        if (group_dead)
+        if (group_dead) {
+                del_timer_sync(&tsk->signal->real_timer);
                 acct_process(code);
+        }
         exit_mm(tsk);
 
         exit_sem(tsk);
diff --git a/kernel/itimer.c b/kernel/itimer.c
index a72cb0e5aa4b..7c1b25e25e47 100644
--- a/kernel/itimer.c
+++ b/kernel/itimer.c
@@ -112,28 +112,11 @@ asmlinkage long sys_getitimer(int which, struct itimerval __user *value)
         return error;
 }
 
-/*
- * Called with P->sighand->siglock held and P->signal->real_timer inactive.
- * If interval is nonzero, arm the timer for interval ticks from now.
- */
-static inline void it_real_arm(struct task_struct *p, unsigned long interval)
-{
-        p->signal->it_real_value = interval; /* XXX unnecessary field?? */
-        if (interval == 0)
-                return;
-        if (interval > (unsigned long) LONG_MAX)
-                interval = LONG_MAX;
-        /* the "+ 1" below makes sure that the timer doesn't go off before
-         * the interval requested. This could happen if
-         * time requested % (usecs per jiffy) is more than the usecs left
-         * in the current jiffy */
-        p->signal->real_timer.expires = jiffies + interval + 1;
-        add_timer(&p->signal->real_timer);
-}
 
 void it_real_fn(unsigned long __data)
 {
         struct task_struct * p = (struct task_struct *) __data;
+        unsigned long inc = p->signal->it_real_incr;
 
         send_group_sig_info(SIGALRM, SEND_SIG_PRIV, p);
 
@@ -141,14 +124,23 @@ void it_real_fn(unsigned long __data)
          * Now restart the timer if necessary.  We don't need any locking
          * here because do_setitimer makes sure we have finished running
          * before it touches anything.
+         * Note, we KNOW we are (or should be) at a jiffie edge here so
+         * we don't need the +1 stuff.  Also, we want to use the prior
+         * expire value so as to not "slip" a jiffie if we are late.
+         * Deal with requesting a time prior to "now" here rather than
+         * in add_timer.
          */
-        it_real_arm(p, p->signal->it_real_incr);
+        if (!inc)
+                return;
+        while (time_before_eq(p->signal->real_timer.expires, jiffies))
+                p->signal->real_timer.expires += inc;
+        add_timer(&p->signal->real_timer);
 }
 
 int do_setitimer(int which, struct itimerval *value, struct itimerval *ovalue)
 {
         struct task_struct *tsk = current;
-        unsigned long val, interval;
+        unsigned long val, interval, expires;
         cputime_t cval, cinterval, nval, ninterval;
 
         switch (which) {
@@ -164,7 +156,10 @@ again:
                 }
                 tsk->signal->it_real_incr =
                         timeval_to_jiffies(&value->it_interval);
-                it_real_arm(tsk, timeval_to_jiffies(&value->it_value));
+                expires = timeval_to_jiffies(&value->it_value);
+                if (expires)
+                        mod_timer(&tsk->signal->real_timer,
+                                  jiffies + 1 + expires);
                 spin_unlock_irq(&tsk->sighand->siglock);
                 if (ovalue) {
                         jiffies_to_timeval(val, &ovalue->it_value);
diff --git a/kernel/module.c b/kernel/module.c
index 068e271ab3a5..c32995fbd8fd 100644
--- a/kernel/module.c
+++ b/kernel/module.c
@@ -250,13 +250,18 @@ static inline unsigned int block_size(int val)
 /* Created by linker magic */
 extern char __per_cpu_start[], __per_cpu_end[];
 
-static void *percpu_modalloc(unsigned long size, unsigned long align)
+static void *percpu_modalloc(unsigned long size, unsigned long align,
+                             const char *name)
 {
         unsigned long extra;
         unsigned int i;
         void *ptr;
 
-        BUG_ON(align > SMP_CACHE_BYTES);
+        if (align > SMP_CACHE_BYTES) {
+                printk(KERN_WARNING "%s: per-cpu alignment %li > %i\n",
+                       name, align, SMP_CACHE_BYTES);
+                align = SMP_CACHE_BYTES;
+        }
 
         ptr = __per_cpu_start;
         for (i = 0; i < pcpu_num_used; ptr += block_size(pcpu_size[i]), i++) {
@@ -348,7 +353,8 @@ static int percpu_modinit(void)
 }       
 __initcall(percpu_modinit);
 #else /* ... !CONFIG_SMP */
-static inline void *percpu_modalloc(unsigned long size, unsigned long align)
+static inline void *percpu_modalloc(unsigned long size, unsigned long align,
+                                    const char *name)
 {
         return NULL;
 }
@@ -1644,7 +1650,8 @@ static struct module *load_module(void __user *umod,
         if (pcpuindex) {
                 /* We have a special allocation for this section. */
                 percpu = percpu_modalloc(sechdrs[pcpuindex].sh_size,
-                                         sechdrs[pcpuindex].sh_addralign);
+                                         sechdrs[pcpuindex].sh_addralign,
+                                         mod->name);
                 if (!percpu) {
                         err = -ENOMEM;
                         goto free_mod;
diff --git a/kernel/panic.c b/kernel/panic.c
index 74ba5f3e46c7..aabc5f86fa3f 100644
--- a/kernel/panic.c
+++ b/kernel/panic.c
@@ -111,12 +111,11 @@ NORET_TYPE void panic(const char * fmt, ...)
                         mdelay(1);
                         i++;
                 }
-                /*
-                 *      Should we run the reboot notifier. For the moment Im
-                 *      choosing not too. It might crash, be corrupt or do
-                 *      more harm than good for other reasons.
+                /*      This will not be a clean reboot, with everything
+                 *      shutting down.  But if there is a chance of
+                 *      rebooting the system it will be rebooted.
                  */
-                machine_restart(NULL);
+                emergency_restart();
         }
 #ifdef __sparc__
         {
diff --git a/kernel/posix-timers.c b/kernel/posix-timers.c
index 5b7b4736d82b..38798a2ff994 100644
--- a/kernel/posix-timers.c
+++ b/kernel/posix-timers.c
@@ -896,21 +896,10 @@ static int adjust_abs_time(struct k_clock *clock, struct timespec *tp,
                         jiffies_64_f = get_jiffies_64();
                 }
                 /*
-                 * Take away now to get delta
+                 * Take away now to get delta and normalize
                  */
-                oc.tv_sec -= now.tv_sec;
-                oc.tv_nsec -= now.tv_nsec;
-                /*
-                 * Normalize...
-                 */
-                while ((oc.tv_nsec - NSEC_PER_SEC) >= 0) {
-                        oc.tv_nsec -= NSEC_PER_SEC;
-                        oc.tv_sec++;
-                }
-                while ((oc.tv_nsec) < 0) {
-                        oc.tv_nsec += NSEC_PER_SEC;
-                        oc.tv_sec--;
-                }
+                set_normalized_timespec(&oc, oc.tv_sec - now.tv_sec,
+                                        oc.tv_nsec - now.tv_nsec);
         }else{
                 jiffies_64_f = get_jiffies_64();
         }
@@ -1177,7 +1166,6 @@ void exit_itimers(struct signal_struct *sig)
                 tmr = list_entry(sig->posix_timers.next, struct k_itimer, list);
                 itimer_delete(tmr);
         }
-        del_timer_sync(&sig->real_timer);
 }
 
 /*
diff --git a/kernel/power/disk.c b/kernel/power/disk.c
index 3ec789c6b537..664eb0469b6e 100644
--- a/kernel/power/disk.c
+++ b/kernel/power/disk.c
@@ -59,16 +59,13 @@ static void power_down(suspend_disk_method_t mode)
                 error = pm_ops->enter(PM_SUSPEND_DISK);
                 break;
         case PM_DISK_SHUTDOWN:
-                printk("Powering off system\n");
-                device_shutdown();
-                machine_power_off();
+                kernel_power_off();
                 break;
         case PM_DISK_REBOOT:
-                device_shutdown();
-                machine_restart(NULL);
+                kernel_restart(NULL);
                 break;
         }
-        machine_halt();
+        kernel_halt();
         /* Valid image is on the disk, if we continue we risk serious data corruption
            after resume. */
         printk(KERN_CRIT "Please power me down manually\n");
diff --git a/kernel/power/poweroff.c b/kernel/power/poweroff.c
index 715081b2d829..7a4144ba3afd 100644
--- a/kernel/power/poweroff.c
+++ b/kernel/power/poweroff.c
@@ -9,6 +9,7 @@
 #include <linux/init.h>
 #include <linux/pm.h>
 #include <linux/workqueue.h>
+#include <linux/reboot.h>
 
 /*
  * When the user hits Sys-Rq o to power down the machine this is the
@@ -17,8 +18,7 @@
 
 static void do_poweroff(void *dummy)
 {
-        if (pm_power_off)
-                pm_power_off();
+        kernel_power_off();
 }
 
 static DECLARE_WORK(poweroff_work, do_poweroff, NULL);
diff --git a/kernel/power/smp.c b/kernel/power/smp.c
index bbe23079c62c..911fc62b8225 100644
--- a/kernel/power/smp.c
+++ b/kernel/power/smp.c
@@ -38,7 +38,7 @@ void disable_nonboot_cpus(void)
                 }
                 printk("Error taking cpu %d down: %d\n", cpu, error);
         }
-        BUG_ON(smp_processor_id() != 0);
+        BUG_ON(raw_smp_processor_id() != 0);
         if (error)
                 panic("cpus not sleeping");
 }
diff --git a/kernel/sched.c b/kernel/sched.c
index 4107db0dc091..a646e4f36c41 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -3486,7 +3486,7 @@ static void __setscheduler(struct task_struct *p, int policy, int prio)
         p->policy = policy;
         p->rt_priority = prio;
         if (policy != SCHED_NORMAL)
-                p->prio = MAX_USER_RT_PRIO-1 - p->rt_priority;
+                p->prio = MAX_RT_PRIO-1 - p->rt_priority;
         else
                 p->prio = p->static_prio;
 }
@@ -3518,7 +3518,8 @@ recheck:
          * 1..MAX_USER_RT_PRIO-1, valid priority for SCHED_NORMAL is 0.
          */
         if (param->sched_priority < 0 ||
-            param->sched_priority > MAX_USER_RT_PRIO-1)
+            (p->mm &&  param->sched_priority > MAX_USER_RT_PRIO-1) ||
+            (!p->mm && param->sched_priority > MAX_RT_PRIO-1))
                 return -EINVAL;
         if ((policy == SCHED_NORMAL) != (param->sched_priority == 0))
                 return -EINVAL;
@@ -3528,7 +3529,8 @@ recheck:
          */
         if (!capable(CAP_SYS_NICE)) {
                 /* can't change policy */
-                if (policy != p->policy)
+                if (policy != p->policy &&
+                        !p->signal->rlim[RLIMIT_RTPRIO].rlim_cur)
                         return -EPERM;
                 /* can't increase priority */
                 if (policy != SCHED_NORMAL &&
diff --git a/kernel/sys.c b/kernel/sys.c
index 9a24374c23bc..0bcaed6560ac 100644
--- a/kernel/sys.c
+++ b/kernel/sys.c
@@ -361,6 +361,64 @@ out_unlock:
         return retval;
 }
 
+void emergency_restart(void)
+{
+        machine_emergency_restart();
+}
+EXPORT_SYMBOL_GPL(emergency_restart);
+
+void kernel_restart(char *cmd)
+{
+        notifier_call_chain(&reboot_notifier_list, SYS_RESTART, cmd);
+        system_state = SYSTEM_RESTART;
+        device_shutdown();
+        if (!cmd) {
+                printk(KERN_EMERG "Restarting system.\n");
+        } else {
+                printk(KERN_EMERG "Restarting system with command '%s'.\n", cmd);
+        }
+        printk(".\n");
+        machine_restart(cmd);
+}
+EXPORT_SYMBOL_GPL(kernel_restart);
+
+void kernel_kexec(void)
+{
+#ifdef CONFIG_KEXEC
+        struct kimage *image;
+        image = xchg(&kexec_image, 0);
+        if (!image) {
+                return;
+        }
+        notifier_call_chain(&reboot_notifier_list, SYS_RESTART, NULL);
+        system_state = SYSTEM_RESTART;
+        device_shutdown();
+        printk(KERN_EMERG "Starting new kernel\n");
+        machine_shutdown();
+        machine_kexec(image);
+#endif
+}
+EXPORT_SYMBOL_GPL(kernel_kexec);
+
+void kernel_halt(void)
+{
+        notifier_call_chain(&reboot_notifier_list, SYS_HALT, NULL);
+        system_state = SYSTEM_HALT;
+        device_shutdown();
+        printk(KERN_EMERG "System halted.\n");
+        machine_halt();
+}
+EXPORT_SYMBOL_GPL(kernel_halt);
+
+void kernel_power_off(void)
+{
+        notifier_call_chain(&reboot_notifier_list, SYS_POWER_OFF, NULL);
+        system_state = SYSTEM_POWER_OFF;
+        device_shutdown();
+        printk(KERN_EMERG "Power down.\n");
+        machine_power_off();
+}
+EXPORT_SYMBOL_GPL(kernel_power_off);
 
 /*
  * Reboot system call: for obvious reasons only root may call it,
@@ -389,11 +447,7 @@ asmlinkage long sys_reboot(int magic1, int magic2, unsigned int cmd, void __user
         lock_kernel();
         switch (cmd) {
         case LINUX_REBOOT_CMD_RESTART:
-                notifier_call_chain(&reboot_notifier_list, SYS_RESTART, NULL);
-                system_state = SYSTEM_RESTART;
-                device_shutdown();
-                printk(KERN_EMERG "Restarting system.\n");
-                machine_restart(NULL);
+                kernel_restart(NULL);
                 break;
 
         case LINUX_REBOOT_CMD_CAD_ON:
@@ -405,23 +459,13 @@ asmlinkage long sys_reboot(int magic1, int magic2, unsigned int cmd, void __user
                 break;
 
         case LINUX_REBOOT_CMD_HALT:
-                notifier_call_chain(&reboot_notifier_list, SYS_HALT, NULL);
-                system_state = SYSTEM_HALT;
-                device_suspend(PMSG_SUSPEND);
-                device_shutdown();
-                printk(KERN_EMERG "System halted.\n");
-                machine_halt();
+                kernel_halt();
                 unlock_kernel();
                 do_exit(0);
                 break;
 
         case LINUX_REBOOT_CMD_POWER_OFF:
-                notifier_call_chain(&reboot_notifier_list, SYS_POWER_OFF, NULL);
-                system_state = SYSTEM_POWER_OFF;
-                device_suspend(PMSG_SUSPEND);
-                device_shutdown();
-                printk(KERN_EMERG "Power down.\n");
-                machine_power_off();
+                kernel_power_off();
                 unlock_kernel();
                 do_exit(0);
                 break;
@@ -433,32 +477,14 @@ asmlinkage long sys_reboot(int magic1, int magic2, unsigned int cmd, void __user
                 }
                 buffer[sizeof(buffer) - 1] = '\0';
 
-                notifier_call_chain(&reboot_notifier_list, SYS_RESTART, buffer);
-                system_state = SYSTEM_RESTART;
-                device_suspend(PMSG_FREEZE);
-                device_shutdown();
-                printk(KERN_EMERG "Restarting system with command '%s'.\n", buffer);
-                machine_restart(buffer);
+                kernel_restart(buffer);
                 break;
 
-#ifdef CONFIG_KEXEC
         case LINUX_REBOOT_CMD_KEXEC:
-        {
-                struct kimage *image;
-                image = xchg(&kexec_image, 0);
-                if (!image) {
-                        unlock_kernel();
-                        return -EINVAL;
-                }
-                notifier_call_chain(&reboot_notifier_list, SYS_RESTART, NULL);
-                system_state = SYSTEM_RESTART;
-                device_shutdown();
-                printk(KERN_EMERG "Starting new kernel\n");
-                machine_shutdown();
-                machine_kexec(image);
-                break;
-        }
-#endif
+                kernel_kexec();
+                unlock_kernel();
+                return -EINVAL;
+
 #ifdef CONFIG_SOFTWARE_SUSPEND
         case LINUX_REBOOT_CMD_SW_SUSPEND:
                 {
@@ -478,8 +504,7 @@ asmlinkage long sys_reboot(int magic1, int magic2, unsigned int cmd, void __user
 
 static void deferred_cad(void *dummy)
 {
-        notifier_call_chain(&reboot_notifier_list, SYS_RESTART, NULL);
-        machine_restart(NULL);
+        kernel_restart(NULL);
 }
 
 /*
diff --git a/kernel/sys_ni.c b/kernel/sys_ni.c
index 42b40ae5eada..1ab2370e2efa 100644
--- a/kernel/sys_ni.c
+++ b/kernel/sys_ni.c
@@ -79,7 +79,6 @@ cond_syscall(sys_request_key);
 cond_syscall(sys_keyctl);
 cond_syscall(compat_sys_keyctl);
 cond_syscall(compat_sys_socketcall);
-cond_syscall(sys_set_zone_reclaim);
 cond_syscall(sys_inotify_init);
 cond_syscall(sys_inotify_add_watch);
 cond_syscall(sys_inotify_rm_watch);
diff --git a/kernel/sysctl.c b/kernel/sysctl.c
index e60b9c36f1f0..3e0bbee549ea 100644
--- a/kernel/sysctl.c
+++ b/kernel/sysctl.c
@@ -114,6 +114,7 @@ extern int unaligned_enabled;
 extern int sysctl_ieee_emulation_warnings;
 #endif
 extern int sysctl_userprocess_debug;
+extern int spin_retry;
 #endif
 
 extern int sysctl_hz_timer;
@@ -647,7 +648,16 @@ static ctl_table kern_table[] = {
                 .mode           = 0644,
                 .proc_handler   = &proc_dointvec,
         },
-
+#if defined(CONFIG_ARCH_S390)
+        {
+                .ctl_name       = KERN_SPIN_RETRY,
+                .procname       = "spin_retry",
+                .data           = &spin_retry,
+                .maxlen         = sizeof (int),
+                .mode           = 0644,
+                .proc_handler   = &proc_dointvec,
+        },
+#endif
         { .ctl_name = 0 }
 };
 
diff --git a/kernel/time.c b/kernel/time.c
index d4335c1c884c..dd5ae1162a8f 100644
--- a/kernel/time.c
+++ b/kernel/time.c
@@ -128,7 +128,7 @@ asmlinkage long sys_gettimeofday(struct timeval __user *tv, struct timezone __us
  * as real UNIX machines always do it. This avoids all headaches about
  * daylight saving times and warping kernel clocks.
  */
-inline static void warp_clock(void)
+static inline void warp_clock(void)
 {
         write_seqlock_irq(&xtime_lock);
         wall_to_monotonic.tv_sec -= sys_tz.tz_minuteswest * 60;
diff --git a/kernel/workqueue.c b/kernel/workqueue.c
index 259cf55da3c9..c7e36d4a70ca 100644
--- a/kernel/workqueue.c
+++ b/kernel/workqueue.c
@@ -308,8 +308,6 @@ struct workqueue_struct *__create_workqueue(const char *name,
         struct workqueue_struct *wq;
         struct task_struct *p;
 
-        BUG_ON(strlen(name) > 10);
-
         wq = kmalloc(sizeof(*wq), GFP_KERNEL);
         if (!wq)
                 return NULL;