20 files changed, 62 insertions, 65 deletions

diff --git a/arch/x86/entry/vsyscall/vsyscall_64.c b/arch/x86/entry/vsyscall/vsyscall_64.c
index d78bcc03e60e..d9d81ad7a400 100644
--- a/arch/x86/entry/vsyscall/vsyscall_64.c
+++ b/arch/x86/entry/vsyscall/vsyscall_64.c
@@ -99,7 +99,7 @@ static bool write_ok_or_segv(unsigned long ptr, size_t size)
          * sig_on_uaccess_err, this could go away.
          */
 
-        if (!access_ok(VERIFY_WRITE, (void __user *)ptr, size)) {
+        if (!access_ok((void __user *)ptr, size)) {
                 struct thread_struct *thread = &current->thread;
 
                 thread->error_code      = X86_PF_USER | X86_PF_WRITE;
diff --git a/arch/x86/ia32/ia32_aout.c b/arch/x86/ia32/ia32_aout.c
index 8e02b30cf08e..f65b78d32f5e 100644
--- a/arch/x86/ia32/ia32_aout.c
+++ b/arch/x86/ia32/ia32_aout.c
@@ -176,10 +176,10 @@ static int aout_core_dump(struct coredump_params *cprm)
 
         /* make sure we actually have a data and stack area to dump */
         set_fs(USER_DS);
-        if (!access_ok(VERIFY_READ, (void *) (unsigned long)START_DATA(dump),
+        if (!access_ok((void *) (unsigned long)START_DATA(dump),
                        dump.u_dsize << PAGE_SHIFT))
                 dump.u_dsize = 0;
-        if (!access_ok(VERIFY_READ, (void *) (unsigned long)START_STACK(dump),
+        if (!access_ok((void *) (unsigned long)START_STACK(dump),
                        dump.u_ssize << PAGE_SHIFT))
                 dump.u_ssize = 0;
 
diff --git a/arch/x86/ia32/ia32_signal.c b/arch/x86/ia32/ia32_signal.c
index 86b1341cba9a..321fe5f5d0e9 100644
--- a/arch/x86/ia32/ia32_signal.c
+++ b/arch/x86/ia32/ia32_signal.c
@@ -119,7 +119,7 @@ asmlinkage long sys32_sigreturn(void)
         struct sigframe_ia32 __user *frame = (struct sigframe_ia32 __user *)(regs->sp-8);
         sigset_t set;
 
-        if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
+        if (!access_ok(frame, sizeof(*frame)))
                 goto badframe;
         if (__get_user(set.sig[0], &frame->sc.oldmask)
             || (_COMPAT_NSIG_WORDS > 1
@@ -147,7 +147,7 @@ asmlinkage long sys32_rt_sigreturn(void)
 
         frame = (struct rt_sigframe_ia32 __user *)(regs->sp - 4);
 
-        if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
+        if (!access_ok(frame, sizeof(*frame)))
                 goto badframe;
         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
                 goto badframe;
@@ -269,7 +269,7 @@ int ia32_setup_frame(int sig, struct ksignal *ksig,
 
         frame = get_sigframe(ksig, regs, sizeof(*frame), &fpstate);
 
-        if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+        if (!access_ok(frame, sizeof(*frame)))
                 return -EFAULT;
 
         if (__put_user(sig, &frame->sig))
@@ -349,7 +349,7 @@ int ia32_setup_rt_frame(int sig, struct ksignal *ksig,
 
         frame = get_sigframe(ksig, regs, sizeof(*frame), &fpstate);
 
-        if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+        if (!access_ok(frame, sizeof(*frame)))
                 return -EFAULT;
 
         put_user_try {
diff --git a/arch/x86/ia32/sys_ia32.c b/arch/x86/ia32/sys_ia32.c
index 11ef7b7c9cc8..a43212036257 100644
--- a/arch/x86/ia32/sys_ia32.c
+++ b/arch/x86/ia32/sys_ia32.c
@@ -75,7 +75,7 @@ static int cp_stat64(struct stat64 __user *ubuf, struct kstat *stat)
         typeof(ubuf->st_gid) gid = 0;
         SET_UID(uid, from_kuid_munged(current_user_ns(), stat->uid));
         SET_GID(gid, from_kgid_munged(current_user_ns(), stat->gid));
-        if (!access_ok(VERIFY_WRITE, ubuf, sizeof(struct stat64)) ||
+        if (!access_ok(ubuf, sizeof(struct stat64)) ||
             __put_user(huge_encode_dev(stat->dev), &ubuf->st_dev) ||
             __put_user(stat->ino, &ubuf->__st_ino) ||
             __put_user(stat->ino, &ubuf->st_ino) ||
diff --git a/arch/x86/include/asm/checksum_32.h b/arch/x86/include/asm/checksum_32.h
index 7a659c74cd03..f57b94e02c57 100644
--- a/arch/x86/include/asm/checksum_32.h
+++ b/arch/x86/include/asm/checksum_32.h
@@ -182,7 +182,7 @@ static inline __wsum csum_and_copy_to_user(const void *src,
         __wsum ret;
 
         might_sleep();
-        if (access_ok(VERIFY_WRITE, dst, len)) {
+        if (access_ok(dst, len)) {
                 stac();
                 ret = csum_partial_copy_generic(src, (__force void *)dst,
                                                 len, sum, NULL, err_ptr);
diff --git a/arch/x86/include/asm/pgtable_32.h b/arch/x86/include/asm/pgtable_32.h
index b3ec519e3982..4fe9e7fc74d3 100644
--- a/arch/x86/include/asm/pgtable_32.h
+++ b/arch/x86/include/asm/pgtable_32.h
@@ -37,7 +37,7 @@ void sync_initial_page_table(void);
 /*
  * Define this if things work differently on an i386 and an i486:
  * it will (on an i486) warn about kernel memory accesses that are
- * done without a 'access_ok(VERIFY_WRITE,..)'
+ * done without a 'access_ok( ..)'
  */
 #undef TEST_ACCESS_OK
 
diff --git a/arch/x86/include/asm/uaccess.h b/arch/x86/include/asm/uaccess.h
index b5e58cc0c5e7..3920f456db79 100644
--- a/arch/x86/include/asm/uaccess.h
+++ b/arch/x86/include/asm/uaccess.h
@@ -77,9 +77,6 @@ static inline bool __chk_range_not_ok(unsigned long addr, unsigned long size, un
 
 /**
  * access_ok: - Checks if a user space pointer is valid
- * @type: Type of access: %VERIFY_READ or %VERIFY_WRITE.  Note that
- *        %VERIFY_WRITE is a superset of %VERIFY_READ - if it is safe
- *        to write to a block, it is always safe to read from it.
  * @addr: User space pointer to start of block to check
  * @size: Size of block to check
  *
@@ -95,7 +92,7 @@ static inline bool __chk_range_not_ok(unsigned long addr, unsigned long size, un
  * checks that the pointer is in the user space range - after calling
  * this function, memory access functions may still return -EFAULT.
  */
-#define access_ok(type, addr, size)                                     \
+#define access_ok(addr, size)                                   \
 ({                                                                      \
         WARN_ON_IN_IRQ();                                               \
         likely(!__range_not_ok(addr, size, user_addr_max()));           \
@@ -670,7 +667,7 @@ extern void __cmpxchg_wrong_size(void)
 
 #define user_atomic_cmpxchg_inatomic(uval, ptr, old, new)               \
 ({                                                                      \
-        access_ok(VERIFY_WRITE, (ptr), sizeof(*(ptr))) ?                \
+        access_ok((ptr), sizeof(*(ptr))) ?              \
                 __user_atomic_cmpxchg_inatomic((uval), (ptr),           \
                                 (old), (new), sizeof(*(ptr))) :         \
                 -EFAULT;                                                \
diff --git a/arch/x86/kernel/fpu/signal.c b/arch/x86/kernel/fpu/signal.c
index d99a8ee9e185..f6a1d299627c 100644
--- a/arch/x86/kernel/fpu/signal.c
+++ b/arch/x86/kernel/fpu/signal.c
@@ -164,7 +164,7 @@ int copy_fpstate_to_sigframe(void __user *buf, void __user *buf_fx, int size)
         ia32_fxstate &= (IS_ENABLED(CONFIG_X86_32) ||
                          IS_ENABLED(CONFIG_IA32_EMULATION));
 
-        if (!access_ok(VERIFY_WRITE, buf, size))
+        if (!access_ok(buf, size))
                 return -EACCES;
 
         if (!static_cpu_has(X86_FEATURE_FPU))
@@ -281,7 +281,7 @@ static int __fpu__restore_sig(void __user *buf, void __user *buf_fx, int size)
                 return 0;
         }
 
-        if (!access_ok(VERIFY_READ, buf, size))
+        if (!access_ok(buf, size))
                 return -EACCES;
 
         fpu__initialize(fpu);
diff --git a/arch/x86/kernel/signal.c b/arch/x86/kernel/signal.c
index 92a3b312a53c..08dfd4c1a4f9 100644
--- a/arch/x86/kernel/signal.c
+++ b/arch/x86/kernel/signal.c
@@ -322,7 +322,7 @@ __setup_frame(int sig, struct ksignal *ksig, sigset_t *set,
 
         frame = get_sigframe(&ksig->ka, regs, sizeof(*frame), &fpstate);
 
-        if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+        if (!access_ok(frame, sizeof(*frame)))
                 return -EFAULT;
 
         if (__put_user(sig, &frame->sig))
@@ -385,7 +385,7 @@ static int __setup_rt_frame(int sig, struct ksignal *ksig,
 
         frame = get_sigframe(&ksig->ka, regs, sizeof(*frame), &fpstate);
 
-        if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+        if (!access_ok(frame, sizeof(*frame)))
                 return -EFAULT;
 
         put_user_try {
@@ -465,7 +465,7 @@ static int __setup_rt_frame(int sig, struct ksignal *ksig,
 
         frame = get_sigframe(&ksig->ka, regs, sizeof(struct rt_sigframe), &fp);
 
-        if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+        if (!access_ok(frame, sizeof(*frame)))
                 return -EFAULT;
 
         if (ksig->ka.sa.sa_flags & SA_SIGINFO) {
@@ -547,7 +547,7 @@ static int x32_setup_rt_frame(struct ksignal *ksig,
 
         frame = get_sigframe(&ksig->ka, regs, sizeof(*frame), &fpstate);
 
-        if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+        if (!access_ok(frame, sizeof(*frame)))
                 return -EFAULT;
 
         if (ksig->ka.sa.sa_flags & SA_SIGINFO) {
@@ -610,7 +610,7 @@ SYSCALL_DEFINE0(sigreturn)
 
         frame = (struct sigframe __user *)(regs->sp - 8);
 
-        if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
+        if (!access_ok(frame, sizeof(*frame)))
                 goto badframe;
         if (__get_user(set.sig[0], &frame->sc.oldmask) || (_NSIG_WORDS > 1
                 && __copy_from_user(&set.sig[1], &frame->extramask,
@@ -642,7 +642,7 @@ SYSCALL_DEFINE0(rt_sigreturn)
         unsigned long uc_flags;
 
         frame = (struct rt_sigframe __user *)(regs->sp - sizeof(long));
-        if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
+        if (!access_ok(frame, sizeof(*frame)))
                 goto badframe;
         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
                 goto badframe;
@@ -871,7 +871,7 @@ asmlinkage long sys32_x32_rt_sigreturn(void)
 
         frame = (struct rt_sigframe_x32 __user *)(regs->sp - 8);
 
-        if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
+        if (!access_ok(frame, sizeof(*frame)))
                 goto badframe;
         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
                 goto badframe;
diff --git a/arch/x86/kernel/stacktrace.c b/arch/x86/kernel/stacktrace.c
index 7627455047c2..5c2d71a1dc06 100644
--- a/arch/x86/kernel/stacktrace.c
+++ b/arch/x86/kernel/stacktrace.c
@@ -177,7 +177,7 @@ copy_stack_frame(const void __user *fp, struct stack_frame_user *frame)
 {
         int ret;
 
-        if (!access_ok(VERIFY_READ, fp, sizeof(*frame)))
+        if (!access_ok(fp, sizeof(*frame)))
                 return 0;
 
         ret = 1;
diff --git a/arch/x86/kernel/vm86_32.c b/arch/x86/kernel/vm86_32.c
index c2fd39752da8..a092b6b40c6b 100644
--- a/arch/x86/kernel/vm86_32.c
+++ b/arch/x86/kernel/vm86_32.c
@@ -114,7 +114,7 @@ void save_v86_state(struct kernel_vm86_regs *regs, int retval)
         set_flags(regs->pt.flags, VEFLAGS, X86_EFLAGS_VIF | vm86->veflags_mask);
         user = vm86->user_vm86;
 
-        if (!access_ok(VERIFY_WRITE, user, vm86->vm86plus.is_vm86pus ?
+        if (!access_ok(user, vm86->vm86plus.is_vm86pus ?
                        sizeof(struct vm86plus_struct) :
                        sizeof(struct vm86_struct))) {
                 pr_alert("could not access userspace vm86 info\n");
@@ -278,7 +278,7 @@ static long do_sys_vm86(struct vm86plus_struct __user *user_vm86, bool plus)
         if (vm86->saved_sp0)
                 return -EPERM;
 
-        if (!access_ok(VERIFY_READ, user_vm86, plus ?
+        if (!access_ok(user_vm86, plus ?
                        sizeof(struct vm86_struct) :
                        sizeof(struct vm86plus_struct)))
                 return -EFAULT;
diff --git a/arch/x86/lib/csum-wrappers_64.c b/arch/x86/lib/csum-wrappers_64.c
index 8bd53589ecfb..a6a2b7dccbff 100644
--- a/arch/x86/lib/csum-wrappers_64.c
+++ b/arch/x86/lib/csum-wrappers_64.c
@@ -27,7 +27,7 @@ csum_partial_copy_from_user(const void __user *src, void *dst,
         might_sleep();
         *errp = 0;
 
-        if (!likely(access_ok(VERIFY_READ, src, len)))
+        if (!likely(access_ok(src, len)))
                 goto out_err;
 
         /*
@@ -89,7 +89,7 @@ csum_partial_copy_to_user(const void *src, void __user *dst,
 
         might_sleep();
 
-        if (unlikely(!access_ok(VERIFY_WRITE, dst, len))) {
+        if (unlikely(!access_ok(dst, len))) {
                 *errp = -EFAULT;
                 return 0;
         }
diff --git a/arch/x86/lib/usercopy_32.c b/arch/x86/lib/usercopy_32.c
index 71fb58d44d58..bfd94e7812fc 100644
--- a/arch/x86/lib/usercopy_32.c
+++ b/arch/x86/lib/usercopy_32.c
@@ -67,7 +67,7 @@ unsigned long
 clear_user(void __user *to, unsigned long n)
 {
         might_fault();
-        if (access_ok(VERIFY_WRITE, to, n))
+        if (access_ok(to, n))
                 __do_clear_user(to, n);
         return n;
 }
diff --git a/arch/x86/lib/usercopy_64.c b/arch/x86/lib/usercopy_64.c
index 1bd837cdc4b1..ee42bb0cbeb3 100644
--- a/arch/x86/lib/usercopy_64.c
+++ b/arch/x86/lib/usercopy_64.c
@@ -48,7 +48,7 @@ EXPORT_SYMBOL(__clear_user);
 
 unsigned long clear_user(void __user *to, unsigned long n)
 {
-        if (access_ok(VERIFY_WRITE, to, n))
+        if (access_ok(to, n))
                 return __clear_user(to, n);
         return n;
 }
diff --git a/arch/x86/math-emu/fpu_system.h b/arch/x86/math-emu/fpu_system.h
index c8b1b31ed7c4..f98a0c956764 100644
--- a/arch/x86/math-emu/fpu_system.h
+++ b/arch/x86/math-emu/fpu_system.h
@@ -104,7 +104,7 @@ static inline bool seg_writable(struct desc_struct *d)
 #define instruction_address     (*(struct address *)&I387->soft.fip)
 #define operand_address         (*(struct address *)&I387->soft.foo)
 
-#define FPU_access_ok(x,y,z)    if ( !access_ok(x,y,z) ) \
+#define FPU_access_ok(y,z)      if ( !access_ok(y,z) ) \
                                 math_abort(FPU_info,SIGSEGV)
 #define FPU_abort               math_abort(FPU_info, SIGSEGV)
 
@@ -119,7 +119,7 @@ static inline bool seg_writable(struct desc_struct *d)
 /* A simpler test than access_ok() can probably be done for
    FPU_code_access_ok() because the only possible error is to step
    past the upper boundary of a legal code area. */
-#define FPU_code_access_ok(z) FPU_access_ok(VERIFY_READ,(void __user *)FPU_EIP,z)
+#define FPU_code_access_ok(z) FPU_access_ok((void __user *)FPU_EIP,z)
 #endif
 
 #define FPU_get_user(x,y)       get_user((x),(y))
diff --git a/arch/x86/math-emu/load_store.c b/arch/x86/math-emu/load_store.c
index f821a9cd7753..f15263e158e8 100644
--- a/arch/x86/math-emu/load_store.c
+++ b/arch/x86/math-emu/load_store.c
@@ -251,7 +251,7 @@ int FPU_load_store(u_char type, fpu_addr_modes addr_modes,
                 break;
         case 024:               /* fldcw */
                 RE_ENTRANT_CHECK_OFF;
-                FPU_access_ok(VERIFY_READ, data_address, 2);
+                FPU_access_ok(data_address, 2);
                 FPU_get_user(control_word,
                              (unsigned short __user *)data_address);
                 RE_ENTRANT_CHECK_ON;
@@ -291,7 +291,7 @@ int FPU_load_store(u_char type, fpu_addr_modes addr_modes,
                 break;
         case 034:               /* fstcw m16int */
                 RE_ENTRANT_CHECK_OFF;
-                FPU_access_ok(VERIFY_WRITE, data_address, 2);
+                FPU_access_ok(data_address, 2);
                 FPU_put_user(control_word,
                              (unsigned short __user *)data_address);
                 RE_ENTRANT_CHECK_ON;
@@ -305,7 +305,7 @@ int FPU_load_store(u_char type, fpu_addr_modes addr_modes,
                 break;
         case 036:               /* fstsw m2byte */
                 RE_ENTRANT_CHECK_OFF;
-                FPU_access_ok(VERIFY_WRITE, data_address, 2);
+                FPU_access_ok(data_address, 2);
                 FPU_put_user(status_word(),
                              (unsigned short __user *)data_address);
                 RE_ENTRANT_CHECK_ON;
diff --git a/arch/x86/math-emu/reg_ld_str.c b/arch/x86/math-emu/reg_ld_str.c
index d40ff45497b9..f3779743d15e 100644
--- a/arch/x86/math-emu/reg_ld_str.c
+++ b/arch/x86/math-emu/reg_ld_str.c
@@ -84,7 +84,7 @@ int FPU_load_extended(long double __user *s, int stnr)
         FPU_REG *sti_ptr = &st(stnr);
 
         RE_ENTRANT_CHECK_OFF;
-        FPU_access_ok(VERIFY_READ, s, 10);
+        FPU_access_ok(s, 10);
         __copy_from_user(sti_ptr, s, 10);
         RE_ENTRANT_CHECK_ON;
 
@@ -98,7 +98,7 @@ int FPU_load_double(double __user *dfloat, FPU_REG *loaded_data)
         unsigned m64, l64;
 
         RE_ENTRANT_CHECK_OFF;
-        FPU_access_ok(VERIFY_READ, dfloat, 8);
+        FPU_access_ok(dfloat, 8);
         FPU_get_user(m64, 1 + (unsigned long __user *)dfloat);
         FPU_get_user(l64, (unsigned long __user *)dfloat);
         RE_ENTRANT_CHECK_ON;
@@ -159,7 +159,7 @@ int FPU_load_single(float __user *single, FPU_REG *loaded_data)
         int exp, tag, negative;
 
         RE_ENTRANT_CHECK_OFF;
-        FPU_access_ok(VERIFY_READ, single, 4);
+        FPU_access_ok(single, 4);
         FPU_get_user(m32, (unsigned long __user *)single);
         RE_ENTRANT_CHECK_ON;
 
@@ -214,7 +214,7 @@ int FPU_load_int64(long long __user *_s)
         FPU_REG *st0_ptr = &st(0);
 
         RE_ENTRANT_CHECK_OFF;
-        FPU_access_ok(VERIFY_READ, _s, 8);
+        FPU_access_ok(_s, 8);
         if (copy_from_user(&s, _s, 8))
                 FPU_abort;
         RE_ENTRANT_CHECK_ON;
@@ -243,7 +243,7 @@ int FPU_load_int32(long __user *_s, FPU_REG *loaded_data)
         int negative;
 
         RE_ENTRANT_CHECK_OFF;
-        FPU_access_ok(VERIFY_READ, _s, 4);
+        FPU_access_ok(_s, 4);
         FPU_get_user(s, _s);
         RE_ENTRANT_CHECK_ON;
 
@@ -271,7 +271,7 @@ int FPU_load_int16(short __user *_s, FPU_REG *loaded_data)
         int s, negative;
 
         RE_ENTRANT_CHECK_OFF;
-        FPU_access_ok(VERIFY_READ, _s, 2);
+        FPU_access_ok(_s, 2);
         /* Cast as short to get the sign extended. */
         FPU_get_user(s, _s);
         RE_ENTRANT_CHECK_ON;
@@ -304,7 +304,7 @@ int FPU_load_bcd(u_char __user *s)
         int sign;
 
         RE_ENTRANT_CHECK_OFF;
-        FPU_access_ok(VERIFY_READ, s, 10);
+        FPU_access_ok(s, 10);
         RE_ENTRANT_CHECK_ON;
         for (pos = 8; pos >= 0; pos--) {
                 l *= 10;
@@ -345,7 +345,7 @@ int FPU_store_extended(FPU_REG *st0_ptr, u_char st0_tag,
 
         if (st0_tag != TAG_Empty) {
                 RE_ENTRANT_CHECK_OFF;
-                FPU_access_ok(VERIFY_WRITE, d, 10);
+                FPU_access_ok(d, 10);
 
                 FPU_put_user(st0_ptr->sigl, (unsigned long __user *)d);
                 FPU_put_user(st0_ptr->sigh,
@@ -364,7 +364,7 @@ int FPU_store_extended(FPU_REG *st0_ptr, u_char st0_tag,
                 /* The masked response */
                 /* Put out the QNaN indefinite */
                 RE_ENTRANT_CHECK_OFF;
-                FPU_access_ok(VERIFY_WRITE, d, 10);
+                FPU_access_ok(d, 10);
                 FPU_put_user(0, (unsigned long __user *)d);
                 FPU_put_user(0xc0000000, 1 + (unsigned long __user *)d);
                 FPU_put_user(0xffff, 4 + (short __user *)d);
@@ -539,7 +539,7 @@ denormal_arg:
                         /* The masked response */
                         /* Put out the QNaN indefinite */
                         RE_ENTRANT_CHECK_OFF;
-                        FPU_access_ok(VERIFY_WRITE, dfloat, 8);
+                        FPU_access_ok(dfloat, 8);
                         FPU_put_user(0, (unsigned long __user *)dfloat);
                         FPU_put_user(0xfff80000,
                                      1 + (unsigned long __user *)dfloat);
@@ -552,7 +552,7 @@ denormal_arg:
                 l[1] |= 0x80000000;
 
         RE_ENTRANT_CHECK_OFF;
-        FPU_access_ok(VERIFY_WRITE, dfloat, 8);
+        FPU_access_ok(dfloat, 8);
         FPU_put_user(l[0], (unsigned long __user *)dfloat);
         FPU_put_user(l[1], 1 + (unsigned long __user *)dfloat);
         RE_ENTRANT_CHECK_ON;
@@ -724,7 +724,7 @@ int FPU_store_single(FPU_REG *st0_ptr, u_char st0_tag, float __user *single)
                         /* The masked response */
                         /* Put out the QNaN indefinite */
                         RE_ENTRANT_CHECK_OFF;
-                        FPU_access_ok(VERIFY_WRITE, single, 4);
+                        FPU_access_ok(single, 4);
                         FPU_put_user(0xffc00000,
                                      (unsigned long __user *)single);
                         RE_ENTRANT_CHECK_ON;
@@ -742,7 +742,7 @@ int FPU_store_single(FPU_REG *st0_ptr, u_char st0_tag, float __user *single)
                 templ |= 0x80000000;
 
         RE_ENTRANT_CHECK_OFF;
-        FPU_access_ok(VERIFY_WRITE, single, 4);
+        FPU_access_ok(single, 4);
         FPU_put_user(templ, (unsigned long __user *)single);
         RE_ENTRANT_CHECK_ON;
 
@@ -791,7 +791,7 @@ int FPU_store_int64(FPU_REG *st0_ptr, u_char st0_tag, long long __user *d)
         }
 
         RE_ENTRANT_CHECK_OFF;
-        FPU_access_ok(VERIFY_WRITE, d, 8);
+        FPU_access_ok(d, 8);
         if (copy_to_user(d, &tll, 8))
                 FPU_abort;
         RE_ENTRANT_CHECK_ON;
@@ -838,7 +838,7 @@ int FPU_store_int32(FPU_REG *st0_ptr, u_char st0_tag, long __user *d)
         }
 
         RE_ENTRANT_CHECK_OFF;
-        FPU_access_ok(VERIFY_WRITE, d, 4);
+        FPU_access_ok(d, 4);
         FPU_put_user(t.sigl, (unsigned long __user *)d);
         RE_ENTRANT_CHECK_ON;
 
@@ -884,7 +884,7 @@ int FPU_store_int16(FPU_REG *st0_ptr, u_char st0_tag, short __user *d)
         }
 
         RE_ENTRANT_CHECK_OFF;
-        FPU_access_ok(VERIFY_WRITE, d, 2);
+        FPU_access_ok(d, 2);
         FPU_put_user((short)t.sigl, d);
         RE_ENTRANT_CHECK_ON;
 
@@ -925,7 +925,7 @@ int FPU_store_bcd(FPU_REG *st0_ptr, u_char st0_tag, u_char __user *d)
                 if (control_word & CW_Invalid) {
                         /* Produce the QNaN "indefinite" */
                         RE_ENTRANT_CHECK_OFF;
-                        FPU_access_ok(VERIFY_WRITE, d, 10);
+                        FPU_access_ok(d, 10);
                         for (i = 0; i < 7; i++)
                                 FPU_put_user(0, d + i); /* These bytes "undefined" */
                         FPU_put_user(0xc0, d + 7);      /* This byte "undefined" */
@@ -941,7 +941,7 @@ int FPU_store_bcd(FPU_REG *st0_ptr, u_char st0_tag, u_char __user *d)
         }
 
         RE_ENTRANT_CHECK_OFF;
-        FPU_access_ok(VERIFY_WRITE, d, 10);
+        FPU_access_ok(d, 10);
         RE_ENTRANT_CHECK_ON;
         for (i = 0; i < 9; i++) {
                 b = FPU_div_small(&ll, 10);
@@ -1034,7 +1034,7 @@ u_char __user *fldenv(fpu_addr_modes addr_modes, u_char __user *s)
             ((addr_modes.default_mode == PM16)
              ^ (addr_modes.override.operand_size == OP_SIZE_PREFIX))) {
                 RE_ENTRANT_CHECK_OFF;
-                FPU_access_ok(VERIFY_READ, s, 0x0e);
+                FPU_access_ok(s, 0x0e);
                 FPU_get_user(control_word, (unsigned short __user *)s);
                 FPU_get_user(partial_status, (unsigned short __user *)(s + 2));
                 FPU_get_user(tag_word, (unsigned short __user *)(s + 4));
@@ -1056,7 +1056,7 @@ u_char __user *fldenv(fpu_addr_modes addr_modes, u_char __user *s)
                 }
         } else {
                 RE_ENTRANT_CHECK_OFF;
-                FPU_access_ok(VERIFY_READ, s, 0x1c);
+                FPU_access_ok(s, 0x1c);
                 FPU_get_user(control_word, (unsigned short __user *)s);
                 FPU_get_user(partial_status, (unsigned short __user *)(s + 4));
                 FPU_get_user(tag_word, (unsigned short __user *)(s + 8));
@@ -1125,7 +1125,7 @@ void frstor(fpu_addr_modes addr_modes, u_char __user *data_address)
 
         /* Copy all registers in stack order. */
         RE_ENTRANT_CHECK_OFF;
-        FPU_access_ok(VERIFY_READ, s, 80);
+        FPU_access_ok(s, 80);
         __copy_from_user(register_base + offset, s, other);
         if (offset)
                 __copy_from_user(register_base, s + other, offset);
@@ -1146,7 +1146,7 @@ u_char __user *fstenv(fpu_addr_modes addr_modes, u_char __user *d)
             ((addr_modes.default_mode == PM16)
              ^ (addr_modes.override.operand_size == OP_SIZE_PREFIX))) {
                 RE_ENTRANT_CHECK_OFF;
-                FPU_access_ok(VERIFY_WRITE, d, 14);
+                FPU_access_ok(d, 14);
 #ifdef PECULIAR_486
                 FPU_put_user(control_word & ~0xe080, (unsigned long __user *)d);
 #else
@@ -1174,7 +1174,7 @@ u_char __user *fstenv(fpu_addr_modes addr_modes, u_char __user *d)
                 d += 0x0e;
         } else {
                 RE_ENTRANT_CHECK_OFF;
-                FPU_access_ok(VERIFY_WRITE, d, 7 * 4);
+                FPU_access_ok(d, 7 * 4);
 #ifdef PECULIAR_486
                 control_word &= ~0xe080;
                 /* An 80486 sets nearly all of the reserved bits to 1. */
@@ -1204,7 +1204,7 @@ void fsave(fpu_addr_modes addr_modes, u_char __user *data_address)
         d = fstenv(addr_modes, data_address);
 
         RE_ENTRANT_CHECK_OFF;
-        FPU_access_ok(VERIFY_WRITE, d, 80);
+        FPU_access_ok(d, 80);
 
         /* Copy all registers in stack order. */
         if (__copy_to_user(d, register_base + offset, other))
diff --git a/arch/x86/mm/mpx.c b/arch/x86/mm/mpx.c
index 2385538e8065..de1851d15699 100644
--- a/arch/x86/mm/mpx.c
+++ b/arch/x86/mm/mpx.c
@@ -495,7 +495,7 @@ static int get_bt_addr(struct mm_struct *mm,
         unsigned long bd_entry;
         unsigned long bt_addr;
 
-        if (!access_ok(VERIFY_READ, (bd_entry_ptr), sizeof(*bd_entry_ptr)))
+        if (!access_ok((bd_entry_ptr), sizeof(*bd_entry_ptr)))
                 return -EFAULT;
 
         while (1) {
diff --git a/arch/x86/um/asm/checksum_32.h b/arch/x86/um/asm/checksum_32.h
index 83a75f8a1233..b9ac7c9eb72c 100644
--- a/arch/x86/um/asm/checksum_32.h
+++ b/arch/x86/um/asm/checksum_32.h
@@ -43,7 +43,7 @@ static __inline__ __wsum csum_and_copy_to_user(const void *src,
                                                      void __user *dst,
                                                      int len, __wsum sum, int *err_ptr)
 {
-        if (access_ok(VERIFY_WRITE, dst, len)) {
+        if (access_ok(dst, len)) {
                 if (copy_to_user(dst, src, len)) {
                         *err_ptr = -EFAULT;
                         return (__force __wsum)-1;
diff --git a/arch/x86/um/signal.c b/arch/x86/um/signal.c
index 727ed442e0a5..8b4a71efe7ee 100644
--- a/arch/x86/um/signal.c
+++ b/arch/x86/um/signal.c
@@ -367,7 +367,7 @@ int setup_signal_stack_sc(unsigned long stack_top, struct ksignal *ksig,
         /* This is the same calculation as i386 - ((sp + 4) & 15) == 0 */
         stack_top = ((stack_top + 4) & -16UL) - 4;
         frame = (struct sigframe __user *) stack_top - 1;
-        if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+        if (!access_ok(frame, sizeof(*frame)))
                 return 1;
 
         restorer = frame->retcode;
@@ -412,7 +412,7 @@ int setup_signal_stack_si(unsigned long stack_top, struct ksignal *ksig,
 
         stack_top &= -8UL;
         frame = (struct rt_sigframe __user *) stack_top - 1;
-        if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+        if (!access_ok(frame, sizeof(*frame)))
                 return 1;
 
         restorer = frame->retcode;
@@ -497,7 +497,7 @@ int setup_signal_stack_si(unsigned long stack_top, struct ksignal *ksig,
         /* Subtract 128 for a red zone and 8 for proper alignment */
         frame = (struct rt_sigframe __user *) ((unsigned long) frame - 128 - 8);
 
-        if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+        if (!access_ok(frame, sizeof(*frame)))
                 goto out;
 
         if (ksig->ka.sa.sa_flags & SA_SIGINFO) {