1 files changed, 93 insertions, 30 deletions

diff --git a/kernel/sys.c b/kernel/sys.c
index ce17760d9c51..6d1a7e0f9d5b 100644
--- a/kernel/sys.c
+++ b/kernel/sys.c
@@ -8,7 +8,6 @@
 #include <linux/mm.h>
 #include <linux/utsname.h>
 #include <linux/mman.h>
-#include <linux/smp_lock.h>
 #include <linux/notifier.h>
 #include <linux/reboot.h>
 #include <linux/prctl.h>
@@ -34,8 +33,10 @@
 #include <linux/task_io_accounting_ops.h>
 #include <linux/seccomp.h>
 #include <linux/cpu.h>
+#include <linux/personality.h>
 #include <linux/ptrace.h>
 #include <linux/fs_struct.h>
+#include <linux/gfp.h>
 
 #include <linux/compat.h>
 #include <linux/syscalls.h>
@@ -163,6 +164,7 @@ SYSCALL_DEFINE3(setpriority, int, which, int, who, int, niceval)
         if (niceval > 19)
                 niceval = 19;
 
+        rcu_read_lock();
         read_lock(&tasklist_lock);
         switch (which) {
                 case PRIO_PROCESS:
@@ -190,16 +192,17 @@ SYSCALL_DEFINE3(setpriority, int, which, int, who, int, niceval)
                                  !(user = find_user(who)))
                                 goto out_unlock;        /* No processes for this user */
 
-                        do_each_thread(g, p)
+                        do_each_thread(g, p) {
                                 if (__task_cred(p)->uid == who)
                                         error = set_one_prio(p, niceval, error);
-                        while_each_thread(g, p);
+                        } while_each_thread(g, p);
                         if (who != cred->uid)
                                 free_uid(user);         /* For find_user() */
                         break;
         }
 out_unlock:
         read_unlock(&tasklist_lock);
+        rcu_read_unlock();
 out:
         return error;
 }
@@ -221,6 +224,7 @@ SYSCALL_DEFINE2(getpriority, int, which, int, who)
         if (which > PRIO_USER || which < PRIO_PROCESS)
                 return -EINVAL;
 
+        rcu_read_lock();
         read_lock(&tasklist_lock);
         switch (which) {
                 case PRIO_PROCESS:
@@ -253,19 +257,20 @@ SYSCALL_DEFINE2(getpriority, int, which, int, who)
                                  !(user = find_user(who)))
                                 goto out_unlock;        /* No processes for this user */
 
-                        do_each_thread(g, p)
+                        do_each_thread(g, p) {
                                 if (__task_cred(p)->uid == who) {
                                         niceval = 20 - task_nice(p);
                                         if (niceval > retval)
                                                 retval = niceval;
                                 }
-                        while_each_thread(g, p);
+                        } while_each_thread(g, p);
                         if (who != cred->uid)
                                 free_uid(user);         /* for find_user() */
                         break;
         }
 out_unlock:
         read_unlock(&tasklist_lock);
+        rcu_read_unlock();
 
         return retval;
 }
@@ -349,6 +354,9 @@ void kernel_power_off(void)
         machine_power_off();
 }
 EXPORT_SYMBOL_GPL(kernel_power_off);
+
+static DEFINE_MUTEX(reboot_mutex);
+
 /*
  * Reboot system call: for obvious reasons only root may call it,
  * and even root needs to set up some magic numbers in the registers
@@ -381,7 +389,7 @@ SYSCALL_DEFINE4(reboot, int, magic1, int, magic2, unsigned int, cmd,
         if ((cmd == LINUX_REBOOT_CMD_POWER_OFF) && !pm_power_off)
                 cmd = LINUX_REBOOT_CMD_HALT;
 
-        lock_kernel();
+        mutex_lock(&reboot_mutex);
         switch (cmd) {
         case LINUX_REBOOT_CMD_RESTART:
                 kernel_restart(NULL);
@@ -397,20 +405,18 @@ SYSCALL_DEFINE4(reboot, int, magic1, int, magic2, unsigned int, cmd,
 
         case LINUX_REBOOT_CMD_HALT:
                 kernel_halt();
-                unlock_kernel();
                 do_exit(0);
                 panic("cannot halt");
 
         case LINUX_REBOOT_CMD_POWER_OFF:
                 kernel_power_off();
-                unlock_kernel();
                 do_exit(0);
                 break;
 
         case LINUX_REBOOT_CMD_RESTART2:
                 if (strncpy_from_user(&buffer[0], arg, sizeof(buffer) - 1) < 0) {
-                        unlock_kernel();
-                        return -EFAULT;
+                        ret = -EFAULT;
+                        break;
                 }
                 buffer[sizeof(buffer) - 1] = '\0';
 
@@ -433,7 +439,7 @@ SYSCALL_DEFINE4(reboot, int, magic1, int, magic2, unsigned int, cmd,
                 ret = -EINVAL;
                 break;
         }
-        unlock_kernel();
+        mutex_unlock(&reboot_mutex);
         return ret;
 }
 
@@ -567,13 +573,7 @@ static int set_user(struct cred *new)
         if (!new_user)
                 return -EAGAIN;
 
-        if (!task_can_switch_user(new_user, current)) {
-                free_uid(new_user);
-                return -EINVAL;
-        }
-
-        if (atomic_read(&new_user->processes) >=
-                                current->signal->rlim[RLIMIT_NPROC].rlim_cur &&
+        if (atomic_read(&new_user->processes) >= rlimit(RLIMIT_NPROC) &&
                         new_user != INIT_USER) {
                 free_uid(new_user);
                 return -EAGAIN;
@@ -911,16 +911,15 @@ change_okay:
 
 void do_sys_times(struct tms *tms)
 {
-        struct task_cputime cputime;
-        cputime_t cutime, cstime;
+        cputime_t tgutime, tgstime, cutime, cstime;
 
-        thread_group_cputime(current, &cputime);
         spin_lock_irq(&current->sighand->siglock);
+        thread_group_times(current, &tgutime, &tgstime);
         cutime = current->signal->cutime;
         cstime = current->signal->cstime;
         spin_unlock_irq(&current->sighand->siglock);
-        tms->tms_utime = cputime_to_clock_t(cputime.utime);
-        tms->tms_stime = cputime_to_clock_t(cputime.stime);
+        tms->tms_utime = cputime_to_clock_t(tgutime);
+        tms->tms_stime = cputime_to_clock_t(tgstime);
         tms->tms_cutime = cputime_to_clock_t(cutime);
         tms->tms_cstime = cputime_to_clock_t(cstime);
 }
@@ -1117,6 +1116,15 @@ out:
 
 DECLARE_RWSEM(uts_sem);
 
+#ifdef COMPAT_UTS_MACHINE
+#define override_architecture(name) \
+        (current->personality == PER_LINUX32 && \
+         copy_to_user(name->machine, COMPAT_UTS_MACHINE, \
+                      sizeof(COMPAT_UTS_MACHINE)))
+#else
+#define override_architecture(name)     0
+#endif
+
 SYSCALL_DEFINE1(newuname, struct new_utsname __user *, name)
 {
         int errno = 0;
@@ -1125,9 +1133,66 @@ SYSCALL_DEFINE1(newuname, struct new_utsname __user *, name)
         if (copy_to_user(name, utsname(), sizeof *name))
                 errno = -EFAULT;
         up_read(&uts_sem);
+
+        if (!errno && override_architecture(name))
+                errno = -EFAULT;
         return errno;
 }
 
+#ifdef __ARCH_WANT_SYS_OLD_UNAME
+/*
+ * Old cruft
+ */
+SYSCALL_DEFINE1(uname, struct old_utsname __user *, name)
+{
+        int error = 0;
+
+        if (!name)
+                return -EFAULT;
+
+        down_read(&uts_sem);
+        if (copy_to_user(name, utsname(), sizeof(*name)))
+                error = -EFAULT;
+        up_read(&uts_sem);
+
+        if (!error && override_architecture(name))
+                error = -EFAULT;
+        return error;
+}
+
+SYSCALL_DEFINE1(olduname, struct oldold_utsname __user *, name)
+{
+        int error;
+
+        if (!name)
+                return -EFAULT;
+        if (!access_ok(VERIFY_WRITE, name, sizeof(struct oldold_utsname)))
+                return -EFAULT;
+
+        down_read(&uts_sem);
+        error = __copy_to_user(&name->sysname, &utsname()->sysname,
+                               __OLD_UTS_LEN);
+        error |= __put_user(0, name->sysname + __OLD_UTS_LEN);
+        error |= __copy_to_user(&name->nodename, &utsname()->nodename,
+                                __OLD_UTS_LEN);
+        error |= __put_user(0, name->nodename + __OLD_UTS_LEN);
+        error |= __copy_to_user(&name->release, &utsname()->release,
+                                __OLD_UTS_LEN);
+        error |= __put_user(0, name->release + __OLD_UTS_LEN);
+        error |= __copy_to_user(&name->version, &utsname()->version,
+                                __OLD_UTS_LEN);
+        error |= __put_user(0, name->version + __OLD_UTS_LEN);
+        error |= __copy_to_user(&name->machine, &utsname()->machine,
+                                __OLD_UTS_LEN);
+        error |= __put_user(0, name->machine + __OLD_UTS_LEN);
+        up_read(&uts_sem);
+
+        if (!error && override_architecture(name))
+                error = -EFAULT;
+        return error ? -EFAULT : 0;
+}
+#endif
+
 SYSCALL_DEFINE2(sethostname, char __user *, name, int, len)
 {
         int errno;
@@ -1338,16 +1403,14 @@ static void k_getrusage(struct task_struct *p, int who, struct rusage *r)
 {
         struct task_struct *t;
         unsigned long flags;
-        cputime_t utime, stime;
-        struct task_cputime cputime;
+        cputime_t tgutime, tgstime, utime, stime;
         unsigned long maxrss = 0;
 
         memset((char *) r, 0, sizeof *r);
         utime = stime = cputime_zero;
 
         if (who == RUSAGE_THREAD) {
-                utime = task_utime(current);
-                stime = task_stime(current);
+                task_times(current, &utime, &stime);
                 accumulate_thread_rusage(p, r);
                 maxrss = p->signal->maxrss;
                 goto out;
@@ -1373,9 +1436,9 @@ static void k_getrusage(struct task_struct *p, int who, struct rusage *r)
                                 break;
 
                 case RUSAGE_SELF:
-                        thread_group_cputime(p, &cputime);
-                        utime = cputime_add(utime, cputime.utime);
-                        stime = cputime_add(stime, cputime.stime);
+                        thread_group_times(p, &tgutime, &tgstime);
+                        utime = cputime_add(utime, tgutime);
+                        stime = cputime_add(stime, tgstime);
                         r->ru_nvcsw += p->signal->nvcsw;
                         r->ru_nivcsw += p->signal->nivcsw;
                         r->ru_minflt += p->signal->min_flt;