if (encoded_op & (FUTEX_OP_OPARG_SHIFT << 28))
                oparg = 1 << oparg;
 
-       if (! access_ok (VERIFY_WRITE, uaddr, sizeof(u32)))
-               return -EFAULT;
-
        pagefault_disable();
        ret = uaccess.futex_atomic_op(op, uaddr, oparg, &oldval);
        pagefault_enable();
 static inline int futex_atomic_cmpxchg_inatomic(u32 *uval, u32 __user *uaddr,
                                                u32 oldval, u32 newval)
 {
-       if (! access_ok (VERIFY_WRITE, uaddr, sizeof(u32)))
-               return -EFAULT;
-
        return uaccess.futex_atomic_cmpxchg(uval, uaddr, oldval, newval);
 }
 
 
 copy_to_user(void __user *to, const void *from, unsigned long n)
 {
        might_fault();
-       if (access_ok(VERIFY_WRITE, to, n))
-               n = __copy_to_user(to, from, n);
-       return n;
+       return __copy_to_user(to, from, n);
 }
 
 /**
                copy_from_user_overflow();
                return n;
        }
-       if (access_ok(VERIFY_READ, from, n))
-               n = __copy_from_user(to, from, n);
-       else
-               memset(to, 0, n);
-       return n;
+       return __copy_from_user(to, from, n);
 }
 
 static inline unsigned long __must_check
 copy_in_user(void __user *to, const void __user *from, unsigned long n)
 {
        might_fault();
-       if (__access_ok(from,n) && __access_ok(to,n))
-               n = __copy_in_user(to, from, n);
-       return n;
+       return __copy_in_user(to, from, n);
 }
 
 /*
 static inline long __must_check
 strncpy_from_user(char *dst, const char __user *src, long count)
 {
-        long res = -EFAULT;
        might_fault();
-        if (access_ok(VERIFY_READ, src, 1))
-               res = uaccess.strncpy_from_user(count, src, dst);
-        return res;
+       return uaccess.strncpy_from_user(count, src, dst);
 }
 
 static inline unsigned long
 clear_user(void __user *to, unsigned long n)
 {
        might_fault();
-       if (access_ok(VERIFY_WRITE, to, n))
-               n = uaccess.clear_user(n, to);
-       return n;
+       return uaccess.clear_user(n, to);
 }
 
 extern int copy_to_user_real(void __user *dest, void *src, size_t count);
 
 {
        int err;
 
-       if (!access_ok (VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
-               return -EFAULT;
-
        /* If you change siginfo_t structure, please be sure
           this code is fixed accordingly.
           It should never copy any pad contained in the structure
        int err;
        u32 tmp;
 
-       if (!access_ok (VERIFY_READ, from, sizeof(compat_siginfo_t)))
-               return -EFAULT;
-
        err = __get_user(to->si_signo, &from->si_signo);
        err |= __get_user(to->si_errno, &from->si_errno);
        err |= __get_user(to->si_code, &from->si_code);
        sigframe32 __user *frame = (sigframe32 __user *)regs->gprs[15];
        sigset_t set;
 
-       if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
-               goto badframe;
        if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE32))
                goto badframe;
        set_current_blocked(&set);
        rt_sigframe32 __user *frame = (rt_sigframe32 __user *)regs->gprs[15];
        sigset_t set;
 
-       if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
-               goto badframe;
        if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
                goto badframe;
        set_current_blocked(&set);
                        sigset_t *set, struct pt_regs * regs)
 {
        sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(sigframe32));
-       if (!access_ok(VERIFY_WRITE, frame, sizeof(sigframe32)))
-               goto give_sigsegv;
 
        if (frame == (void __user *) -1UL)
                goto give_sigsegv;
 {
        int err = 0;
        rt_sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(rt_sigframe32));
-       if (!access_ok(VERIFY_WRITE, frame, sizeof(rt_sigframe32)))
-               goto give_sigsegv;
 
        if (frame == (void __user *) -1UL)
                goto give_sigsegv;
 
        sigframe __user *frame = (sigframe __user *)regs->gprs[15];
        sigset_t set;
 
-       if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
-               goto badframe;
        if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE))
                goto badframe;
        set_current_blocked(&set);
        rt_sigframe __user *frame = (rt_sigframe __user *)regs->gprs[15];
        sigset_t set;
 
-       if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
-               goto badframe;
        if (__copy_from_user(&set.sig, &frame->uc.uc_sigmask, sizeof(set)))
                goto badframe;
        set_current_blocked(&set);
        sigframe __user *frame;
 
        frame = get_sigframe(ka, regs, sizeof(sigframe));
-       if (!access_ok(VERIFY_WRITE, frame, sizeof(sigframe)))
-               goto give_sigsegv;
 
        if (frame == (void __user *) -1UL)
                goto give_sigsegv;
        rt_sigframe __user *frame;
 
        frame = get_sigframe(ka, regs, sizeof(rt_sigframe));
-       if (!access_ok(VERIFY_WRITE, frame, sizeof(rt_sigframe)))
-               goto give_sigsegv;
 
        if (frame == (void __user *) -1UL)
                goto give_sigsegv;