Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/signal

Pull signal handling cleanups from Al Viro:
 "This is the first pile; another one will come a bit later and will
  contain SYSCALL_DEFINE-related patches.

   - a bunch of signal-related syscalls (both native and compat)
     unified.

   - a bunch of compat syscalls switched to COMPAT_SYSCALL_DEFINE
     (fixing several potential problems with missing argument
     validation, while we are at it)

   - a lot of now-pointless wrappers killed

   - a couple of architectures (cris and hexagon) forgot to save
     altstack settings into sigframe, even though they used the
     (uninitialized) values in sigreturn; fixed.

   - microblaze fixes for delivery of multiple signals arriving at once

   - saner set of helpers for signal delivery introduced, several
     architectures switched to using those."

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/signal: (143 commits)
  x86: convert to ksignal
  sparc: convert to ksignal
  arm: switch to struct ksignal * passing
  alpha: pass k_sigaction and siginfo_t using ksignal pointer
  burying unused conditionals
  make do_sigaltstack() static
  arm64: switch to generic old sigaction() (compat-only)
  arm64: switch to generic compat rt_sigaction()
  arm64: switch compat to generic old sigsuspend
  arm64: switch to generic compat rt_sigqueueinfo()
  arm64: switch to generic compat rt_sigpending()
  arm64: switch to generic compat rt_sigprocmask()
  arm64: switch to generic sigaltstack
  sparc: switch to generic old sigsuspend
  sparc: COMPAT_SYSCALL_DEFINE does all sign-extension as well as SYSCALL_DEFINE
  sparc: kill sign-extending wrappers for native syscalls
  kill sparc32_open()
  sparc: switch to use of generic old sigaction
  sparc: switch sys_compat_rt_sigaction() to COMPAT_SYSCALL_DEFINE
  mips: switch to generic sys_fork() and sys_clone()
  ...

10 files changed, 32 insertions, 491 deletions

diff --git a/arch/s390/Kconfig b/arch/s390/Kconfig
index b220e152aefa..f09ae7b0b4c5 100644
--- a/arch/s390/Kconfig
+++ b/arch/s390/Kconfig
@@ -137,6 +137,8 @@ config S390
         select INIT_ALL_POSSIBLE
         select KTIME_SCALAR if 32BIT
         select MODULES_USE_ELF_RELA
+        select OLD_SIGSUSPEND3
+        select OLD_SIGACTION
         select SYSCTL_EXCEPTION_TRACE
         select USE_GENERIC_SMP_HELPERS if SMP
         select VIRT_CPU_ACCOUNTING
@@ -249,6 +251,7 @@ config COMPAT
         depends on 64BIT
         select COMPAT_BINFMT_ELF if BINFMT_ELF
         select ARCH_WANT_OLD_COMPAT_IPC
+        select COMPAT_OLD_SIGACTION
         help
           Select this option if you want to enable your system kernel to
           handle system-calls from ELF binaries for 31 bit ESA.  This option
diff --git a/arch/s390/include/asm/signal.h b/arch/s390/include/asm/signal.h
index db7ddfaf5b79..abf9e5735943 100644
--- a/arch/s390/include/asm/signal.h
+++ b/arch/s390/include/asm/signal.h
@@ -21,22 +21,5 @@ typedef struct {
         unsigned long sig[_NSIG_WORDS];
 } sigset_t;
 
-struct old_sigaction {
-        __sighandler_t sa_handler;
-        old_sigset_t sa_mask;
-        unsigned long sa_flags;
-        void (*sa_restorer)(void);
-};
-
-struct sigaction {
-        __sighandler_t sa_handler;
-        unsigned long sa_flags;
-        void (*sa_restorer)(void);
-        sigset_t sa_mask;               /* mask last for extensibility */
-};
-
-struct k_sigaction {
-        struct sigaction sa;
-};
-
+#define __ARCH_HAS_SA_RESTORER
 #endif
diff --git a/arch/s390/include/asm/unistd.h b/arch/s390/include/asm/unistd.h
index 636530872516..a6667a952969 100644
--- a/arch/s390/include/asm/unistd.h
+++ b/arch/s390/include/asm/unistd.h
@@ -43,15 +43,12 @@
 #define __ARCH_WANT_SYS_OLDUMOUNT
 #define __ARCH_WANT_SYS_SIGPENDING
 #define __ARCH_WANT_SYS_SIGPROCMASK
-#define __ARCH_WANT_SYS_RT_SIGACTION
-#define __ARCH_WANT_SYS_RT_SIGSUSPEND
 # ifndef CONFIG_64BIT
 #   define __ARCH_WANT_STAT64
 #   define __ARCH_WANT_SYS_TIME
 # endif
 # ifdef CONFIG_COMPAT
 #   define __ARCH_WANT_COMPAT_SYS_TIME
-#   define __ARCH_WANT_COMPAT_SYS_RT_SIGSUSPEND
 # endif
 #define __ARCH_WANT_SYS_FORK
 #define __ARCH_WANT_SYS_VFORK
diff --git a/arch/s390/kernel/compat_linux.c b/arch/s390/kernel/compat_linux.c
index 65cca95843e1..19f26de27fae 100644
--- a/arch/s390/kernel/compat_linux.c
+++ b/arch/s390/kernel/compat_linux.c
@@ -352,86 +352,6 @@ asmlinkage long sys32_ftruncate64(unsigned int fd, unsigned long high, unsigned
                 return sys_ftruncate(fd, (high << 32) | low);
 }
 
-asmlinkage long sys32_sched_rr_get_interval(compat_pid_t pid,
-                                struct compat_timespec __user *interval)
-{
-        struct timespec t;
-        int ret;
-        mm_segment_t old_fs = get_fs ();
-        
-        set_fs (KERNEL_DS);
-        ret = sys_sched_rr_get_interval(pid,
-                                        (struct timespec __force __user *) &t);
-        set_fs (old_fs);
-        if (put_compat_timespec(&t, interval))
-                return -EFAULT;
-        return ret;
-}
-
-asmlinkage long sys32_rt_sigprocmask(int how, compat_sigset_t __user *set,
-                        compat_sigset_t __user *oset, size_t sigsetsize)
-{
-        sigset_t s;
-        compat_sigset_t s32;
-        int ret;
-        mm_segment_t old_fs = get_fs();
-        
-        if (set) {
-                if (copy_from_user (&s32, set, sizeof(compat_sigset_t)))
-                        return -EFAULT;
-                s.sig[0] = s32.sig[0] | (((long)s32.sig[1]) << 32);
-        }
-        set_fs (KERNEL_DS);
-        ret = sys_rt_sigprocmask(how,
-                                 set ? (sigset_t __force __user *) &s : NULL,
-                                 oset ? (sigset_t __force __user *) &s : NULL,
-                                 sigsetsize);
-        set_fs (old_fs);
-        if (ret) return ret;
-        if (oset) {
-                s32.sig[1] = (s.sig[0] >> 32);
-                s32.sig[0] = s.sig[0];
-                if (copy_to_user (oset, &s32, sizeof(compat_sigset_t)))
-                        return -EFAULT;
-        }
-        return 0;
-}
-
-asmlinkage long sys32_rt_sigpending(compat_sigset_t __user *set,
-                                size_t sigsetsize)
-{
-        sigset_t s;
-        compat_sigset_t s32;
-        int ret;
-        mm_segment_t old_fs = get_fs();
-                
-        set_fs (KERNEL_DS);
-        ret = sys_rt_sigpending((sigset_t __force __user *) &s, sigsetsize);
-        set_fs (old_fs);
-        if (!ret) {
-                s32.sig[1] = (s.sig[0] >> 32);
-                s32.sig[0] = s.sig[0];
-                if (copy_to_user (set, &s32, sizeof(compat_sigset_t)))
-                        return -EFAULT;
-        }
-        return ret;
-}
-
-asmlinkage long
-sys32_rt_sigqueueinfo(int pid, int sig, compat_siginfo_t __user *uinfo)
-{
-        siginfo_t info;
-        int ret;
-        mm_segment_t old_fs = get_fs();
-        
-        if (copy_siginfo_from_user32(&info, uinfo))
-                return -EFAULT;
-        set_fs (KERNEL_DS);
-        ret = sys_rt_sigqueueinfo(pid, sig, (siginfo_t __force __user *) &info);
-        set_fs (old_fs);
-        return ret;
-}
-
 asmlinkage long sys32_pread64(unsigned int fd, char __user *ubuf,
                                 size_t count, u32 poshi, u32 poslo)
 {
diff --git a/arch/s390/kernel/compat_linux.h b/arch/s390/kernel/compat_linux.h
index d4d0239970ac..00d92a5a6f6c 100644
--- a/arch/s390/kernel/compat_linux.h
+++ b/arch/s390/kernel/compat_linux.h
@@ -17,13 +17,6 @@ struct ipc_kludge_32 {
         __s32   msgtyp;
 };
 
-struct old_sigaction32 {
-       __u32                    sa_handler;     /* Really a pointer, but need to deal with 32 bits */
-       compat_old_sigset_t      sa_mask;        /* A 32 bit mask */
-       __u32                    sa_flags;
-       __u32                    sa_restorer;    /* Another 32 bit pointer */
-};
-
 /* asm/sigcontext.h */
 typedef union
 {
@@ -68,24 +61,12 @@ struct sigcontext32
 };
 
 /* asm/signal.h */
-struct sigaction32 {
-        __u32           sa_handler;             /* pointer */
-        __u32           sa_flags;
-        __u32           sa_restorer;            /* pointer */
-        compat_sigset_t sa_mask;        /* mask last for extensibility */
-};
-
-typedef struct {
-        __u32                   ss_sp;          /* pointer */
-        int                     ss_flags;
-        compat_size_t           ss_size;
-} stack_t32;
 
 /* asm/ucontext.h */
 struct ucontext32 {
         __u32                   uc_flags;
         __u32                   uc_link;        /* pointer */   
-        stack_t32               uc_stack;
+        compat_stack_t          uc_stack;
         _sigregs32              uc_mcontext;
         compat_sigset_t         uc_sigmask;     /* mask last for extensibility */
 };
@@ -93,8 +74,6 @@ struct ucontext32 {
 struct stat64_emu31;
 struct mmap_arg_struct_emu31;
 struct fadvise64_64_args;
-struct old_sigaction32;
-struct old_sigaction32;
 
 long sys32_chown16(const char __user * filename, u16 user, u16 group);
 long sys32_lchown16(const char __user * filename, u16 user, u16 group);
@@ -119,12 +98,6 @@ long sys32_ipc(u32 call, int first, int second, int third, u32 ptr);
 long sys32_truncate64(const char __user * path, unsigned long high,
                       unsigned long low);
 long sys32_ftruncate64(unsigned int fd, unsigned long high, unsigned long low);
-long sys32_sched_rr_get_interval(compat_pid_t pid,
-                                 struct compat_timespec __user *interval);
-long sys32_rt_sigprocmask(int how, compat_sigset_t __user *set,
-                          compat_sigset_t __user *oset, size_t sigsetsize);
-long sys32_rt_sigpending(compat_sigset_t __user *set, size_t sigsetsize);
-long sys32_rt_sigqueueinfo(int pid, int sig, compat_siginfo_t __user *uinfo);
 long sys32_init_module(void __user *umod, unsigned long len,
                        const char __user *uargs);
 long sys32_delete_module(const char __user *name_user, unsigned int flags);
@@ -149,9 +122,4 @@ long sys32_read(unsigned int fd, char __user * buf, size_t count);
 long sys32_write(unsigned int fd, const char __user * buf, size_t count);
 long sys32_fadvise64(int fd, loff_t offset, size_t len, int advise);
 long sys32_fadvise64_64(struct fadvise64_64_args __user *args);
-long sys32_sigaction(int sig, const struct old_sigaction32 __user *act,
-                     struct old_sigaction32 __user *oact);
-long sys32_rt_sigaction(int sig, const struct sigaction32 __user *act,
-                        struct sigaction32 __user *oact, size_t sigsetsize);
-long sys32_sigaltstack(const stack_t32 __user *uss, stack_t32 __user *uoss);
 #endif /* _ASM_S390X_S390_H */
diff --git a/arch/s390/kernel/compat_signal.c b/arch/s390/kernel/compat_signal.c
index 593fcc9253fc..3e71194c1902 100644
--- a/arch/s390/kernel/compat_signal.c
+++ b/arch/s390/kernel/compat_signal.c
@@ -157,122 +157,6 @@ int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
         return err;
 }
 
-asmlinkage long
-sys32_sigaction(int sig, const struct old_sigaction32 __user *act,
-                 struct old_sigaction32 __user *oact)
-{
-        struct k_sigaction new_ka, old_ka;
-        unsigned long sa_handler, sa_restorer;
-        int ret;
-
-        if (act) {
-                compat_old_sigset_t mask;
-                if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
-                    __get_user(sa_handler, &act->sa_handler) ||
-                    __get_user(sa_restorer, &act->sa_restorer) ||
-                    __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
-                    __get_user(mask, &act->sa_mask))
-                        return -EFAULT;
-                new_ka.sa.sa_handler = (__sighandler_t) sa_handler;
-                new_ka.sa.sa_restorer = (void (*)(void)) sa_restorer;
-                siginitset(&new_ka.sa.sa_mask, mask);
-        }
-
-        ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
-
-        if (!ret && oact) {
-                sa_handler = (unsigned long) old_ka.sa.sa_handler;
-                sa_restorer = (unsigned long) old_ka.sa.sa_restorer;
-                if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
-                    __put_user(sa_handler, &oact->sa_handler) ||
-                    __put_user(sa_restorer, &oact->sa_restorer) ||
-                    __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
-                    __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
-                        return -EFAULT;
-        }
-
-        return ret;
-}
-
-asmlinkage long
-sys32_rt_sigaction(int sig, const struct sigaction32 __user *act,
-           struct sigaction32 __user *oact,  size_t sigsetsize)
-{
-        struct k_sigaction new_ka, old_ka;
-        unsigned long sa_handler;
-        int ret;
-        compat_sigset_t set32;
-
-        /* XXX: Don't preclude handling different sized sigset_t's.  */
-        if (sigsetsize != sizeof(compat_sigset_t))
-                return -EINVAL;
-
-        if (act) {
-                ret = get_user(sa_handler, &act->sa_handler);
-                ret |= __copy_from_user(&set32, &act->sa_mask,
-                                        sizeof(compat_sigset_t));
-                new_ka.sa.sa_mask.sig[0] =
-                        set32.sig[0] | (((long)set32.sig[1]) << 32);
-                ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
-                
-                if (ret)
-                        return -EFAULT;
-                new_ka.sa.sa_handler = (__sighandler_t) sa_handler;
-        }
-
-        ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
-
-        if (!ret && oact) {
-                set32.sig[1] = (old_ka.sa.sa_mask.sig[0] >> 32);
-                set32.sig[0] = old_ka.sa.sa_mask.sig[0];
-                ret = put_user((unsigned long)old_ka.sa.sa_handler, &oact->sa_handler);
-                ret |= __copy_to_user(&oact->sa_mask, &set32,
-                                      sizeof(compat_sigset_t));
-                ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
-        }
-
-        return ret;
-}
-
-asmlinkage long
-sys32_sigaltstack(const stack_t32 __user *uss, stack_t32 __user *uoss)
-{
-        struct pt_regs *regs = task_pt_regs(current);
-        stack_t kss, koss;
-        unsigned long ss_sp;
-        int ret, err = 0;
-        mm_segment_t old_fs = get_fs();
-
-        if (uss) {
-                if (!access_ok(VERIFY_READ, uss, sizeof(*uss)))
-                        return -EFAULT;
-                err |= __get_user(ss_sp, &uss->ss_sp);
-                err |= __get_user(kss.ss_size, &uss->ss_size);
-                err |= __get_user(kss.ss_flags, &uss->ss_flags);
-                if (err)
-                        return -EFAULT;
-                kss.ss_sp = (void __user *) ss_sp;
-        }
-
-        set_fs (KERNEL_DS);
-        ret = do_sigaltstack((stack_t __force __user *) (uss ? &kss : NULL),
-                             (stack_t __force __user *) (uoss ? &koss : NULL),
-                             regs->gprs[15]);
-        set_fs (old_fs);
-
-        if (!ret && uoss) {
-                if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
-                        return -EFAULT;
-                ss_sp = (unsigned long) koss.ss_sp;
-                err |= __put_user(ss_sp, &uoss->ss_sp);
-                err |= __put_user(koss.ss_size, &uoss->ss_size);
-                err |= __put_user(koss.ss_flags, &uoss->ss_flags);
-                if (err)
-                        return -EFAULT;
-        }
-        return ret;
-}
-
 static int save_sigregs32(struct pt_regs *regs, _sigregs32 __user *sregs)
 {
         _s390_regs_common32 regs32;
@@ -380,10 +264,6 @@ asmlinkage long sys32_rt_sigreturn(void)
         struct pt_regs *regs = task_pt_regs(current);
         rt_sigframe32 __user *frame = (rt_sigframe32 __user *)regs->gprs[15];
         sigset_t set;
-        stack_t st;
-        __u32 ss_sp;
-        int err;
-        mm_segment_t old_fs = get_fs();
 
         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
                 goto badframe;
@@ -394,15 +274,8 @@ asmlinkage long sys32_rt_sigreturn(void)
                 goto badframe;
         if (restore_sigregs_gprs_high(regs, frame->gprs_high))
                 goto badframe;
-        err = __get_user(ss_sp, &frame->uc.uc_stack.ss_sp);
-        st.ss_sp = compat_ptr(ss_sp);
-        err |= __get_user(st.ss_size, &frame->uc.uc_stack.ss_size);
-        err |= __get_user(st.ss_flags, &frame->uc.uc_stack.ss_flags);
-        if (err)
+        if (compat_restore_altstack(&frame->uc.uc_stack))
                 goto badframe; 
-        set_fs (KERNEL_DS);
-        do_sigaltstack((stack_t __force __user *)&st, NULL, regs->gprs[15]);
-        set_fs (old_fs);
         return regs->gprs[2];
 badframe:
         force_sig(SIGSEGV, current);
@@ -530,10 +403,7 @@ static int setup_rt_frame32(int sig, struct k_sigaction *ka, siginfo_t *info,
         /* Create the ucontext.  */
         err |= __put_user(UC_EXTENDED, &frame->uc.uc_flags);
         err |= __put_user(0, &frame->uc.uc_link);
-        err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
-        err |= __put_user(sas_ss_flags(regs->gprs[15]),
-                          &frame->uc.uc_stack.ss_flags);
-        err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
+        err |= __compat_save_altstack(&frame->uc.uc_stack, regs->gprs[15]);
         err |= save_sigregs32(regs, &frame->uc.uc_mcontext);
         err |= save_sigregs_gprs_high(regs, frame->gprs_high);
         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
diff --git a/arch/s390/kernel/compat_wrapper.S b/arch/s390/kernel/compat_wrapper.S
index 9b9a805656b5..c14faf39ae36 100644
--- a/arch/s390/kernel/compat_wrapper.S
+++ b/arch/s390/kernel/compat_wrapper.S
@@ -24,12 +24,6 @@ ENTRY(sys32_write_wrapper)
         llgfr   %r4,%r4                 # size_t
         jg      sys32_write             # branch to system call
 
-ENTRY(sys32_open_wrapper)
-        llgtr   %r2,%r2                 # const char *
-        lgfr    %r3,%r3                 # int
-        lgfr    %r4,%r4                 # int
-        jg      compat_sys_open         # branch to system call
-
 ENTRY(sys32_close_wrapper)
         llgfr   %r2,%r2                 # unsigned int
         jg      sys_close               # branch to system call
@@ -226,12 +220,6 @@ ENTRY(sys32_dup2_wrapper)
 
 #sys32_setsid_wrapper                   # void
 
-ENTRY(sys32_sigaction_wrapper)
-        lgfr    %r2,%r2                 # int
-        llgtr   %r3,%r3                 # const struct old_sigaction *
-        llgtr   %r4,%r4                 # struct old_sigaction32 *
-        jg      sys32_sigaction         # branch to system call
-
 ENTRY(sys32_setreuid16_wrapper)
         llgfr   %r2,%r2                 # __kernel_old_uid_emu31_t
         llgfr   %r3,%r3                 # __kernel_old_uid_emu31_t
@@ -396,17 +384,6 @@ ENTRY(sys32_syslog_wrapper)
         lgfr    %r4,%r4                 # int
         jg      sys_syslog              # branch to system call
 
-ENTRY(compat_sys_setitimer_wrapper)
-        lgfr    %r2,%r2                 # int
-        llgtr   %r3,%r3                 # struct itimerval_emu31 *
-        llgtr   %r4,%r4                 # struct itimerval_emu31 *
-        jg      compat_sys_setitimer    # branch to system call
-
-ENTRY(compat_sys_getitimer_wrapper)
-        lgfr    %r2,%r2                 # int
-        llgtr   %r3,%r3                 # struct itimerval_emu31 *
-        jg      compat_sys_getitimer    # branch to system call
-
 ENTRY(compat_sys_newstat_wrapper)
         llgtr   %r2,%r2                 # char *
         llgtr   %r3,%r3                 # struct stat_emu31 *
@@ -424,13 +401,6 @@ ENTRY(compat_sys_newfstat_wrapper)
 
 #sys32_vhangup_wrapper                  # void
 
-ENTRY(compat_sys_wait4_wrapper)
-        lgfr    %r2,%r2                 # pid_t
-        llgtr   %r3,%r3                 # unsigned int *
-        lgfr    %r4,%r4                 # int
-        llgtr   %r5,%r5                 # struct rusage *
-        jg      compat_sys_wait4        # branch to system call
-
 ENTRY(sys32_swapoff_wrapper)
         llgtr   %r2,%r2                 # const char *
         jg      sys_swapoff             # branch to system call
@@ -474,12 +444,6 @@ ENTRY(sys32_mprotect_wrapper)
         llgfr   %r4,%r4                 # unsigned long
         jg      sys_mprotect            # branch to system call
 
-ENTRY(compat_sys_sigprocmask_wrapper)
-        lgfr    %r2,%r2                 # int
-        llgtr   %r3,%r3                 # compat_old_sigset_t *
-        llgtr   %r4,%r4                 # compat_old_sigset_t *
-        jg      compat_sys_sigprocmask          # branch to system call
-
 ENTRY(sys_init_module_wrapper)
         llgtr   %r2,%r2                 # void *
         llgfr   %r3,%r3                 # unsigned long
@@ -628,11 +592,6 @@ ENTRY(sys32_sched_get_priority_min_wrapper)
         lgfr    %r2,%r2                 # int
         jg      sys_sched_get_priority_min      # branch to system call
 
-ENTRY(sys32_sched_rr_get_interval_wrapper)
-        lgfr    %r2,%r2                 # pid_t
-        llgtr   %r3,%r3                 # struct compat_timespec *
-        jg      sys32_sched_rr_get_interval     # branch to system call
-
 ENTRY(compat_sys_nanosleep_wrapper)
         llgtr   %r2,%r2                 # struct compat_timespec *
         llgtr   %r3,%r3                 # struct compat_timespec *
@@ -686,43 +645,6 @@ ENTRY(sys32_prctl_wrapper)
 
 #sys32_rt_sigreturn_wrapper             # done in rt_sigreturn_glue
 
-ENTRY(sys32_rt_sigaction_wrapper)
-        lgfr    %r2,%r2                 # int
-        llgtr   %r3,%r3                 # const struct sigaction_emu31 *
-        llgtr   %r4,%r4                 # const struct sigaction_emu31 *
-        llgfr   %r5,%r5                 # size_t
-        jg      sys32_rt_sigaction      # branch to system call
-
-ENTRY(sys32_rt_sigprocmask_wrapper)
-        lgfr    %r2,%r2                 # int
-        llgtr   %r3,%r3                 # old_sigset_emu31 *
-        llgtr   %r4,%r4                 # old_sigset_emu31 *
-        llgfr   %r5,%r5                 # size_t
-        jg      sys32_rt_sigprocmask    # branch to system call
-
-ENTRY(sys32_rt_sigpending_wrapper)
-        llgtr   %r2,%r2                 # sigset_emu31 *
-        llgfr   %r3,%r3                 # size_t
-        jg      sys32_rt_sigpending     # branch to system call
-
-ENTRY(compat_sys_rt_sigtimedwait_wrapper)
-        llgtr   %r2,%r2                 # const sigset_emu31_t *
-        llgtr   %r3,%r3                 # siginfo_emu31_t *
-        llgtr   %r4,%r4                 # const struct compat_timespec *
-        llgfr   %r5,%r5                 # size_t
-        jg      compat_sys_rt_sigtimedwait      # branch to system call
-
-ENTRY(sys32_rt_sigqueueinfo_wrapper)
-        lgfr    %r2,%r2                 # int
-        lgfr    %r3,%r3                 # int
-        llgtr   %r4,%r4                 # siginfo_emu31_t *
-        jg      sys32_rt_sigqueueinfo   # branch to system call
-
-ENTRY(compat_sys_rt_sigsuspend_wrapper)
-        llgtr   %r2,%r2                 # compat_sigset_t *
-        llgfr   %r3,%r3                 # compat_size_t
-        jg      compat_sys_rt_sigsuspend
-
 ENTRY(sys32_pread64_wrapper)
         llgfr   %r2,%r2                 # unsigned int
         llgtr   %r3,%r3                 # char *
@@ -760,11 +682,6 @@ ENTRY(sys32_capset_wrapper)
         llgtr   %r3,%r3                 # const cap_user_data_t
         jg      sys_capset              # branch to system call
 
-ENTRY(sys32_sigaltstack_wrapper)
-        llgtr   %r2,%r2                 # const stack_emu31_t *
-        llgtr   %r3,%r3                 # stack_emu31_t *
-        jg      sys32_sigaltstack
-
 ENTRY(sys32_sendfile_wrapper)
         lgfr    %r2,%r2                 # int
         lgfr    %r3,%r3                 # int
@@ -921,16 +838,6 @@ ENTRY(sys32_fstat64_wrapper)
         llgtr   %r3,%r3                 # struct stat64 *
         jg      sys32_fstat64           # branch to system call
 
-ENTRY(compat_sys_futex_wrapper)
-        llgtr   %r2,%r2                 # u32 *
-        lgfr    %r3,%r3                 # int
-        lgfr    %r4,%r4                 # int
-        llgtr   %r5,%r5                 # struct compat_timespec *
-        llgtr   %r6,%r6                 # u32 *
-        lgf     %r0,164(%r15)           # int
-        stg     %r0,160(%r15)
-        jg      compat_sys_futex        # branch to system call
-
 ENTRY(sys32_setxattr_wrapper)
         llgtr   %r2,%r2                 # char *
         llgtr   %r3,%r3                 # char *
@@ -1216,14 +1123,6 @@ ENTRY(sys32_remap_file_pages_wrapper)
         llgfr   %r6,%r6                 # unsigned long
         jg      sys_remap_file_pages
 
-ENTRY(compat_sys_waitid_wrapper)
-        lgfr    %r2,%r2                 # int
-        lgfr    %r3,%r3                 # pid_t
-        llgtr   %r4,%r4                 # siginfo_emu31_t *
-        lgfr    %r5,%r5                 # int
-        llgtr   %r6,%r6                 # struct rusage_emu31 *
-        jg      compat_sys_waitid
-
 ENTRY(compat_sys_kexec_load_wrapper)
         llgfr   %r2,%r2                 # unsigned long
         llgfr   %r3,%r3                 # unsigned long
@@ -1253,13 +1152,6 @@ ENTRY(sys_inotify_rm_watch_wrapper)
         llgfr   %r3,%r3                 # u32
         jg      sys_inotify_rm_watch
 
-ENTRY(compat_sys_openat_wrapper)
-        llgfr   %r2,%r2                 # unsigned int
-        llgtr   %r3,%r3                 # const char *
-        lgfr    %r4,%r4                 # int
-        lgfr    %r5,%r5                 # int
-        jg      compat_sys_openat
-
 ENTRY(sys_mkdirat_wrapper)
         lgfr    %r2,%r2                 # int
         llgtr   %r3,%r3                 # const char *
@@ -1362,17 +1254,6 @@ ENTRY(sys_unshare_wrapper)
         llgfr   %r2,%r2                 # unsigned long
         jg      sys_unshare
 
-ENTRY(compat_sys_set_robust_list_wrapper)
-        llgtr   %r2,%r2                 # struct compat_robust_list_head *
-        llgfr   %r3,%r3                 # size_t
-        jg      compat_sys_set_robust_list
-
-ENTRY(compat_sys_get_robust_list_wrapper)
-        lgfr    %r2,%r2                 # int
-        llgtr   %r3,%r3                 # compat_uptr_t_t *
-        llgtr   %r4,%r4                 # compat_size_t *
-        jg      compat_sys_get_robust_list
-
 ENTRY(sys_splice_wrapper)
         lgfr    %r2,%r2                 # int
         llgtr   %r3,%r3                 # loff_t *
@@ -1458,18 +1339,6 @@ ENTRY(sys_timerfd_create_wrapper)
         lgfr    %r3,%r3                 # int
         jg      sys_timerfd_create
 
-ENTRY(compat_sys_timerfd_settime_wrapper)
-        lgfr    %r2,%r2                 # int
-        lgfr    %r3,%r3                 # int
-        llgtr   %r4,%r4                 # struct compat_itimerspec *
-        llgtr   %r5,%r5                 # struct compat_itimerspec *
-        jg      compat_sys_timerfd_settime
-
-ENTRY(compat_sys_timerfd_gettime_wrapper)
-        lgfr    %r2,%r2                 # int
-        llgtr   %r3,%r3                 # struct compat_itimerspec *
-        jg      compat_sys_timerfd_gettime
-
 ENTRY(compat_sys_signalfd4_wrapper)
         lgfr    %r2,%r2                 # int
         llgtr   %r3,%r3                 # compat_sigset_t *
@@ -1550,13 +1419,6 @@ ENTRY(compat_sys_pwritev_wrapper)
         llgfr   %r6,%r6                 # u32
         jg      compat_sys_pwritev      # branch to system call
 
-ENTRY(compat_sys_rt_tgsigqueueinfo_wrapper)
-        lgfr    %r2,%r2                 # compat_pid_t
-        lgfr    %r3,%r3                 # compat_pid_t
-        lgfr    %r4,%r4                 # int
-        llgtr   %r5,%r5                 # struct compat_siginfo *
-        jg      compat_sys_rt_tgsigqueueinfo_wrapper # branch to system call
-
 ENTRY(sys_perf_event_open_wrapper)
         llgtr   %r2,%r2                 # const struct perf_event_attr *
         lgfr    %r3,%r3                 # pid_t
@@ -1607,12 +1469,6 @@ ENTRY(sys_name_to_handle_at_wrapper)
         lgfr    %r6,%r6                 # int
         jg      sys_name_to_handle_at
 
-ENTRY(compat_sys_open_by_handle_at_wrapper)
-        lgfr    %r2,%r2                 # int
-        llgtr   %r3,%r3                 # struct file_handle __user *
-        lgfr    %r4,%r4                 # int
-        jg      compat_sys_open_by_handle_at
-
 ENTRY(compat_sys_clock_adjtime_wrapper)
         lgfr    %r2,%r2                 # clockid_t (int)
         llgtr   %r3,%r3                 # struct compat_timex __user *
diff --git a/arch/s390/kernel/entry.h b/arch/s390/kernel/entry.h
index 2711936fe706..c3a736a3ed44 100644
--- a/arch/s390/kernel/entry.h
+++ b/arch/s390/kernel/entry.h
@@ -73,10 +73,6 @@ long sys_s390_fadvise64(int fd, u32 offset_high, u32 offset_low,
 long sys_s390_fadvise64_64(struct fadvise64_64_args __user *args);
 long sys_s390_fallocate(int fd, int mode, loff_t offset, u32 len_high,
                         u32 len_low);
-long sys_sigsuspend(int history0, int history1, old_sigset_t mask);
-long sys_sigaction(int sig, const struct old_sigaction __user *act,
-                   struct old_sigaction __user *oact);
-long sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss);
 long sys_sigreturn(void);
 long sys_rt_sigreturn(void);
 long sys32_sigreturn(void);
diff --git a/arch/s390/kernel/signal.c b/arch/s390/kernel/signal.c
index c3ff70a7b247..9c6e747a5e1e 100644
--- a/arch/s390/kernel/signal.c
+++ b/arch/s390/kernel/signal.c
@@ -48,54 +48,6 @@ typedef struct
         struct ucontext uc;
 } rt_sigframe;
 
-/*
- * Atomically swap in the new signal mask, and wait for a signal.
- */
-SYSCALL_DEFINE3(sigsuspend, int, history0, int, history1, old_sigset_t, mask)
-{
-        sigset_t blocked;
-        siginitset(&blocked, mask);
-        return sigsuspend(&blocked);
-}
-
-SYSCALL_DEFINE3(sigaction, int, sig, const struct old_sigaction __user *, act,
-                struct old_sigaction __user *, oact)
-{
-        struct k_sigaction new_ka, old_ka;
-        int ret;
-
-        if (act) {
-                old_sigset_t mask;
-                if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
-                    __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
-                    __get_user(new_ka.sa.sa_restorer, &act->sa_restorer) ||
-                    __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
-                    __get_user(mask, &act->sa_mask))
-                        return -EFAULT;
-                siginitset(&new_ka.sa.sa_mask, mask);
-        }
-
-        ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
-
-        if (!ret && oact) {
-                if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
-                    __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
-                    __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer) ||
-                    __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
-                    __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
-                        return -EFAULT;
-        }
-
-        return ret;
-}
-
-SYSCALL_DEFINE2(sigaltstack, const stack_t __user *, uss,
-                stack_t __user *, uoss)
-{
-        struct pt_regs *regs = task_pt_regs(current);
-        return do_sigaltstack(uss, uoss, regs->gprs[15]);
-}
-
 /* Returns non-zero on fault. */
 static int save_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
 {
@@ -190,8 +142,7 @@ SYSCALL_DEFINE0(rt_sigreturn)
         set_current_blocked(&set);
         if (restore_sigregs(regs, &frame->uc.uc_mcontext))
                 goto badframe;
-        if (do_sigaltstack(&frame->uc.uc_stack, NULL,
-                           regs->gprs[15]) == -EFAULT)
+        if (restore_altstack(&frame->uc.uc_stack))
                 goto badframe;
         return regs->gprs[2];
 badframe:
@@ -325,10 +276,7 @@ static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
         /* Create the ucontext.  */
         err |= __put_user(0, &frame->uc.uc_flags);
         err |= __put_user(NULL, &frame->uc.uc_link);
-        err |= __put_user((void __user *)current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
-        err |= __put_user(sas_ss_flags(regs->gprs[15]),
-                          &frame->uc.uc_stack.ss_flags);
-        err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
+        err |= __save_altstack(&frame->uc.uc_stack, regs->gprs[15]);
         err |= save_sigregs(regs, &frame->uc.uc_mcontext);
         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
         if (err)
diff --git a/arch/s390/kernel/syscalls.S b/arch/s390/kernel/syscalls.S
index 6a6c61f94dd3..aaac708aa110 100644
--- a/arch/s390/kernel/syscalls.S
+++ b/arch/s390/kernel/syscalls.S
@@ -13,7 +13,7 @@ SYSCALL(sys_exit,sys_exit,sys32_exit_wrapper)
 SYSCALL(sys_fork,sys_fork,sys_fork)
 SYSCALL(sys_read,sys_read,sys32_read_wrapper)
 SYSCALL(sys_write,sys_write,sys32_write_wrapper)
-SYSCALL(sys_open,sys_open,sys32_open_wrapper)                   /* 5 */
+SYSCALL(sys_open,sys_open,compat_sys_open)                      /* 5 */
 SYSCALL(sys_close,sys_close,sys32_close_wrapper)
 SYSCALL(sys_restart_syscall,sys_restart_syscall,sys_restart_syscall)
 SYSCALL(sys_creat,sys_creat,sys32_creat_wrapper)
@@ -75,7 +75,7 @@ SYSCALL(sys_dup2,sys_dup2,sys32_dup2_wrapper)
 SYSCALL(sys_getppid,sys_getppid,sys_getppid)
 SYSCALL(sys_getpgrp,sys_getpgrp,sys_getpgrp)                    /* 65 */
 SYSCALL(sys_setsid,sys_setsid,sys_setsid)
-SYSCALL(sys_sigaction,sys_sigaction,sys32_sigaction_wrapper)
+SYSCALL(sys_sigaction,sys_sigaction,compat_sys_sigaction)
 NI_SYSCALL                                                      /* old sgetmask syscall*/
 NI_SYSCALL                                                      /* old ssetmask syscall*/
 SYSCALL(sys_setreuid16,sys_ni_syscall,sys32_setreuid16_wrapper) /* old setreuid16 syscall */
@@ -112,8 +112,8 @@ SYSCALL(sys_fstatfs,sys_fstatfs,compat_sys_fstatfs_wrapper)	/* 100 */
 NI_SYSCALL                                                      /* ioperm for i386 */
 SYSCALL(sys_socketcall,sys_socketcall,compat_sys_socketcall_wrapper)
 SYSCALL(sys_syslog,sys_syslog,sys32_syslog_wrapper)
-SYSCALL(sys_setitimer,sys_setitimer,compat_sys_setitimer_wrapper)
-SYSCALL(sys_getitimer,sys_getitimer,compat_sys_getitimer_wrapper)       /* 105 */
+SYSCALL(sys_setitimer,sys_setitimer,compat_sys_setitimer)
+SYSCALL(sys_getitimer,sys_getitimer,compat_sys_getitimer)       /* 105 */
 SYSCALL(sys_newstat,sys_newstat,compat_sys_newstat_wrapper)
 SYSCALL(sys_newlstat,sys_newlstat,compat_sys_newlstat_wrapper)
 SYSCALL(sys_newfstat,sys_newfstat,compat_sys_newfstat_wrapper)
@@ -122,7 +122,7 @@ SYSCALL(sys_lookup_dcookie,sys_lookup_dcookie,sys32_lookup_dcookie_wrapper)	/* 1
 SYSCALL(sys_vhangup,sys_vhangup,sys_vhangup)
 NI_SYSCALL                                                      /* old "idle" system call */
 NI_SYSCALL                                                      /* vm86old for i386 */
-SYSCALL(sys_wait4,sys_wait4,compat_sys_wait4_wrapper)
+SYSCALL(sys_wait4,sys_wait4,compat_sys_wait4)
 SYSCALL(sys_swapoff,sys_swapoff,sys32_swapoff_wrapper)          /* 115 */
 SYSCALL(sys_sysinfo,sys_sysinfo,compat_sys_sysinfo_wrapper)
 SYSCALL(sys_s390_ipc,sys_s390_ipc,sys32_ipc_wrapper)
@@ -134,7 +134,7 @@ SYSCALL(sys_newuname,sys_newuname,sys32_newuname_wrapper)
 NI_SYSCALL                                                      /* modify_ldt for i386 */
 SYSCALL(sys_adjtimex,sys_adjtimex,compat_sys_adjtimex_wrapper)
 SYSCALL(sys_mprotect,sys_mprotect,sys32_mprotect_wrapper)       /* 125 */
-SYSCALL(sys_sigprocmask,sys_sigprocmask,compat_sys_sigprocmask_wrapper)
+SYSCALL(sys_sigprocmask,sys_sigprocmask,compat_sys_sigprocmask)
 NI_SYSCALL                                                      /* old "create module" */
 SYSCALL(sys_init_module,sys_init_module,sys_init_module_wrapper)
 SYSCALL(sys_delete_module,sys_delete_module,sys_delete_module_wrapper)
@@ -169,7 +169,7 @@ SYSCALL(sys_sched_getscheduler,sys_sched_getscheduler,sys32_sched_getscheduler_w
 SYSCALL(sys_sched_yield,sys_sched_yield,sys_sched_yield)
 SYSCALL(sys_sched_get_priority_max,sys_sched_get_priority_max,sys32_sched_get_priority_max_wrapper)
 SYSCALL(sys_sched_get_priority_min,sys_sched_get_priority_min,sys32_sched_get_priority_min_wrapper)     /* 160 */
-SYSCALL(sys_sched_rr_get_interval,sys_sched_rr_get_interval,sys32_sched_rr_get_interval_wrapper)
+SYSCALL(sys_sched_rr_get_interval,sys_sched_rr_get_interval,compat_sys_sched_rr_get_interval)
 SYSCALL(sys_nanosleep,sys_nanosleep,compat_sys_nanosleep_wrapper)
 SYSCALL(sys_mremap,sys_mremap,sys32_mremap_wrapper)
 SYSCALL(sys_setresuid16,sys_ni_syscall,sys32_setresuid16_wrapper)       /* old setresuid16 syscall */
@@ -182,19 +182,19 @@ SYSCALL(sys_setresgid16,sys_ni_syscall,sys32_setresgid16_wrapper)	/* 170 old set
 SYSCALL(sys_getresgid16,sys_ni_syscall,sys32_getresgid16_wrapper)       /* old getresgid16 syscall */
 SYSCALL(sys_prctl,sys_prctl,sys32_prctl_wrapper)
 SYSCALL(sys_rt_sigreturn,sys_rt_sigreturn,sys32_rt_sigreturn)
-SYSCALL(sys_rt_sigaction,sys_rt_sigaction,sys32_rt_sigaction_wrapper)
-SYSCALL(sys_rt_sigprocmask,sys_rt_sigprocmask,sys32_rt_sigprocmask_wrapper)     /* 175 */
-SYSCALL(sys_rt_sigpending,sys_rt_sigpending,sys32_rt_sigpending_wrapper)
-SYSCALL(sys_rt_sigtimedwait,sys_rt_sigtimedwait,compat_sys_rt_sigtimedwait_wrapper)
-SYSCALL(sys_rt_sigqueueinfo,sys_rt_sigqueueinfo,sys32_rt_sigqueueinfo_wrapper)
-SYSCALL(sys_rt_sigsuspend,sys_rt_sigsuspend,compat_sys_rt_sigsuspend_wrapper)
+SYSCALL(sys_rt_sigaction,sys_rt_sigaction,compat_sys_rt_sigaction)
+SYSCALL(sys_rt_sigprocmask,sys_rt_sigprocmask,compat_sys_rt_sigprocmask) /* 175 */
+SYSCALL(sys_rt_sigpending,sys_rt_sigpending,compat_sys_rt_sigpending)
+SYSCALL(sys_rt_sigtimedwait,sys_rt_sigtimedwait,compat_sys_rt_sigtimedwait)
+SYSCALL(sys_rt_sigqueueinfo,sys_rt_sigqueueinfo,compat_sys_rt_sigqueueinfo)
+SYSCALL(sys_rt_sigsuspend,sys_rt_sigsuspend,compat_sys_rt_sigsuspend)
 SYSCALL(sys_pread64,sys_pread64,sys32_pread64_wrapper)          /* 180 */
 SYSCALL(sys_pwrite64,sys_pwrite64,sys32_pwrite64_wrapper)
 SYSCALL(sys_chown16,sys_ni_syscall,sys32_chown16_wrapper)       /* old chown16 syscall */
 SYSCALL(sys_getcwd,sys_getcwd,sys32_getcwd_wrapper)
 SYSCALL(sys_capget,sys_capget,sys32_capget_wrapper)
 SYSCALL(sys_capset,sys_capset,sys32_capset_wrapper)             /* 185 */
-SYSCALL(sys_sigaltstack,sys_sigaltstack,sys32_sigaltstack_wrapper)
+SYSCALL(sys_sigaltstack,sys_sigaltstack,compat_sys_sigaltstack)
 SYSCALL(sys_sendfile,sys_sendfile64,sys32_sendfile_wrapper)
 NI_SYSCALL                                                      /* streams1 */
 NI_SYSCALL                                                      /* streams2 */
@@ -246,7 +246,7 @@ SYSCALL(sys_lremovexattr,sys_lremovexattr,sys32_lremovexattr_wrapper)
 SYSCALL(sys_fremovexattr,sys_fremovexattr,sys32_fremovexattr_wrapper)   /* 235 */
 SYSCALL(sys_gettid,sys_gettid,sys_gettid)
 SYSCALL(sys_tkill,sys_tkill,sys_tkill_wrapper)
-SYSCALL(sys_futex,sys_futex,compat_sys_futex_wrapper)
+SYSCALL(sys_futex,sys_futex,compat_sys_futex)
 SYSCALL(sys_sched_setaffinity,sys_sched_setaffinity,sys32_sched_setaffinity_wrapper)
 SYSCALL(sys_sched_getaffinity,sys_sched_getaffinity,sys32_sched_getaffinity_wrapper)    /* 240 */
 SYSCALL(sys_tgkill,sys_tgkill,sys_tgkill_wrapper)
@@ -289,14 +289,14 @@ SYSCALL(sys_kexec_load,sys_kexec_load,compat_sys_kexec_load_wrapper)
 SYSCALL(sys_add_key,sys_add_key,compat_sys_add_key_wrapper)
 SYSCALL(sys_request_key,sys_request_key,compat_sys_request_key_wrapper)
 SYSCALL(sys_keyctl,sys_keyctl,compat_sys_keyctl_wrapper)                /* 280 */
-SYSCALL(sys_waitid,sys_waitid,compat_sys_waitid_wrapper)
+SYSCALL(sys_waitid,sys_waitid,compat_sys_waitid)
 SYSCALL(sys_ioprio_set,sys_ioprio_set,sys_ioprio_set_wrapper)
 SYSCALL(sys_ioprio_get,sys_ioprio_get,sys_ioprio_get_wrapper)
 SYSCALL(sys_inotify_init,sys_inotify_init,sys_inotify_init)
 SYSCALL(sys_inotify_add_watch,sys_inotify_add_watch,sys_inotify_add_watch_wrapper)      /* 285 */
 SYSCALL(sys_inotify_rm_watch,sys_inotify_rm_watch,sys_inotify_rm_watch_wrapper)
 NI_SYSCALL                                                      /* 287 sys_migrate_pages */
-SYSCALL(sys_openat,sys_openat,compat_sys_openat_wrapper)
+SYSCALL(sys_openat,sys_openat,compat_sys_openat)
 SYSCALL(sys_mkdirat,sys_mkdirat,sys_mkdirat_wrapper)
 SYSCALL(sys_mknodat,sys_mknodat,sys_mknodat_wrapper)    /* 290 */
 SYSCALL(sys_fchownat,sys_fchownat,sys_fchownat_wrapper)
@@ -312,8 +312,8 @@ SYSCALL(sys_faccessat,sys_faccessat,sys_faccessat_wrapper)	/* 300 */
 SYSCALL(sys_pselect6,sys_pselect6,compat_sys_pselect6_wrapper)
 SYSCALL(sys_ppoll,sys_ppoll,compat_sys_ppoll_wrapper)
 SYSCALL(sys_unshare,sys_unshare,sys_unshare_wrapper)
-SYSCALL(sys_set_robust_list,sys_set_robust_list,compat_sys_set_robust_list_wrapper)
-SYSCALL(sys_get_robust_list,sys_get_robust_list,compat_sys_get_robust_list_wrapper)
+SYSCALL(sys_set_robust_list,sys_set_robust_list,compat_sys_set_robust_list)
+SYSCALL(sys_get_robust_list,sys_get_robust_list,compat_sys_get_robust_list)
 SYSCALL(sys_splice,sys_splice,sys_splice_wrapper)
 SYSCALL(sys_sync_file_range,sys_sync_file_range,sys_sync_file_range_wrapper)
 SYSCALL(sys_tee,sys_tee,sys_tee_wrapper)
@@ -328,8 +328,8 @@ SYSCALL(sys_signalfd,sys_signalfd,compat_sys_signalfd_wrapper)
 NI_SYSCALL                                              /* 317 old sys_timer_fd */
 SYSCALL(sys_eventfd,sys_eventfd,sys_eventfd_wrapper)
 SYSCALL(sys_timerfd_create,sys_timerfd_create,sys_timerfd_create_wrapper)
-SYSCALL(sys_timerfd_settime,sys_timerfd_settime,compat_sys_timerfd_settime_wrapper) /* 320 */
-SYSCALL(sys_timerfd_gettime,sys_timerfd_gettime,compat_sys_timerfd_gettime_wrapper)
+SYSCALL(sys_timerfd_settime,sys_timerfd_settime,compat_sys_timerfd_settime) /* 320 */
+SYSCALL(sys_timerfd_gettime,sys_timerfd_gettime,compat_sys_timerfd_gettime)
 SYSCALL(sys_signalfd4,sys_signalfd4,compat_sys_signalfd4_wrapper)
 SYSCALL(sys_eventfd2,sys_eventfd2,sys_eventfd2_wrapper)
 SYSCALL(sys_inotify_init1,sys_inotify_init1,sys_inotify_init1_wrapper)
@@ -338,13 +338,13 @@ SYSCALL(sys_dup3,sys_dup3,sys_dup3_wrapper)
 SYSCALL(sys_epoll_create1,sys_epoll_create1,sys_epoll_create1_wrapper)
 SYSCALL(sys_preadv,sys_preadv,compat_sys_preadv_wrapper)
 SYSCALL(sys_pwritev,sys_pwritev,compat_sys_pwritev_wrapper)
-SYSCALL(sys_rt_tgsigqueueinfo,sys_rt_tgsigqueueinfo,compat_sys_rt_tgsigqueueinfo_wrapper) /* 330 */
+SYSCALL(sys_rt_tgsigqueueinfo,sys_rt_tgsigqueueinfo,compat_sys_rt_tgsigqueueinfo) /* 330 */
 SYSCALL(sys_perf_event_open,sys_perf_event_open,sys_perf_event_open_wrapper)
 SYSCALL(sys_fanotify_init,sys_fanotify_init,sys_fanotify_init_wrapper)
 SYSCALL(sys_fanotify_mark,sys_fanotify_mark,sys_fanotify_mark_wrapper)
 SYSCALL(sys_prlimit64,sys_prlimit64,sys_prlimit64_wrapper)
 SYSCALL(sys_name_to_handle_at,sys_name_to_handle_at,sys_name_to_handle_at_wrapper) /* 335 */
-SYSCALL(sys_open_by_handle_at,sys_open_by_handle_at,compat_sys_open_by_handle_at_wrapper)
+SYSCALL(sys_open_by_handle_at,sys_open_by_handle_at,compat_sys_open_by_handle_at)
 SYSCALL(sys_clock_adjtime,sys_clock_adjtime,compat_sys_clock_adjtime_wrapper)
 SYSCALL(sys_syncfs,sys_syncfs,sys_syncfs_wrapper)
 SYSCALL(sys_setns,sys_setns,sys_setns_wrapper)