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

Pull compat and uaccess updates from Al Viro:

 - {get,put}_compat_sigset() series

 - assorted compat ioctl stuff

 - more set_fs() elimination

 - a few more timespec64 conversions

 - several removals of pointless access_ok() in places where it was
   followed only by non-__ variants of primitives

* 'misc.compat' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs: (24 commits)
  coredump: call do_unlinkat directly instead of sys_unlink
  fs: expose do_unlinkat for built-in callers
  ext4: take handling of EXT4_IOC_GROUP_ADD into a helper, get rid of set_fs()
  ipmi: get rid of pointless access_ok()
  pi433: sanitize ioctl
  cxlflash: get rid of pointless access_ok()
  mtdchar: get rid of pointless access_ok()
  r128: switch compat ioctls to drm_ioctl_kernel()
  selection: get rid of field-by-field copyin
  VT_RESIZEX: get rid of field-by-field copyin
  i2c compat ioctls: move to ->compat_ioctl()
  sched_rr_get_interval(): move compat to native, get rid of set_fs()
  mips: switch to {get,put}_compat_sigset()
  sparc: switch to {get,put}_compat_sigset()
  s390: switch to {get,put}_compat_sigset()
  ppc: switch to {get,put}_compat_sigset()
  parisc: switch to {get,put}_compat_sigset()
  get_compat_sigset()
  get rid of {get,put}_compat_itimerspec()
  io_getevents: Use timespec64 to represent timeouts
  ...

9 files changed, 108 insertions, 251 deletions

diff --git a/fs/aio.c b/fs/aio.c
index e6de7715228c..a062d75109cb 100644
--- a/fs/aio.c
+++ b/fs/aio.c
@@ -1297,20 +1297,10 @@ static bool aio_read_events(struct kioctx *ctx, long min_nr, long nr,
 
 static long read_events(struct kioctx *ctx, long min_nr, long nr,
                         struct io_event __user *event,
-                        struct timespec __user *timeout)
+                        ktime_t until)
 {
-        ktime_t until = KTIME_MAX;
         long ret = 0;
 
-        if (timeout) {
-                struct timespec ts;
-
-                if (unlikely(copy_from_user(&ts, timeout, sizeof(ts))))
-                        return -EFAULT;
-
-                until = timespec_to_ktime(ts);
-        }
-
         /*
          * Note that aio_read_events() is being called as the conditional - i.e.
          * we're calling it after prepare_to_wait() has set task state to
@@ -1826,6 +1816,25 @@ SYSCALL_DEFINE3(io_cancel, aio_context_t, ctx_id, struct iocb __user *, iocb,
         return ret;
 }
 
+static long do_io_getevents(aio_context_t ctx_id,
+                long min_nr,
+                long nr,
+                struct io_event __user *events,
+                struct timespec64 *ts)
+{
+        ktime_t until = ts ? timespec64_to_ktime(*ts) : KTIME_MAX;
+        struct kioctx *ioctx = lookup_ioctx(ctx_id);
+        long ret = -EINVAL;
+
+        if (likely(ioctx)) {
+                if (likely(min_nr <= nr && min_nr >= 0))
+                        ret = read_events(ioctx, min_nr, nr, events, until);
+                percpu_ref_put(&ioctx->users);
+        }
+
+        return ret;
+}
+
 /* io_getevents:
  *      Attempts to read at least min_nr events and up to nr events from
  *      the completion queue for the aio_context specified by ctx_id. If
@@ -1844,15 +1853,14 @@ SYSCALL_DEFINE5(io_getevents, aio_context_t, ctx_id,
                 struct io_event __user *, events,
                 struct timespec __user *, timeout)
 {
-        struct kioctx *ioctx = lookup_ioctx(ctx_id);
-        long ret = -EINVAL;
+        struct timespec64       ts;
 
-        if (likely(ioctx)) {
-                if (likely(min_nr <= nr && min_nr >= 0))
-                        ret = read_events(ioctx, min_nr, nr, events, timeout);
-                percpu_ref_put(&ioctx->users);
+        if (timeout) {
+                if (unlikely(get_timespec64(&ts, timeout)))
+                        return -EFAULT;
         }
-        return ret;
+
+        return do_io_getevents(ctx_id, min_nr, nr, events, timeout ? &ts : NULL);
 }
 
 #ifdef CONFIG_COMPAT
@@ -1862,17 +1870,14 @@ COMPAT_SYSCALL_DEFINE5(io_getevents, compat_aio_context_t, ctx_id,
                        struct io_event __user *, events,
                        struct compat_timespec __user *, timeout)
 {
-        struct timespec t;
-        struct timespec __user *ut = NULL;
+        struct timespec64 t;
 
         if (timeout) {
-                if (compat_get_timespec(&t, timeout))
+                if (compat_get_timespec64(&t, timeout))
                         return -EFAULT;
 
-                ut = compat_alloc_user_space(sizeof(*ut));
-                if (copy_to_user(ut, &t, sizeof(t)))
-                        return -EFAULT;
         }
-        return sys_io_getevents(ctx_id, min_nr, nr, events, ut);
+
+        return do_io_getevents(ctx_id, min_nr, nr, events, timeout ? &t : NULL);
 }
 #endif
diff --git a/fs/compat_ioctl.c b/fs/compat_ioctl.c
index bd5d91e119ca..f95aa0b2e9c0 100644
--- a/fs/compat_ioctl.c
+++ b/fs/compat_ioctl.c
@@ -54,8 +54,6 @@
 #include <linux/if_tun.h>
 #include <linux/ctype.h>
 #include <linux/syscalls.h>
-#include <linux/i2c.h>
-#include <linux/i2c-dev.h>
 #include <linux/atalk.h>
 #include <linux/gfp.h>
 #include <linux/cec.h>
@@ -137,22 +135,6 @@ static int do_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
         return vfs_ioctl(file, cmd, arg);
 }
 
-static int w_long(struct file *file,
-                unsigned int cmd, compat_ulong_t __user *argp)
-{
-        int err;
-        unsigned long __user *valp = compat_alloc_user_space(sizeof(*valp));
-
-        if (valp == NULL)
-                return -EFAULT;
-        err = do_ioctl(file, cmd, (unsigned long)valp);
-        if (err)
-                return err;
-        if (convert_in_user(valp, argp))
-                return -EFAULT;
-        return 0;
-}
-
 struct compat_video_event {
         int32_t         type;
         compat_time_t   timestamp;
@@ -671,96 +653,6 @@ static int serial_struct_ioctl(struct file *file,
         return err;
 }
 
-/*
- * I2C layer ioctls
- */
-
-struct i2c_msg32 {
-        u16 addr;
-        u16 flags;
-        u16 len;
-        compat_caddr_t buf;
-};
-
-struct i2c_rdwr_ioctl_data32 {
-        compat_caddr_t msgs; /* struct i2c_msg __user *msgs */
-        u32 nmsgs;
-};
-
-struct i2c_smbus_ioctl_data32 {
-        u8 read_write;
-        u8 command;
-        u32 size;
-        compat_caddr_t data; /* union i2c_smbus_data *data */
-};
-
-struct i2c_rdwr_aligned {
-        struct i2c_rdwr_ioctl_data cmd;
-        struct i2c_msg msgs[0];
-};
-
-static int do_i2c_rdwr_ioctl(struct file *file,
-        unsigned int cmd, struct i2c_rdwr_ioctl_data32 __user *udata)
-{
-        struct i2c_rdwr_aligned         __user *tdata;
-        struct i2c_msg                  __user *tmsgs;
-        struct i2c_msg32                __user *umsgs;
-        compat_caddr_t                  datap;
-        u32                             nmsgs;
-        int                             i;
-
-        if (get_user(nmsgs, &udata->nmsgs))
-                return -EFAULT;
-        if (nmsgs > I2C_RDWR_IOCTL_MAX_MSGS)
-                return -EINVAL;
-
-        if (get_user(datap, &udata->msgs))
-                return -EFAULT;
-        umsgs = compat_ptr(datap);
-
-        tdata = compat_alloc_user_space(sizeof(*tdata) +
-                                      nmsgs * sizeof(struct i2c_msg));
-        tmsgs = &tdata->msgs[0];
-
-        if (put_user(nmsgs, &tdata->cmd.nmsgs) ||
-            put_user(tmsgs, &tdata->cmd.msgs))
-                return -EFAULT;
-
-        for (i = 0; i < nmsgs; i++) {
-                if (copy_in_user(&tmsgs[i].addr, &umsgs[i].addr, 3*sizeof(u16)))
-                        return -EFAULT;
-                if (get_user(datap, &umsgs[i].buf) ||
-                    put_user(compat_ptr(datap), &tmsgs[i].buf))
-                        return -EFAULT;
-        }
-        return do_ioctl(file, cmd, (unsigned long)tdata);
-}
-
-static int do_i2c_smbus_ioctl(struct file *file,
-                unsigned int cmd, struct i2c_smbus_ioctl_data32   __user *udata)
-{
-        struct i2c_smbus_ioctl_data     __user *tdata;
-        union {
-                /* beginnings of those have identical layouts */
-                struct i2c_smbus_ioctl_data32   data32;
-                struct i2c_smbus_ioctl_data     data;
-        } v;
-
-        tdata = compat_alloc_user_space(sizeof(*tdata));
-        if (tdata == NULL)
-                return -ENOMEM;
-
-        memset(&v, 0, sizeof(v));
-        if (copy_from_user(&v.data32, udata, sizeof(v.data32)))
-                return -EFAULT;
-        v.data.data = compat_ptr(v.data32.data);
-
-        if (copy_to_user(tdata, &v.data, sizeof(v.data)))
-                return -EFAULT;
-
-        return do_ioctl(file, cmd, (unsigned long)tdata);
-}
-
 #define RTC_IRQP_READ32         _IOR('p', 0x0b, compat_ulong_t)
 #define RTC_IRQP_SET32          _IOW('p', 0x0c, compat_ulong_t)
 #define RTC_EPOCH_READ32        _IOR('p', 0x0d, compat_ulong_t)
@@ -1283,13 +1175,6 @@ COMPATIBLE_IOCTL(PCIIOC_CONTROLLER)
 COMPATIBLE_IOCTL(PCIIOC_MMAP_IS_IO)
 COMPATIBLE_IOCTL(PCIIOC_MMAP_IS_MEM)
 COMPATIBLE_IOCTL(PCIIOC_WRITE_COMBINE)
-/* i2c */
-COMPATIBLE_IOCTL(I2C_SLAVE)
-COMPATIBLE_IOCTL(I2C_SLAVE_FORCE)
-COMPATIBLE_IOCTL(I2C_TENBIT)
-COMPATIBLE_IOCTL(I2C_PEC)
-COMPATIBLE_IOCTL(I2C_RETRIES)
-COMPATIBLE_IOCTL(I2C_TIMEOUT)
 /* hiddev */
 COMPATIBLE_IOCTL(HIDIOCGVERSION)
 COMPATIBLE_IOCTL(HIDIOCAPPLICATION)
@@ -1464,13 +1349,6 @@ static long do_ioctl_trans(unsigned int cmd,
         case TIOCGSERIAL:
         case TIOCSSERIAL:
                 return serial_struct_ioctl(file, cmd, argp);
-        /* i2c */
-        case I2C_FUNCS:
-                return w_long(file, cmd, argp);
-        case I2C_RDWR:
-                return do_i2c_rdwr_ioctl(file, cmd, argp);
-        case I2C_SMBUS:
-                return do_i2c_smbus_ioctl(file, cmd, argp);
         /* Not implemented in the native kernel */
         case RTC_IRQP_READ32:
         case RTC_IRQP_SET32:
diff --git a/fs/coredump.c b/fs/coredump.c
index 52c63d6c9143..1e2c87acac9b 100644
--- a/fs/coredump.c
+++ b/fs/coredump.c
@@ -680,16 +680,11 @@ void do_coredump(const siginfo_t *siginfo)
                  * privs and don't want to unlink another user's coredump.
                  */
                 if (!need_suid_safe) {
-                        mm_segment_t old_fs;
-
-                        old_fs = get_fs();
-                        set_fs(KERNEL_DS);
                         /*
                          * If it doesn't exist, that's fine. If there's some
                          * other problem, we'll catch it at the filp_open().
                          */
-                        (void) sys_unlink((const char __user *)cn.corename);
-                        set_fs(old_fs);
+                        do_unlinkat(AT_FDCWD, getname_kernel(cn.corename));
                 }
 
                 /*
diff --git a/fs/eventpoll.c b/fs/eventpoll.c
index 2fabd19cdeea..396a3c075fd4 100644
--- a/fs/eventpoll.c
+++ b/fs/eventpoll.c
@@ -2259,7 +2259,6 @@ COMPAT_SYSCALL_DEFINE6(epoll_pwait, int, epfd,
                         compat_size_t, sigsetsize)
 {
         long err;
-        compat_sigset_t csigmask;
         sigset_t ksigmask, sigsaved;
 
         /*
@@ -2269,9 +2268,8 @@ COMPAT_SYSCALL_DEFINE6(epoll_pwait, int, epfd,
         if (sigmask) {
                 if (sigsetsize != sizeof(compat_sigset_t))
                         return -EINVAL;
-                if (copy_from_user(&csigmask, sigmask, sizeof(csigmask)))
+                if (get_compat_sigset(&ksigmask, sigmask))
                         return -EFAULT;
-                sigset_from_compat(&ksigmask, &csigmask);
                 sigsaved = current->blocked;
                 set_current_blocked(&ksigmask);
         }
diff --git a/fs/ext4/ioctl.c b/fs/ext4/ioctl.c
index b7558f292420..1eec25014f62 100644
--- a/fs/ext4/ioctl.c
+++ b/fs/ext4/ioctl.c
@@ -592,6 +592,44 @@ static int ext4_ioc_getfsmap(struct super_block *sb,
         return 0;
 }
 
+static long ext4_ioctl_group_add(struct file *file,
+                                 struct ext4_new_group_data *input)
+{
+        struct super_block *sb = file_inode(file)->i_sb;
+        int err, err2=0;
+
+        err = ext4_resize_begin(sb);
+        if (err)
+                return err;
+
+        if (ext4_has_feature_bigalloc(sb)) {
+                ext4_msg(sb, KERN_ERR,
+                         "Online resizing not supported with bigalloc");
+                err = -EOPNOTSUPP;
+                goto group_add_out;
+        }
+
+        err = mnt_want_write_file(file);
+        if (err)
+                goto group_add_out;
+
+        err = ext4_group_add(sb, input);
+        if (EXT4_SB(sb)->s_journal) {
+                jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal);
+                err2 = jbd2_journal_flush(EXT4_SB(sb)->s_journal);
+                jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
+        }
+        if (err == 0)
+                err = err2;
+        mnt_drop_write_file(file);
+        if (!err && ext4_has_group_desc_csum(sb) &&
+            test_opt(sb, INIT_INODE_TABLE))
+                err = ext4_register_li_request(sb, input->group);
+group_add_out:
+        ext4_resize_end(sb);
+        return err;
+}
+
 long ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 {
         struct inode *inode = file_inode(filp);
@@ -776,44 +814,12 @@ mext_out:
 
         case EXT4_IOC_GROUP_ADD: {
                 struct ext4_new_group_data input;
-                int err, err2=0;
-
-                err = ext4_resize_begin(sb);
-                if (err)
-                        return err;
 
                 if (copy_from_user(&input, (struct ext4_new_group_input __user *)arg,
-                                sizeof(input))) {
-                        err = -EFAULT;
-                        goto group_add_out;
-                }
-
-                if (ext4_has_feature_bigalloc(sb)) {
-                        ext4_msg(sb, KERN_ERR,
-                                 "Online resizing not supported with bigalloc");
-                        err = -EOPNOTSUPP;
-                        goto group_add_out;
-                }
-
-                err = mnt_want_write_file(filp);
-                if (err)
-                        goto group_add_out;
+                                sizeof(input)))
+                        return -EFAULT;
 
-                err = ext4_group_add(sb, &input);
-                if (EXT4_SB(sb)->s_journal) {
-                        jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal);
-                        err2 = jbd2_journal_flush(EXT4_SB(sb)->s_journal);
-                        jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
-                }
-                if (err == 0)
-                        err = err2;
-                mnt_drop_write_file(filp);
-                if (!err && ext4_has_group_desc_csum(sb) &&
-                    test_opt(sb, INIT_INODE_TABLE))
-                        err = ext4_register_li_request(sb, input.group);
-group_add_out:
-                ext4_resize_end(sb);
-                return err;
+                return ext4_ioctl_group_add(filp, &input);
         }
 
         case EXT4_IOC_MIGRATE:
@@ -1078,8 +1084,7 @@ long ext4_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                 break;
         case EXT4_IOC32_GROUP_ADD: {
                 struct compat_ext4_new_group_input __user *uinput;
-                struct ext4_new_group_input input;
-                mm_segment_t old_fs;
+                struct ext4_new_group_data input;
                 int err;
 
                 uinput = compat_ptr(arg);
@@ -1092,12 +1097,7 @@ long ext4_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                                 &uinput->reserved_blocks);
                 if (err)
                         return -EFAULT;
-                old_fs = get_fs();
-                set_fs(KERNEL_DS);
-                err = ext4_ioctl(file, EXT4_IOC_GROUP_ADD,
-                                 (unsigned long) &input);
-                set_fs(old_fs);
-                return err;
+                return ext4_ioctl_group_add(file, &input);
         }
         case EXT4_IOC_MOVE_EXT:
         case EXT4_IOC_RESIZE_FS:
diff --git a/fs/internal.h b/fs/internal.h
index 48cee21b4f14..df262f41a0ef 100644
--- a/fs/internal.h
+++ b/fs/internal.h
@@ -55,6 +55,7 @@ extern void __init chrdev_init(void);
 extern int user_path_mountpoint_at(int, const char __user *, unsigned int, struct path *);
 extern int vfs_path_lookup(struct dentry *, struct vfsmount *,
                            const char *, unsigned int, struct path *);
+long do_unlinkat(int dfd, struct filename *name);
 
 /*
  * namespace.c
diff --git a/fs/namei.c b/fs/namei.c
index 5424b10cfdc4..287781363763 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -4010,10 +4010,9 @@ EXPORT_SYMBOL(vfs_unlink);
  * writeout happening, and we don't want to prevent access to the directory
  * while waiting on the I/O.
  */
-static long do_unlinkat(int dfd, const char __user *pathname)
+long do_unlinkat(int dfd, struct filename *name)
 {
         int error;
-        struct filename *name;
         struct dentry *dentry;
         struct path path;
         struct qstr last;
@@ -4022,8 +4021,7 @@ static long do_unlinkat(int dfd, const char __user *pathname)
         struct inode *delegated_inode = NULL;
         unsigned int lookup_flags = 0;
 retry:
-        name = filename_parentat(dfd, getname(pathname), lookup_flags,
-                                &path, &last, &type);
+        name = filename_parentat(dfd, name, lookup_flags, &path, &last, &type);
         if (IS_ERR(name))
                 return PTR_ERR(name);
 
@@ -4065,12 +4063,12 @@ exit2:
         mnt_drop_write(path.mnt);
 exit1:
         path_put(&path);
-        putname(name);
         if (retry_estale(error, lookup_flags)) {
                 lookup_flags |= LOOKUP_REVAL;
                 inode = NULL;
                 goto retry;
         }
+        putname(name);
         return error;
 
 slashes:
@@ -4091,12 +4089,12 @@ SYSCALL_DEFINE3(unlinkat, int, dfd, const char __user *, pathname, int, flag)
         if (flag & AT_REMOVEDIR)
                 return do_rmdir(dfd, pathname);
 
-        return do_unlinkat(dfd, pathname);
+        return do_unlinkat(dfd, getname(pathname));
 }
 
 SYSCALL_DEFINE1(unlink, const char __user *, pathname)
 {
-        return do_unlinkat(AT_FDCWD, pathname);
+        return do_unlinkat(AT_FDCWD, getname(pathname));
 }
 
 int vfs_symlink(struct inode *dir, struct dentry *dentry, const char *oldname)
diff --git a/fs/select.c b/fs/select.c
index 063067e606ca..6de493bb42a4 100644
--- a/fs/select.c
+++ b/fs/select.c
@@ -292,8 +292,7 @@ static int poll_select_copy_remaining(struct timespec64 *end_time,
                                       void __user *p,
                                       int timeval, int ret)
 {
-        struct timespec64 rts64;
-        struct timespec rts;
+        struct timespec64 rts;
         struct timeval rtv;
 
         if (!p)
@@ -306,23 +305,22 @@ static int poll_select_copy_remaining(struct timespec64 *end_time,
         if (!end_time->tv_sec && !end_time->tv_nsec)
                 return ret;
 
-        ktime_get_ts64(&rts64);
-        rts64 = timespec64_sub(*end_time, rts64);
-        if (rts64.tv_sec < 0)
-                rts64.tv_sec = rts64.tv_nsec = 0;
+        ktime_get_ts64(&rts);
+        rts = timespec64_sub(*end_time, rts);
+        if (rts.tv_sec < 0)
+                rts.tv_sec = rts.tv_nsec = 0;
 
-        rts = timespec64_to_timespec(rts64);
 
         if (timeval) {
                 if (sizeof(rtv) > sizeof(rtv.tv_sec) + sizeof(rtv.tv_usec))
                         memset(&rtv, 0, sizeof(rtv));
-                rtv.tv_sec = rts64.tv_sec;
-                rtv.tv_usec = rts64.tv_nsec / NSEC_PER_USEC;
+                rtv.tv_sec = rts.tv_sec;
+                rtv.tv_usec = rts.tv_nsec / NSEC_PER_USEC;
 
                 if (!copy_to_user(p, &rtv, sizeof(rtv)))
                         return ret;
 
-        } else if (!copy_to_user(p, &rts, sizeof(rts)))
+        } else if (!put_timespec64(&rts, p))
                 return ret;
 
         /*
@@ -705,17 +703,15 @@ static long do_pselect(int n, fd_set __user *inp, fd_set __user *outp,
                        const sigset_t __user *sigmask, size_t sigsetsize)
 {
         sigset_t ksigmask, sigsaved;
-        struct timespec ts;
-        struct timespec64 ts64, end_time, *to = NULL;
+        struct timespec64 ts, end_time, *to = NULL;
         int ret;
 
         if (tsp) {
-                if (copy_from_user(&ts, tsp, sizeof(ts)))
+                if (get_timespec64(&ts, tsp))
                         return -EFAULT;
-                ts64 = timespec_to_timespec64(ts);
 
                 to = &end_time;
-                if (poll_select_set_timeout(to, ts64.tv_sec, ts64.tv_nsec))
+                if (poll_select_set_timeout(to, ts.tv_sec, ts.tv_nsec))
                         return -EINVAL;
         }
 
@@ -1052,12 +1048,11 @@ SYSCALL_DEFINE5(ppoll, struct pollfd __user *, ufds, unsigned int, nfds,
                 size_t, sigsetsize)
 {
         sigset_t ksigmask, sigsaved;
-        struct timespec ts;
-        struct timespec64 end_time, *to = NULL;
+        struct timespec64 ts, end_time, *to = NULL;
         int ret;
 
         if (tsp) {
-                if (copy_from_user(&ts, tsp, sizeof(ts)))
+                if (get_timespec64(&ts, tsp))
                         return -EFAULT;
 
                 to = &end_time;
@@ -1103,10 +1098,10 @@ SYSCALL_DEFINE5(ppoll, struct pollfd __user *, ufds, unsigned int, nfds,
 #define __COMPAT_NFDBITS       (8 * sizeof(compat_ulong_t))
 
 static
-int compat_poll_select_copy_remaining(struct timespec *end_time, void __user *p,
+int compat_poll_select_copy_remaining(struct timespec64 *end_time, void __user *p,
                                       int timeval, int ret)
 {
-        struct timespec ts;
+        struct timespec64 ts;
 
         if (!p)
                 return ret;
@@ -1118,8 +1113,8 @@ int compat_poll_select_copy_remaining(struct timespec *end_time, void __user *p,
         if (!end_time->tv_sec && !end_time->tv_nsec)
                 return ret;
 
-        ktime_get_ts(&ts);
-        ts = timespec_sub(*end_time, ts);
+        ktime_get_ts64(&ts);
+        ts = timespec64_sub(*end_time, ts);
         if (ts.tv_sec < 0)
                 ts.tv_sec = ts.tv_nsec = 0;
 
@@ -1132,12 +1127,7 @@ int compat_poll_select_copy_remaining(struct timespec *end_time, void __user *p,
                 if (!copy_to_user(p, &rtv, sizeof(rtv)))
                         return ret;
         } else {
-                struct compat_timespec rts;
-
-                rts.tv_sec = ts.tv_sec;
-                rts.tv_nsec = ts.tv_nsec;
-
-                if (!copy_to_user(p, &rts, sizeof(rts)))
+                if (!compat_put_timespec64(&ts, p))
                         return ret;
         }
         /*
@@ -1195,7 +1185,7 @@ int compat_set_fd_set(unsigned long nr, compat_ulong_t __user *ufdset,
  */
 static int compat_core_sys_select(int n, compat_ulong_t __user *inp,
         compat_ulong_t __user *outp, compat_ulong_t __user *exp,
-        struct timespec *end_time)
+        struct timespec64 *end_time)
 {
         fd_set_bits fds;
         void *bits;
@@ -1268,7 +1258,7 @@ COMPAT_SYSCALL_DEFINE5(select, int, n, compat_ulong_t __user *, inp,
         compat_ulong_t __user *, outp, compat_ulong_t __user *, exp,
         struct compat_timeval __user *, tvp)
 {
-        struct timespec end_time, *to = NULL;
+        struct timespec64 end_time, *to = NULL;
         struct compat_timeval tv;
         int ret;
 
@@ -1312,14 +1302,12 @@ static long do_compat_pselect(int n, compat_ulong_t __user *inp,
         struct compat_timespec __user *tsp, compat_sigset_t __user *sigmask,
         compat_size_t sigsetsize)
 {
-        compat_sigset_t ss32;
         sigset_t ksigmask, sigsaved;
-        struct compat_timespec ts;
-        struct timespec end_time, *to = NULL;
+        struct timespec64 ts, end_time, *to = NULL;
         int ret;
 
         if (tsp) {
-                if (copy_from_user(&ts, tsp, sizeof(ts)))
+                if (compat_get_timespec64(&ts, tsp))
                         return -EFAULT;
 
                 to = &end_time;
@@ -1330,9 +1318,8 @@ static long do_compat_pselect(int n, compat_ulong_t __user *inp,
         if (sigmask) {
                 if (sigsetsize != sizeof(compat_sigset_t))
                         return -EINVAL;
-                if (copy_from_user(&ss32, sigmask, sizeof(ss32)))
+                if (get_compat_sigset(&ksigmask, sigmask))
                         return -EFAULT;
-                sigset_from_compat(&ksigmask, &ss32);
 
                 sigdelsetmask(&ksigmask, sigmask(SIGKILL)|sigmask(SIGSTOP));
                 sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved);
@@ -1381,14 +1368,12 @@ COMPAT_SYSCALL_DEFINE5(ppoll, struct pollfd __user *, ufds,
         unsigned int,  nfds, struct compat_timespec __user *, tsp,
         const compat_sigset_t __user *, sigmask, compat_size_t, sigsetsize)
 {
-        compat_sigset_t ss32;
         sigset_t ksigmask, sigsaved;
-        struct compat_timespec ts;
-        struct timespec end_time, *to = NULL;
+        struct timespec64 ts, end_time, *to = NULL;
         int ret;
 
         if (tsp) {
-                if (copy_from_user(&ts, tsp, sizeof(ts)))
+                if (compat_get_timespec64(&ts, tsp))
                         return -EFAULT;
 
                 to = &end_time;
@@ -1399,9 +1384,8 @@ COMPAT_SYSCALL_DEFINE5(ppoll, struct pollfd __user *, ufds,
         if (sigmask) {
                 if (sigsetsize != sizeof(compat_sigset_t))
                         return -EINVAL;
-                if (copy_from_user(&ss32, sigmask, sizeof(ss32)))
+                if (get_compat_sigset(&ksigmask, sigmask))
                         return -EFAULT;
-                sigset_from_compat(&ksigmask, &ss32);
 
                 sigdelsetmask(&ksigmask, sigmask(SIGKILL)|sigmask(SIGSTOP));
                 sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved);
diff --git a/fs/signalfd.c b/fs/signalfd.c
index 1c667af86da5..5f1ff8756595 100644
--- a/fs/signalfd.c
+++ b/fs/signalfd.c
@@ -313,15 +313,13 @@ COMPAT_SYSCALL_DEFINE4(signalfd4, int, ufd,
                      compat_size_t, sigsetsize,
                      int, flags)
 {
-        compat_sigset_t ss32;
         sigset_t tmp;
         sigset_t __user *ksigmask;
 
         if (sigsetsize != sizeof(compat_sigset_t))
                 return -EINVAL;
-        if (copy_from_user(&ss32, sigmask, sizeof(ss32)))
+        if (get_compat_sigset(&tmp, sigmask))
                 return -EFAULT;
-        sigset_from_compat(&tmp, &ss32);
         ksigmask = compat_alloc_user_space(sizeof(sigset_t));
         if (copy_to_user(ksigmask, &tmp, sizeof(sigset_t)))
                 return -EFAULT;