Merge branch 'misc.compat' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs

Pull misc compat stuff updates from Al Viro:
 "This part is basically untangling various compat stuff. Compat
  syscalls moved to their native counterparts, getting rid of quite a
  bit of double-copying and/or set_fs() uses. A lot of field-by-field
  copyin/copyout killed off.

   - kernel/compat.c is much closer to containing just the
     copyin/copyout of compat structs. Not all compat syscalls are gone
     from it yet, but it's getting there.

   - ipc/compat_mq.c killed off completely.

   - block/compat_ioctl.c cleaned up; floppy compat ioctls moved to
     drivers/block/floppy.c where they belong. Yes, there are several
     drivers that implement some of the same ioctls. Some are m68k and
     one is 32bit-only pmac. drivers/block/floppy.c is the only one in
     that bunch that can be built on biarch"

* 'misc.compat' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs:
  mqueue: move compat syscalls to native ones
  usbdevfs: get rid of field-by-field copyin
  compat_hdio_ioctl: get rid of set_fs()
  take floppy compat ioctls to sodding floppy.c
  ipmi: get rid of field-by-field __get_user()
  ipmi: get COMPAT_IPMICTL_RECEIVE_MSG in sync with the native one
  rt_sigtimedwait(): move compat to native
  select: switch compat_{get,put}_fd_set() to compat_{get,put}_bitmap()
  put_compat_rusage(): switch to copy_to_user()
  sigpending(): move compat to native
  getrlimit()/setrlimit(): move compat to native
  times(2): move compat to native
  compat_{get,put}_bitmap(): use unsafe_{get,put}_user()
  fb_get_fscreeninfo(): don't bother with do_fb_ioctl()
  do_sigaltstack(): lift copying to/from userland into callers
  take compat_sys_old_getrlimit() to native syscall
  trim __ARCH_WANT_SYS_OLD_GETRLIMIT

1 files changed, 99 insertions, 1 deletions

diff --git a/kernel/sys.c b/kernel/sys.c
index dab1a0658a92..47d901586b4e 100644
--- a/kernel/sys.c
+++ b/kernel/sys.c
@@ -886,7 +886,7 @@ SYSCALL_DEFINE0(getegid)
         return from_kgid_munged(current_user_ns(), current_egid());
 }
 
-void do_sys_times(struct tms *tms)
+static void do_sys_times(struct tms *tms)
 {
         u64 tgutime, tgstime, cutime, cstime;
 
@@ -912,6 +912,32 @@ SYSCALL_DEFINE1(times, struct tms __user *, tbuf)
         return (long) jiffies_64_to_clock_t(get_jiffies_64());
 }
 
+#ifdef CONFIG_COMPAT
+static compat_clock_t clock_t_to_compat_clock_t(clock_t x)
+{
+        return compat_jiffies_to_clock_t(clock_t_to_jiffies(x));
+}
+
+COMPAT_SYSCALL_DEFINE1(times, struct compat_tms __user *, tbuf)
+{
+        if (tbuf) {
+                struct tms tms;
+                struct compat_tms tmp;
+
+                do_sys_times(&tms);
+                /* Convert our struct tms to the compat version. */
+                tmp.tms_utime = clock_t_to_compat_clock_t(tms.tms_utime);
+                tmp.tms_stime = clock_t_to_compat_clock_t(tms.tms_stime);
+                tmp.tms_cutime = clock_t_to_compat_clock_t(tms.tms_cutime);
+                tmp.tms_cstime = clock_t_to_compat_clock_t(tms.tms_cstime);
+                if (copy_to_user(tbuf, &tmp, sizeof(tmp)))
+                        return -EFAULT;
+        }
+        force_successful_syscall_return();
+        return compat_jiffies_to_clock_t(jiffies);
+}
+#endif
+
 /*
  * This needs some heavy checking ...
  * I just haven't the stomach for it. I also don't fully
@@ -1306,6 +1332,54 @@ SYSCALL_DEFINE2(getrlimit, unsigned int, resource, struct rlimit __user *, rlim)
         return ret;
 }
 
+#ifdef CONFIG_COMPAT
+
+COMPAT_SYSCALL_DEFINE2(setrlimit, unsigned int, resource,
+                       struct compat_rlimit __user *, rlim)
+{
+        struct rlimit r;
+        struct compat_rlimit r32;
+
+        if (copy_from_user(&r32, rlim, sizeof(struct compat_rlimit)))
+                return -EFAULT;
+
+        if (r32.rlim_cur == COMPAT_RLIM_INFINITY)
+                r.rlim_cur = RLIM_INFINITY;
+        else
+                r.rlim_cur = r32.rlim_cur;
+        if (r32.rlim_max == COMPAT_RLIM_INFINITY)
+                r.rlim_max = RLIM_INFINITY;
+        else
+                r.rlim_max = r32.rlim_max;
+        return do_prlimit(current, resource, &r, NULL);
+}
+
+COMPAT_SYSCALL_DEFINE2(getrlimit, unsigned int, resource,
+                       struct compat_rlimit __user *, rlim)
+{
+        struct rlimit r;
+        int ret;
+
+        ret = do_prlimit(current, resource, NULL, &r);
+        if (!ret) {
+                struct rlimit r32;
+                if (r.rlim_cur > COMPAT_RLIM_INFINITY)
+                        r32.rlim_cur = COMPAT_RLIM_INFINITY;
+                else
+                        r32.rlim_cur = r.rlim_cur;
+                if (r.rlim_max > COMPAT_RLIM_INFINITY)
+                        r32.rlim_max = COMPAT_RLIM_INFINITY;
+                else
+                        r32.rlim_max = r.rlim_max;
+
+                if (copy_to_user(rlim, &r32, sizeof(struct compat_rlimit)))
+                        return -EFAULT;
+        }
+        return ret;
+}
+
+#endif
+
 #ifdef __ARCH_WANT_SYS_OLD_GETRLIMIT
 
 /*
@@ -1328,6 +1402,30 @@ SYSCALL_DEFINE2(old_getrlimit, unsigned int, resource,
         return copy_to_user(rlim, &x, sizeof(x)) ? -EFAULT : 0;
 }
 
+#ifdef CONFIG_COMPAT
+COMPAT_SYSCALL_DEFINE2(old_getrlimit, unsigned int, resource,
+                       struct compat_rlimit __user *, rlim)
+{
+        struct rlimit r;
+
+        if (resource >= RLIM_NLIMITS)
+                return -EINVAL;
+
+        task_lock(current->group_leader);
+        r = current->signal->rlim[resource];
+        task_unlock(current->group_leader);
+        if (r.rlim_cur > 0x7FFFFFFF)
+                r.rlim_cur = 0x7FFFFFFF;
+        if (r.rlim_max > 0x7FFFFFFF)
+                r.rlim_max = 0x7FFFFFFF;
+
+        if (put_user(r.rlim_cur, &rlim->rlim_cur) ||
+            put_user(r.rlim_max, &rlim->rlim_max))
+                return -EFAULT;
+        return 0;
+}
+#endif
+
 #endif
 
 static inline bool rlim64_is_infinity(__u64 rlim64)