Remove 'type' argument from access_ok() function
authorLinus Torvalds <torvalds@linux-foundation.org>
Fri, 4 Jan 2019 02:57:57 +0000 (18:57 -0800)
committerLinus Torvalds <torvalds@linux-foundation.org>
Fri, 4 Jan 2019 02:57:57 +0000 (18:57 -0800)
Nobody has actually used the type (VERIFY_READ vs VERIFY_WRITE) argument
of the user address range verification function since we got rid of the
old racy i386-only code to walk page tables by hand.

It existed because the original 80386 would not honor the write protect
bit when in kernel mode, so you had to do COW by hand before doing any
user access.  But we haven't supported that in a long time, and these
days the 'type' argument is a purely historical artifact.

A discussion about extending 'user_access_begin()' to do the range
checking resulted this patch, because there is no way we're going to
move the old VERIFY_xyz interface to that model.  And it's best done at
the end of the merge window when I've done most of my merges, so let's
just get this done once and for all.

This patch was mostly done with a sed-script, with manual fix-ups for
the cases that weren't of the trivial 'access_ok(VERIFY_xyz' form.

There were a couple of notable cases:

 - csky still had the old "verify_area()" name as an alias.

 - the iter_iov code had magical hardcoded knowledge of the actual
   values of VERIFY_{READ,WRITE} (not that they mattered, since nothing
   really used it)

 - microblaze used the type argument for a debug printout

but other than those oddities this should be a total no-op patch.

I tried to fix up all architectures, did fairly extensive grepping for
access_ok() uses, and the changes are trivial, but I may have missed
something.  Any missed conversion should be trivially fixable, though.

Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
221 files changed:
arch/alpha/include/asm/futex.h
arch/alpha/include/asm/uaccess.h
arch/alpha/kernel/signal.c
arch/alpha/lib/csum_partial_copy.c
arch/arc/include/asm/futex.h
arch/arc/kernel/process.c
arch/arc/kernel/signal.c
arch/arm/include/asm/futex.h
arch/arm/include/asm/uaccess.h
arch/arm/kernel/perf_callchain.c
arch/arm/kernel/signal.c
arch/arm/kernel/swp_emulate.c
arch/arm/kernel/sys_oabi-compat.c
arch/arm/kernel/traps.c
arch/arm/oprofile/common.c
arch/arm64/include/asm/futex.h
arch/arm64/include/asm/uaccess.h
arch/arm64/kernel/armv8_deprecated.c
arch/arm64/kernel/perf_callchain.c
arch/arm64/kernel/signal.c
arch/arm64/kernel/signal32.c
arch/arm64/kernel/sys_compat.c
arch/c6x/kernel/signal.c
arch/csky/abiv1/alignment.c
arch/csky/include/asm/uaccess.h
arch/csky/kernel/signal.c
arch/csky/lib/usercopy.c
arch/h8300/kernel/signal.c
arch/hexagon/include/asm/futex.h
arch/hexagon/include/asm/uaccess.h
arch/hexagon/kernel/signal.c
arch/hexagon/mm/uaccess.c
arch/ia64/include/asm/futex.h
arch/ia64/include/asm/uaccess.h
arch/ia64/kernel/ptrace.c
arch/ia64/kernel/signal.c
arch/m68k/include/asm/uaccess_mm.h
arch/m68k/include/asm/uaccess_no.h
arch/m68k/kernel/signal.c
arch/microblaze/include/asm/futex.h
arch/microblaze/include/asm/uaccess.h
arch/microblaze/kernel/signal.c
arch/mips/include/asm/checksum.h
arch/mips/include/asm/futex.h
arch/mips/include/asm/termios.h
arch/mips/include/asm/uaccess.h
arch/mips/kernel/mips-r2-to-r6-emul.c
arch/mips/kernel/ptrace.c
arch/mips/kernel/signal.c
arch/mips/kernel/signal32.c
arch/mips/kernel/signal_n32.c
arch/mips/kernel/signal_o32.c
arch/mips/kernel/syscall.c
arch/mips/kernel/unaligned.c
arch/mips/math-emu/cp1emu.c
arch/mips/mm/cache.c
arch/mips/mm/gup.c
arch/mips/oprofile/backtrace.c
arch/mips/sibyte/common/sb_tbprof.c
arch/nds32/include/asm/futex.h
arch/nds32/include/asm/uaccess.h
arch/nds32/kernel/perf_event_cpu.c
arch/nds32/kernel/signal.c
arch/nds32/mm/alignment.c
arch/nios2/include/asm/uaccess.h
arch/nios2/kernel/signal.c
arch/openrisc/include/asm/futex.h
arch/openrisc/include/asm/uaccess.h
arch/openrisc/kernel/signal.c
arch/parisc/include/asm/futex.h
arch/parisc/include/asm/uaccess.h
arch/powerpc/include/asm/futex.h
arch/powerpc/include/asm/uaccess.h
arch/powerpc/kernel/align.c
arch/powerpc/kernel/rtas_flash.c
arch/powerpc/kernel/rtasd.c
arch/powerpc/kernel/signal.c
arch/powerpc/kernel/signal_32.c
arch/powerpc/kernel/signal_64.c
arch/powerpc/kernel/syscalls.c
arch/powerpc/kernel/traps.c
arch/powerpc/kvm/book3s_64_mmu_hv.c
arch/powerpc/lib/checksum_wrappers.c
arch/powerpc/mm/fault.c
arch/powerpc/mm/subpage-prot.c
arch/powerpc/oprofile/backtrace.c
arch/powerpc/platforms/cell/spufs/file.c
arch/powerpc/platforms/powernv/opal-lpc.c
arch/powerpc/platforms/pseries/scanlog.c
arch/riscv/include/asm/futex.h
arch/riscv/include/asm/uaccess.h
arch/riscv/kernel/signal.c
arch/s390/include/asm/uaccess.h
arch/sh/include/asm/checksum_32.h
arch/sh/include/asm/futex.h
arch/sh/include/asm/uaccess.h
arch/sh/kernel/signal_32.c
arch/sh/kernel/signal_64.c
arch/sh/kernel/traps_64.c
arch/sh/mm/gup.c
arch/sh/oprofile/backtrace.c
arch/sparc/include/asm/checksum_32.h
arch/sparc/include/asm/uaccess_32.h
arch/sparc/include/asm/uaccess_64.h
arch/sparc/kernel/sigutil_32.c
arch/sparc/kernel/unaligned_32.c
arch/um/kernel/ptrace.c
arch/unicore32/kernel/signal.c
arch/x86/entry/vsyscall/vsyscall_64.c
arch/x86/ia32/ia32_aout.c
arch/x86/ia32/ia32_signal.c
arch/x86/ia32/sys_ia32.c
arch/x86/include/asm/checksum_32.h
arch/x86/include/asm/pgtable_32.h
arch/x86/include/asm/uaccess.h
arch/x86/kernel/fpu/signal.c
arch/x86/kernel/signal.c
arch/x86/kernel/stacktrace.c
arch/x86/kernel/vm86_32.c
arch/x86/lib/csum-wrappers_64.c
arch/x86/lib/usercopy_32.c
arch/x86/lib/usercopy_64.c
arch/x86/math-emu/fpu_system.h
arch/x86/math-emu/load_store.c
arch/x86/math-emu/reg_ld_str.c
arch/x86/mm/mpx.c
arch/x86/um/asm/checksum_32.h
arch/x86/um/signal.c
arch/xtensa/include/asm/checksum.h
arch/xtensa/include/asm/futex.h
arch/xtensa/include/asm/uaccess.h
arch/xtensa/kernel/signal.c
arch/xtensa/kernel/stacktrace.c
drivers/acpi/acpi_dbg.c
drivers/char/generic_nvram.c
drivers/char/mem.c
drivers/char/nwflash.c
drivers/char/pcmcia/cm4000_cs.c
drivers/crypto/ccp/psp-dev.c
drivers/firewire/core-cdev.c
drivers/firmware/efi/test/efi_test.c
drivers/fpga/dfl-afu-dma-region.c
drivers/fpga/dfl-fme-pr.c
drivers/gpu/drm/amd/amdkfd/kfd_chardev.c
drivers/gpu/drm/armada/armada_gem.c
drivers/gpu/drm/drm_file.c
drivers/gpu/drm/etnaviv/etnaviv_drv.c
drivers/gpu/drm/i915/i915_gem.c
drivers/gpu/drm/i915/i915_gem_execbuffer.c
drivers/gpu/drm/i915/i915_gem_userptr.c
drivers/gpu/drm/i915/i915_ioc32.c
drivers/gpu/drm/i915/i915_perf.c
drivers/gpu/drm/i915/i915_query.c
drivers/gpu/drm/msm/msm_gem_submit.c
drivers/gpu/drm/qxl/qxl_ioctl.c
drivers/infiniband/core/uverbs_main.c
drivers/infiniband/hw/hfi1/user_exp_rcv.c
drivers/infiniband/hw/qib/qib_file_ops.c
drivers/macintosh/ans-lcd.c
drivers/macintosh/via-pmu.c
drivers/media/pci/ivtv/ivtvfb.c
drivers/media/v4l2-core/v4l2-compat-ioctl32.c
drivers/misc/vmw_vmci/vmci_host.c
drivers/pci/proc.c
drivers/platform/goldfish/goldfish_pipe.c
drivers/pnp/isapnp/proc.c
drivers/scsi/pmcraid.c
drivers/scsi/scsi_ioctl.c
drivers/scsi/sg.c
drivers/staging/comedi/comedi_compat32.c
drivers/tty/n_hdlc.c
drivers/usb/core/devices.c
drivers/usb/core/devio.c
drivers/usb/gadget/function/f_hid.c
drivers/usb/gadget/udc/atmel_usba_udc.c
drivers/vhost/vhost.c
drivers/video/fbdev/amifb.c
drivers/video/fbdev/omap2/omapfb/omapfb-ioctl.c
drivers/xen/privcmd.c
fs/binfmt_aout.c
fs/btrfs/send.c
fs/eventpoll.c
fs/fat/dir.c
fs/ioctl.c
fs/namespace.c
fs/ocfs2/dlmfs/dlmfs.c
fs/pstore/pmsg.c
fs/pstore/ram_core.c
fs/read_write.c
fs/readdir.c
fs/select.c
include/asm-generic/uaccess.h
include/linux/regset.h
include/linux/uaccess.h
include/net/checksum.h
kernel/bpf/syscall.c
kernel/compat.c
kernel/events/core.c
kernel/exit.c
kernel/futex.c
kernel/printk/printk.c
kernel/ptrace.c
kernel/rseq.c
kernel/sched/core.c
kernel/signal.c
kernel/sys.c
kernel/trace/bpf_trace.c
lib/bitmap.c
lib/iov_iter.c
lib/usercopy.c
mm/gup.c
mm/mincore.c
net/batman-adv/icmp_socket.c
net/batman-adv/log.c
net/compat.c
net/sunrpc/sysctl.c
security/tomoyo/common.c
sound/core/seq/seq_clientmgr.c
sound/isa/sb/emu8000_patch.c
tools/perf/util/include/asm/uaccess.h
virt/kvm/kvm_main.c

index ca3322536f7247d706bd70d7b7f044f3c3807bea..bfd3c01038f83bac87462029595c7d502bb123d3 100644 (file)
@@ -68,7 +68,7 @@ futex_atomic_cmpxchg_inatomic(u32 *uval, u32 __user *uaddr,
        int ret = 0, cmp;
        u32 prev;
 
-       if (!access_ok(VERIFY_WRITE, uaddr, sizeof(u32)))
+       if (!access_ok(uaddr, sizeof(u32)))
                return -EFAULT;
 
        __asm__ __volatile__ (
index 87d8c4f0307d11539c15df2aa8dace09656a6560..e69c4e13c3283577579e21239653a01bef64fd26 100644 (file)
@@ -36,7 +36,7 @@
 #define __access_ok(addr, size) \
        ((get_fs().seg & (addr | size | (addr+size))) == 0)
 
-#define access_ok(type, addr, size)                    \
+#define access_ok(addr, size)                          \
 ({                                                     \
        __chk_user_ptr(addr);                           \
        __access_ok(((unsigned long)(addr)), (size));   \
index 8c0c4ee0be6edb62d90be4ccbffdb4210a09b89c..33e904a05881797481c1d95b68e56332040bf809 100644 (file)
@@ -65,7 +65,7 @@ SYSCALL_DEFINE3(osf_sigaction, int, sig,
 
        if (act) {
                old_sigset_t mask;
-               if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
+               if (!access_ok(act, sizeof(*act)) ||
                    __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
                    __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
                    __get_user(mask, &act->sa_mask))
@@ -77,7 +77,7 @@ SYSCALL_DEFINE3(osf_sigaction, int, sig,
        ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 
        if (!ret && oact) {
-               if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
+               if (!access_ok(oact, sizeof(*oact)) ||
                    __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
                    __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
                    __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
@@ -207,7 +207,7 @@ do_sigreturn(struct sigcontext __user *sc)
        sigset_t set;
 
        /* Verify that it's a good sigcontext before using it */
-       if (!access_ok(VERIFY_READ, sc, sizeof(*sc)))
+       if (!access_ok(sc, sizeof(*sc)))
                goto give_sigsegv;
        if (__get_user(set.sig[0], &sc->sc_mask))
                goto give_sigsegv;
@@ -235,7 +235,7 @@ do_rt_sigreturn(struct rt_sigframe __user *frame)
        sigset_t set;
 
        /* Verify that it's a good ucontext_t before using it */
-       if (!access_ok(VERIFY_READ, &frame->uc, sizeof(frame->uc)))
+       if (!access_ok(&frame->uc, sizeof(frame->uc)))
                goto give_sigsegv;
        if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
                goto give_sigsegv;
@@ -332,7 +332,7 @@ setup_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs)
 
        oldsp = rdusp();
        frame = get_sigframe(ksig, oldsp, sizeof(*frame));
-       if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+       if (!access_ok(frame, sizeof(*frame)))
                return -EFAULT;
 
        err |= setup_sigcontext(&frame->sc, regs, set->sig[0], oldsp);
@@ -377,7 +377,7 @@ setup_rt_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs)
 
        oldsp = rdusp();
        frame = get_sigframe(ksig, oldsp, sizeof(*frame));
-       if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+       if (!access_ok(frame, sizeof(*frame)))
                return -EFAULT;
 
        err |= copy_siginfo_to_user(&frame->info, &ksig->info);
index ddb9c2f376fa2965035311f48b77e049581ed982..e53f96e8aa6d2bbe60bed40d0d549f3b428cdbc5 100644 (file)
@@ -333,7 +333,7 @@ csum_partial_copy_from_user(const void __user *src, void *dst, int len,
        unsigned long doff = 7 & (unsigned long) dst;
 
        if (len) {
-               if (!access_ok(VERIFY_READ, src, len)) {
+               if (!access_ok(src, len)) {
                        if (errp) *errp = -EFAULT;
                        memset(dst, 0, len);
                        return sum;
index eb887dd13e74862b9bfbba21c2d2d9f09e3b113c..c29c3fae68549b5d84a230a17094698db3037994 100644 (file)
@@ -126,7 +126,7 @@ futex_atomic_cmpxchg_inatomic(u32 *uval, u32 __user *uaddr, u32 expval,
        int ret = 0;
        u32 existval;
 
-       if (!access_ok(VERIFY_WRITE, uaddr, sizeof(u32)))
+       if (!access_ok(uaddr, sizeof(u32)))
                return -EFAULT;
 
 #ifndef CONFIG_ARC_HAS_LLSC
index 8ce6e723591556fc12765a19e08090632bb9d0ba..641c364fc232f01fe0763423894130047286dd35 100644 (file)
@@ -61,7 +61,7 @@ SYSCALL_DEFINE3(arc_usr_cmpxchg, int *, uaddr, int, expected, int, new)
        /* Z indicates to userspace if operation succeded */
        regs->status32 &= ~STATUS_Z_MASK;
 
-       ret = access_ok(VERIFY_WRITE, uaddr, sizeof(*uaddr));
+       ret = access_ok(uaddr, sizeof(*uaddr));
        if (!ret)
                 goto fail;
 
index 48685445002e77ee55a2fe24c40a9c63319b4489..1bfb7de696bd67361a098be6a705df21d3c0ff00 100644 (file)
@@ -169,7 +169,7 @@ SYSCALL_DEFINE0(rt_sigreturn)
 
        sf = (struct rt_sigframe __force __user *)(regs->sp);
 
-       if (!access_ok(VERIFY_READ, sf, sizeof(*sf)))
+       if (!access_ok(sf, sizeof(*sf)))
                goto badframe;
 
        if (__get_user(magic, &sf->sigret_magic))
@@ -219,7 +219,7 @@ static inline void __user *get_sigframe(struct ksignal *ksig,
        frame = (void __user *)((sp - framesize) & ~7);
 
        /* Check that we can actually write to the signal frame */
-       if (!access_ok(VERIFY_WRITE, frame, framesize))
+       if (!access_ok(frame, framesize))
                frame = NULL;
 
        return frame;
index ffebe7b7a5b743682c071fc14a7dd30f75ebfac9..0a46676b4245b3d15292eac1c03f5915033d8cae 100644 (file)
@@ -50,7 +50,7 @@ futex_atomic_cmpxchg_inatomic(u32 *uval, u32 __user *uaddr,
        int ret;
        u32 val;
 
-       if (!access_ok(VERIFY_WRITE, uaddr, sizeof(u32)))
+       if (!access_ok(uaddr, sizeof(u32)))
                return -EFAULT;
 
        smp_mb();
@@ -104,7 +104,7 @@ futex_atomic_cmpxchg_inatomic(u32 *uval, u32 __user *uaddr,
        int ret = 0;
        u32 val;
 
-       if (!access_ok(VERIFY_WRITE, uaddr, sizeof(u32)))
+       if (!access_ok(uaddr, sizeof(u32)))
                return -EFAULT;
 
        preempt_disable();
index c136eef8f690be60bba14f6a871dff286a5942f0..27ed17ec45fe2a5728f8cec106baf3a8596afb2f 100644 (file)
@@ -279,7 +279,7 @@ static inline void set_fs(mm_segment_t fs)
 
 #endif /* CONFIG_MMU */
 
-#define access_ok(type, addr, size)    (__range_ok(addr, size) == 0)
+#define access_ok(addr, size)  (__range_ok(addr, size) == 0)
 
 #define user_addr_max() \
        (uaccess_kernel() ? ~0UL : get_fs())
@@ -560,7 +560,7 @@ raw_copy_to_user(void __user *to, const void *from, unsigned long n)
 
 static inline unsigned long __must_check clear_user(void __user *to, unsigned long n)
 {
-       if (access_ok(VERIFY_WRITE, to, n))
+       if (access_ok(to, n))
                n = __clear_user(to, n);
        return n;
 }
index 08e43a32a693bd810f98d366e19c03e1e3767d63..3b69a76d341e784075a1f8ef053f0d308177feee 100644 (file)
@@ -37,7 +37,7 @@ user_backtrace(struct frame_tail __user *tail,
        struct frame_tail buftail;
        unsigned long err;
 
-       if (!access_ok(VERIFY_READ, tail, sizeof(buftail)))
+       if (!access_ok(tail, sizeof(buftail)))
                return NULL;
 
        pagefault_disable();
index b908382b69ff55a4036fc03208e327df6bc3fbd0..76bb8de6bf6b6983bf5a231ae66b8a162bd9e3ba 100644 (file)
@@ -241,7 +241,7 @@ asmlinkage int sys_sigreturn(struct pt_regs *regs)
 
        frame = (struct sigframe __user *)regs->ARM_sp;
 
-       if (!access_ok(VERIFY_READ, frame, sizeof (*frame)))
+       if (!access_ok(frame, sizeof (*frame)))
                goto badframe;
 
        if (restore_sigframe(regs, frame))
@@ -271,7 +271,7 @@ asmlinkage int sys_rt_sigreturn(struct pt_regs *regs)
 
        frame = (struct rt_sigframe __user *)regs->ARM_sp;
 
-       if (!access_ok(VERIFY_READ, frame, sizeof (*frame)))
+       if (!access_ok(frame, sizeof (*frame)))
                goto badframe;
 
        if (restore_sigframe(regs, &frame->sig))
@@ -355,7 +355,7 @@ get_sigframe(struct ksignal *ksig, struct pt_regs *regs, int framesize)
        /*
         * Check that we can actually write to the signal frame.
         */
-       if (!access_ok(VERIFY_WRITE, frame, framesize))
+       if (!access_ok(frame, framesize))
                frame = NULL;
 
        return frame;
index a188d5e8ab7fa1c32f42a22d612a69603ea7629a..76f6e6a9736cd45f9c14a3165d2c9fb553c3bdf8 100644 (file)
@@ -198,7 +198,7 @@ static int swp_handler(struct pt_regs *regs, unsigned int instr)
                 destreg, EXTRACT_REG_NUM(instr, RT2_OFFSET), data);
 
        /* Check access in reasonable access range for both SWP and SWPB */
-       if (!access_ok(VERIFY_WRITE, (address & ~3), 4)) {
+       if (!access_ok((address & ~3), 4)) {
                pr_debug("SWP{B} emulation: access to %p not allowed!\n",
                         (void *)address);
                res = -EFAULT;
index 40da0872170fca836d734b12257c63906d1e6b8f..92ab36f3879512979c4b0ba558b92599d3df89ab 100644 (file)
@@ -285,7 +285,7 @@ asmlinkage long sys_oabi_epoll_wait(int epfd,
                        maxevents > (INT_MAX/sizeof(*kbuf)) ||
                        maxevents > (INT_MAX/sizeof(*events)))
                return -EINVAL;
-       if (!access_ok(VERIFY_WRITE, events, sizeof(*events) * maxevents))
+       if (!access_ok(events, sizeof(*events) * maxevents))
                return -EFAULT;
        kbuf = kmalloc_array(maxevents, sizeof(*kbuf), GFP_KERNEL);
        if (!kbuf)
@@ -326,7 +326,7 @@ asmlinkage long sys_oabi_semtimedop(int semid,
 
        if (nsops < 1 || nsops > SEMOPM)
                return -EINVAL;
-       if (!access_ok(VERIFY_READ, tsops, sizeof(*tsops) * nsops))
+       if (!access_ok(tsops, sizeof(*tsops) * nsops))
                return -EFAULT;
        sops = kmalloc_array(nsops, sizeof(*sops), GFP_KERNEL);
        if (!sops)
index 2d668cff8ef431dd00cde262fa7118fc846a2964..33af097c454bd53f6beea7419b76953e3228616d 100644 (file)
@@ -582,7 +582,7 @@ do_cache_op(unsigned long start, unsigned long end, int flags)
        if (end < start || flags)
                return -EINVAL;
 
-       if (!access_ok(VERIFY_READ, start, end - start))
+       if (!access_ok(start, end - start))
                return -EFAULT;
 
        return __do_cache_op(start, end);
index cc649a1e46da27ae45488d743597edcc251430ff..7cb3e0453fcd928eb48bbd80dec6b98f38179820 100644 (file)
@@ -88,7 +88,7 @@ static struct frame_tail* user_backtrace(struct frame_tail *tail)
        struct frame_tail buftail[2];
 
        /* Also check accessibility of one struct frame_tail beyond */
-       if (!access_ok(VERIFY_READ, tail, sizeof(buftail)))
+       if (!access_ok(tail, sizeof(buftail)))
                return NULL;
        if (__copy_from_user_inatomic(buftail, tail, sizeof(buftail)))
                return NULL;
index 07fe2479d3105da29feafcb57a209d3942e6dca3..cccb83ad7fa8ea2e1f4251dd724edc62c754771b 100644 (file)
@@ -96,7 +96,7 @@ futex_atomic_cmpxchg_inatomic(u32 *uval, u32 __user *_uaddr,
        u32 val, tmp;
        u32 __user *uaddr;
 
-       if (!access_ok(VERIFY_WRITE, _uaddr, sizeof(u32)))
+       if (!access_ok(_uaddr, sizeof(u32)))
                return -EFAULT;
 
        uaddr = __uaccess_mask_ptr(_uaddr);
index ed252435fd92484cde9d0c04a36ba27b35605948..547d7a0c9d05bdfa30cc102acbc4a7c403d5bfc6 100644 (file)
@@ -95,7 +95,7 @@ static inline unsigned long __range_ok(const void __user *addr, unsigned long si
        return ret;
 }
 
-#define access_ok(type, addr, size)    __range_ok(addr, size)
+#define access_ok(addr, size)  __range_ok(addr, size)
 #define user_addr_max                  get_fs
 
 #define _ASM_EXTABLE(from, to)                                         \
@@ -301,7 +301,7 @@ do {                                                                        \
 ({                                                                     \
        __typeof__(*(ptr)) __user *__p = (ptr);                         \
        might_fault();                                                  \
-       if (access_ok(VERIFY_READ, __p, sizeof(*__p))) {                \
+       if (access_ok(__p, sizeof(*__p))) {                             \
                __p = uaccess_mask_ptr(__p);                            \
                __get_user_err((x), __p, (err));                        \
        } else {                                                        \
@@ -370,7 +370,7 @@ do {                                                                        \
 ({                                                                     \
        __typeof__(*(ptr)) __user *__p = (ptr);                         \
        might_fault();                                                  \
-       if (access_ok(VERIFY_WRITE, __p, sizeof(*__p))) {               \
+       if (access_ok(__p, sizeof(*__p))) {                             \
                __p = uaccess_mask_ptr(__p);                            \
                __put_user_err((x), __p, (err));                        \
        } else  {                                                       \
@@ -418,7 +418,7 @@ extern unsigned long __must_check __arch_copy_in_user(void __user *to, const voi
 extern unsigned long __must_check __arch_clear_user(void __user *to, unsigned long n);
 static inline unsigned long __must_check __clear_user(void __user *to, unsigned long n)
 {
-       if (access_ok(VERIFY_WRITE, to, n))
+       if (access_ok(to, n))
                n = __arch_clear_user(__uaccess_mask_ptr(to), n);
        return n;
 }
index 92be1d12d59080d06472e05e2f292f812a38d224..e52e7280884a850a033b9d91e495dd9e2cb82efc 100644 (file)
@@ -402,7 +402,7 @@ static int swp_handler(struct pt_regs *regs, u32 instr)
 
        /* Check access in reasonable access range for both SWP and SWPB */
        user_ptr = (const void __user *)(unsigned long)(address & ~3);
-       if (!access_ok(VERIFY_WRITE, user_ptr, 4)) {
+       if (!access_ok(user_ptr, 4)) {
                pr_debug("SWP{B} emulation: access to 0x%08x not allowed!\n",
                        address);
                goto fault;
index a34c26afacb0eaf38bebe89ea3dd13d19972c4a9..61d983f5756f8a94ff449cb53bb99534bbf4ac6b 100644 (file)
@@ -39,7 +39,7 @@ user_backtrace(struct frame_tail __user *tail,
        unsigned long lr;
 
        /* Also check accessibility of one struct frame_tail beyond */
-       if (!access_ok(VERIFY_READ, tail, sizeof(buftail)))
+       if (!access_ok(tail, sizeof(buftail)))
                return NULL;
 
        pagefault_disable();
@@ -86,7 +86,7 @@ compat_user_backtrace(struct compat_frame_tail __user *tail,
        unsigned long err;
 
        /* Also check accessibility of one struct frame_tail beyond */
-       if (!access_ok(VERIFY_READ, tail, sizeof(buftail)))
+       if (!access_ok(tail, sizeof(buftail)))
                return NULL;
 
        pagefault_disable();
index 5dcc942906db3afe34cc9972a3eaaa6b72b0848c..867a7cea70e52efe753cc7e40b8815fa2b76e6d5 100644 (file)
@@ -470,7 +470,7 @@ static int parse_user_sigframe(struct user_ctxs *user,
                        offset = 0;
                        limit = extra_size;
 
-                       if (!access_ok(VERIFY_READ, base, limit))
+                       if (!access_ok(base, limit))
                                goto invalid;
 
                        continue;
@@ -556,7 +556,7 @@ SYSCALL_DEFINE0(rt_sigreturn)
 
        frame = (struct rt_sigframe __user *)regs->sp;
 
-       if (!access_ok(VERIFY_READ, frame, sizeof (*frame)))
+       if (!access_ok(frame, sizeof (*frame)))
                goto badframe;
 
        if (restore_sigframe(regs, frame))
@@ -730,7 +730,7 @@ static int get_sigframe(struct rt_sigframe_user_layout *user,
        /*
         * Check that we can actually write to the signal frame.
         */
-       if (!access_ok(VERIFY_WRITE, user->sigframe, sp_top - sp))
+       if (!access_ok(user->sigframe, sp_top - sp))
                return -EFAULT;
 
        return 0;
index 24b09003f8214ce0df5a222a112e6cf10d2161e9..cb7800acd19fbd4554b1d25adab62c908421a0cf 100644 (file)
@@ -303,7 +303,7 @@ COMPAT_SYSCALL_DEFINE0(sigreturn)
 
        frame = (struct compat_sigframe __user *)regs->compat_sp;
 
-       if (!access_ok(VERIFY_READ, frame, sizeof (*frame)))
+       if (!access_ok(frame, sizeof (*frame)))
                goto badframe;
 
        if (compat_restore_sigframe(regs, frame))
@@ -334,7 +334,7 @@ COMPAT_SYSCALL_DEFINE0(rt_sigreturn)
 
        frame = (struct compat_rt_sigframe __user *)regs->compat_sp;
 
-       if (!access_ok(VERIFY_READ, frame, sizeof (*frame)))
+       if (!access_ok(frame, sizeof (*frame)))
                goto badframe;
 
        if (compat_restore_sigframe(regs, &frame->sig))
@@ -365,7 +365,7 @@ static void __user *compat_get_sigframe(struct ksignal *ksig,
        /*
         * Check that we can actually write to the signal frame.
         */
-       if (!access_ok(VERIFY_WRITE, frame, framesize))
+       if (!access_ok(frame, framesize))
                frame = NULL;
 
        return frame;
index 32653d156747e7d8c23ce34ec72ba17341be43a3..21005dfe8406cc390fd34594d017853709d79858 100644 (file)
@@ -58,7 +58,7 @@ do_compat_cache_op(unsigned long start, unsigned long end, int flags)
        if (end < start || flags)
                return -EINVAL;
 
-       if (!access_ok(VERIFY_READ, (const void __user *)start, end - start))
+       if (!access_ok((const void __user *)start, end - start))
                return -EFAULT;
 
        return __do_compat_cache_op(start, end);
index 3c4bb5a5c3820a1d3ad7b7a1ffef55f6206ff838..33b9f69c38f7ba8f95aa5e07e259c3d343bd0c97 100644 (file)
@@ -80,7 +80,7 @@ asmlinkage int do_rt_sigreturn(struct pt_regs *regs)
 
        frame = (struct rt_sigframe __user *) ((unsigned long) 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;
@@ -149,7 +149,7 @@ static int setup_rt_frame(struct ksignal *ksig, sigset_t *set,
 
        frame = get_sigframe(ksig, regs, sizeof(*frame));
 
-       if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+       if (!access_ok(frame, sizeof(*frame)))
                return -EFAULT;
 
        err |= __put_user(&frame->info, &frame->pinfo);
index 60205e98fb87a50b54b9cc55d34e8f87e9fe7569..d789be36eb4f092b992d77967dec5ad11ff7865d 100644 (file)
@@ -32,7 +32,7 @@ static int ldb_asm(uint32_t addr, uint32_t *valp)
        uint32_t val;
        int err;
 
-       if (!access_ok(VERIFY_READ, (void *)addr, 1))
+       if (!access_ok((void *)addr, 1))
                return 1;
 
        asm volatile (
@@ -67,7 +67,7 @@ static int stb_asm(uint32_t addr, uint32_t val)
 {
        int err;
 
-       if (!access_ok(VERIFY_WRITE, (void *)addr, 1))
+       if (!access_ok((void *)addr, 1))
                return 1;
 
        asm volatile (
index acaf0e210d81cfd32f4c394c1b895b601aa7ddb5..eaa1c3403a42458bec78a0a1cbf9678ec7a45b84 100644 (file)
 #include <linux/version.h>
 #include <asm/segment.h>
 
-#define VERIFY_READ    0
-#define VERIFY_WRITE   1
-
-static inline int access_ok(int type, const void *addr, unsigned long size)
+static inline int access_ok(const void *addr, unsigned long size)
 {
        unsigned long limit = current_thread_info()->addr_limit.seg;
 
@@ -27,12 +24,7 @@ static inline int access_ok(int type, const void *addr, unsigned long size)
                ((unsigned long)(addr + size) < limit));
 }
 
-static inline int verify_area(int type, const void *addr, unsigned long size)
-{
-       return access_ok(type, addr, size) ? 0 : -EFAULT;
-}
-
-#define __addr_ok(addr) (access_ok(VERIFY_READ, addr, 0))
+#define __addr_ok(addr) (access_ok(addr, 0))
 
 extern int __put_user_bad(void);
 
@@ -91,7 +83,7 @@ extern int __put_user_bad(void);
        long __pu_err = -EFAULT;                                        \
        typeof(*(ptr)) *__pu_addr = (ptr);                              \
        typeof(*(ptr)) __pu_val = (typeof(*(ptr)))(x);                  \
-       if (access_ok(VERIFY_WRITE, __pu_addr, size) && __pu_addr)      \
+       if (access_ok(__pu_addr, size) && __pu_addr)    \
                __put_user_size(__pu_val, __pu_addr, (size), __pu_err); \
        __pu_err;                                                       \
 })
@@ -217,7 +209,7 @@ do {                                                                \
 ({                                                             \
        int __gu_err = -EFAULT;                                 \
        const __typeof__(*(ptr)) __user *__gu_ptr = (ptr);      \
-       if (access_ok(VERIFY_READ, __gu_ptr, size) && __gu_ptr) \
+       if (access_ok(__gu_ptr, size) && __gu_ptr)      \
                __get_user_size(x, __gu_ptr, size, __gu_err);   \
        __gu_err;                                               \
 })
index 66e1b729b10b741d63cf841c0fa0bd733a3e4f3f..9967c10eee2bff00f7bab79ef4ab3fd1b6023430 100644 (file)
@@ -88,7 +88,7 @@ do_rt_sigreturn(void)
        struct pt_regs *regs = current_pt_regs();
        struct rt_sigframe *frame = (struct rt_sigframe *)(regs->usp);
 
-       if (verify_area(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;
index ac9170e2cbb8fff9bd01450ab3c6c69d91ec9b97..647a23986fb502bb7fad776cb05bce854ef956f3 100644 (file)
@@ -7,7 +7,7 @@
 unsigned long raw_copy_from_user(void *to, const void *from,
                        unsigned long n)
 {
-       if (access_ok(VERIFY_READ, from, n))
+       if (access_ok(from, n))
                __copy_user_zeroing(to, from, n);
        else
                memset(to, 0, n);
@@ -18,7 +18,7 @@ EXPORT_SYMBOL(raw_copy_from_user);
 unsigned long raw_copy_to_user(void *to, const void *from,
                        unsigned long n)
 {
-       if (access_ok(VERIFY_WRITE, to, n))
+       if (access_ok(to, n))
                __copy_user(to, from, n);
        return n;
 }
@@ -113,7 +113,7 @@ long strncpy_from_user(char *dst, const char *src, long count)
 {
        long res = -EFAULT;
 
-       if (access_ok(VERIFY_READ, src, 1))
+       if (access_ok(src, 1))
                __do_strncpy_from_user(dst, src, count, res);
        return res;
 }
@@ -236,7 +236,7 @@ do {                                                        \
 unsigned long
 clear_user(void __user *to, unsigned long n)
 {
-       if (access_ok(VERIFY_WRITE, to, n))
+       if (access_ok(to, n))
                __do_clear_user(to, n);
        return n;
 }
index 1e8070d08770a0cfaa0a4c05c48148ece129de0b..e0f2b708e5d9dbb6dd92cc7ac59c1f0a24411c96 100644 (file)
@@ -110,7 +110,7 @@ asmlinkage int sys_rt_sigreturn(void)
        sigset_t set;
        int er0;
 
-       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;
@@ -165,7 +165,7 @@ static int setup_rt_frame(struct ksignal *ksig, sigset_t *set,
 
        frame = get_sigframe(ksig, regs, sizeof(*frame));
 
-       if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+       if (!access_ok(frame, sizeof(*frame)))
                return -EFAULT;
 
        if (ksig->ka.sa.sa_flags & SA_SIGINFO)
index c889f5993ecd35f1646e06fa1fab846860655ac6..cb635216a732c98c2d05e965762696543d7ec3e4 100644 (file)
@@ -77,7 +77,7 @@ futex_atomic_cmpxchg_inatomic(u32 *uval, u32 __user *uaddr, u32 oldval,
        int prev;
        int ret;
 
-       if (!access_ok(VERIFY_WRITE, uaddr, sizeof(u32)))
+       if (!access_ok(uaddr, sizeof(u32)))
                return -EFAULT;
 
        __asm__ __volatile__ (
index 458b69886b3452fc66d3a33957285645db1c70e0..a30e58d5f3516cce39fd35caec420603e508a45b 100644 (file)
@@ -29,9 +29,6 @@
 
 /*
  * 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
  *
index 78aa7304a5c9f4ac6ddf97343e2a37f29df67a8d..31e2cf95f189c303cc4039753fb26fdd4db7505a 100644 (file)
@@ -115,7 +115,7 @@ static int setup_rt_frame(struct ksignal *ksig, sigset_t *set,
 
        frame = get_sigframe(ksig, regs, sizeof(struct rt_sigframe));
 
-       if (!access_ok(VERIFY_WRITE, frame, sizeof(struct rt_sigframe)))
+       if (!access_ok(frame, sizeof(struct rt_sigframe)))
                return -EFAULT;
 
        if (copy_siginfo_to_user(&frame->info, &ksig->info))
@@ -244,7 +244,7 @@ asmlinkage int sys_rt_sigreturn(void)
        current->restart_block.fn = do_no_restart_syscall;
 
        frame = (struct rt_sigframe __user *)pt_psp(regs);
-       if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
+       if (!access_ok(frame, sizeof(*frame)))
                goto badframe;
        if (__copy_from_user(&blocked, &frame->uc.uc_sigmask, sizeof(blocked)))
                goto badframe;
index c599eb126c9e7be9a3324744297f562ad743e97a..6f9c4697552cc302ab09a564175c4ffdead5830d 100644 (file)
@@ -51,7 +51,7 @@ __kernel_size_t __clear_user_hexagon(void __user *dest, unsigned long count)
 
 unsigned long clear_user_hexagon(void __user *dest, unsigned long count)
 {
-       if (!access_ok(VERIFY_WRITE, dest, count))
+       if (!access_ok(dest, count))
                return count;
        else
                return __clear_user_hexagon(dest, count);
index db2dd85918c2923ce2877e76eed8d7d693885b2a..2e106d46219650bd8093c1100279aff3a73c7e2a 100644 (file)
@@ -86,7 +86,7 @@ static inline int
 futex_atomic_cmpxchg_inatomic(u32 *uval, u32 __user *uaddr,
                              u32 oldval, u32 newval)
 {
-       if (!access_ok(VERIFY_WRITE, uaddr, sizeof(u32)))
+       if (!access_ok(uaddr, sizeof(u32)))
                return -EFAULT;
 
        {
index a74524f2d625f2f6669fafc9f9eead31b78a15ec..306d469e43da6d45e5b7bb2b5aac58f387fd9955 100644 (file)
@@ -67,7 +67,7 @@ static inline int __access_ok(const void __user *p, unsigned long size)
        return likely(addr <= seg) &&
         (seg == KERNEL_DS.seg || likely(REGION_OFFSET(addr) < RGN_MAP_LIMIT));
 }
-#define access_ok(type, addr, size)    __access_ok((addr), (size))
+#define access_ok(addr, size)  __access_ok((addr), (size))
 
 /*
  * These are the main single-value transfer routines.  They automatically
index 427cd565fd61d38429c9ed66cb9b2534a21ee7c3..6d50ede0ed691ca1899540722e65edb3cf896510 100644 (file)
@@ -836,7 +836,7 @@ ptrace_getregs (struct task_struct *child, struct pt_all_user_regs __user *ppr)
        char nat = 0;
        int i;
 
-       if (!access_ok(VERIFY_WRITE, ppr, sizeof(struct pt_all_user_regs)))
+       if (!access_ok(ppr, sizeof(struct pt_all_user_regs)))
                return -EIO;
 
        pt = task_pt_regs(child);
@@ -981,7 +981,7 @@ ptrace_setregs (struct task_struct *child, struct pt_all_user_regs __user *ppr)
 
        memset(&fpval, 0, sizeof(fpval));
 
-       if (!access_ok(VERIFY_READ, ppr, sizeof(struct pt_all_user_regs)))
+       if (!access_ok(ppr, sizeof(struct pt_all_user_regs)))
                return -EIO;
 
        pt = task_pt_regs(child);
index 99099f73b2072e7972c15aa61d57c5186d346141..6062fd14e34eb0312a310698d56c85283f453b3e 100644 (file)
@@ -132,7 +132,7 @@ ia64_rt_sigreturn (struct sigscratch *scr)
                 */
                retval = (long) &ia64_strace_leave_kernel;
 
-       if (!access_ok(VERIFY_READ, sc, sizeof(*sc)))
+       if (!access_ok(sc, sizeof(*sc)))
                goto give_sigsegv;
 
        if (GET_SIGSET(&set, &sc->sc_mask))
@@ -264,7 +264,7 @@ setup_frame(struct ksignal *ksig, sigset_t *set, struct sigscratch *scr)
        }
        frame = (void __user *) ((new_sp - sizeof(*frame)) & -STACK_ALIGN);
 
-       if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) {
+       if (!access_ok(frame, sizeof(*frame))) {
                force_sigsegv(ksig->sig, current);
                return 1;
        }
index c4cb889660aa0c3582d59f0f40428fec718d92a3..7e85de984df197aebb6c56debfe56dbf1f3fc7fe 100644 (file)
@@ -10,7 +10,7 @@
 #include <asm/segment.h>
 
 /* We let the MMU do all checking */
-static inline int access_ok(int type, const void __user *addr,
+static inline int access_ok(const void __user *addr,
                            unsigned long size)
 {
        return 1;
index 892efb56beef81b184a8cf6e21f9cd998d613eb4..0134008bf539b8fc8f0c1a46b20052eca638b7be 100644 (file)
@@ -10,7 +10,7 @@
 
 #include <asm/segment.h>
 
-#define access_ok(type,addr,size)      _access_ok((unsigned long)(addr),(size))
+#define access_ok(addr,size)   _access_ok((unsigned long)(addr),(size))
 
 /*
  * It is not enough to just have access_ok check for a real RAM address.
index 72850b85ecf859a94bdc97b0043df7ccf42b5848..e2a9421c57975034e55695dd273cb42228723773 100644 (file)
@@ -787,7 +787,7 @@ asmlinkage int do_sigreturn(struct pt_regs *regs, struct switch_stack *sw)
        struct sigframe __user *frame = (struct sigframe __user *)(usp - 4);
        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.sc_mask) ||
            (_NSIG_WORDS > 1 &&
@@ -812,7 +812,7 @@ asmlinkage int do_rt_sigreturn(struct pt_regs *regs, struct switch_stack *sw)
        struct rt_sigframe __user *frame = (struct rt_sigframe __user *)(usp - 4);
        sigset_t set;
 
-       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;
index 2572077b04eaa48db06861d63a4322e4922dbd7f..8c90357e59831230afd31893ee7afe792fc1f832 100644 (file)
@@ -71,7 +71,7 @@ futex_atomic_cmpxchg_inatomic(u32 *uval, u32 __user *uaddr,
        int ret = 0, cmp;
        u32 prev;
 
-       if (!access_ok(VERIFY_WRITE, uaddr, sizeof(u32)))
+       if (!access_ok(uaddr, sizeof(u32)))
                return -EFAULT;
 
        __asm__ __volatile__ ("1:       lwx     %1, %3, r0;             \
index 81f16aadbf9ea8fd61df1c91df7bfd64ccf843c3..dbfea093a7c7db596bd2e108a0a47220b7698457 100644 (file)
@@ -60,26 +60,25 @@ static inline int ___range_ok(unsigned long addr, unsigned long size)
 #define __range_ok(addr, size) \
                ___range_ok((unsigned long)(addr), (unsigned long)(size))
 
-#define access_ok(type, addr, size) (__range_ok((addr), (size)) == 0)
+#define access_ok(addr, size) (__range_ok((addr), (size)) == 0)
 
 #else
 
-static inline int access_ok(int type, const void __user *addr,
-                                                       unsigned long size)
+static inline int access_ok(const void __user *addr, unsigned long size)
 {
        if (!size)
                goto ok;
 
        if ((get_fs().seg < ((unsigned long)addr)) ||
                        (get_fs().seg < ((unsigned long)addr + size - 1))) {
-               pr_devel("ACCESS fail: %s at 0x%08x (size 0x%x), seg 0x%08x\n",
-                       type ? "WRITE" : "READ ", (__force u32)addr, (u32)size,
+               pr_devel("ACCESS fail at 0x%08x (size 0x%x), seg 0x%08x\n",
+                       (__force u32)addr, (u32)size,
                        (u32)get_fs().seg);
                return 0;
        }
 ok:
-       pr_devel("ACCESS OK: %s at 0x%08x (size 0x%x), seg 0x%08x\n",
-                       type ? "WRITE" : "READ ", (__force u32)addr, (u32)size,
+       pr_devel("ACCESS OK at 0x%08x (size 0x%x), seg 0x%08x\n",
+                       (__force u32)addr, (u32)size,
                        (u32)get_fs().seg);
        return 1;
 }
@@ -120,7 +119,7 @@ static inline unsigned long __must_check clear_user(void __user *to,
                                                        unsigned long n)
 {
        might_fault();
-       if (unlikely(!access_ok(VERIFY_WRITE, to, n)))
+       if (unlikely(!access_ok(to, n)))
                return n;
 
        return __clear_user(to, n);
@@ -174,7 +173,7 @@ extern long __user_bad(void);
        const typeof(*(ptr)) __user *__gu_addr = (ptr);                 \
        int __gu_err = 0;                                               \
                                                                        \
-       if (access_ok(VERIFY_READ, __gu_addr, size)) {                  \
+       if (access_ok(__gu_addr, size)) {                       \
                switch (size) {                                         \
                case 1:                                                 \
                        __get_user_asm("lbu", __gu_addr, __gu_val,      \
@@ -286,7 +285,7 @@ extern long __user_bad(void);
        typeof(*(ptr)) __user *__pu_addr = (ptr);                       \
        int __pu_err = 0;                                               \
                                                                        \
-       if (access_ok(VERIFY_WRITE, __pu_addr, size)) {                 \
+       if (access_ok(__pu_addr, size)) {                       \
                switch (size) {                                         \
                case 1:                                                 \
                        __put_user_asm("sb", __pu_addr, __pu_val,       \
@@ -358,7 +357,7 @@ extern int __strncpy_user(char *to, const char __user *from, int len);
 static inline long
 strncpy_from_user(char *dst, const char __user *src, long count)
 {
-       if (!access_ok(VERIFY_READ, src, 1))
+       if (!access_ok(src, 1))
                return -EFAULT;
        return __strncpy_user(dst, src, count);
 }
@@ -372,7 +371,7 @@ extern int __strnlen_user(const char __user *sstr, int len);
 
 static inline long strnlen_user(const char __user *src, long n)
 {
-       if (!access_ok(VERIFY_READ, src, 1))
+       if (!access_ok(src, 1))
                return 0;
        return __strnlen_user(src, n);
 }
index 97001524ca2d8e3062a51e4a536ad4d1d18a702f..0685696349bb4415a4c4f1c6d9d3249c54be501f 100644 (file)
@@ -91,7 +91,7 @@ asmlinkage long sys_rt_sigreturn(struct pt_regs *regs)
        /* Always make any pending restarted system calls return -EINTR */
        current->restart_block.fn = do_no_restart_syscall;
 
-       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)))
@@ -166,7 +166,7 @@ static int setup_rt_frame(struct ksignal *ksig, sigset_t *set,
 
        frame = get_sigframe(ksig, regs, sizeof(*frame));
 
-       if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+       if (!access_ok(frame, sizeof(*frame)))
                return -EFAULT;
 
        if (ksig->ka.sa.sa_flags & SA_SIGINFO)
index e8161e4dfde7039a80cb3875bba7b9415520c67b..dcebaaf8c862497342631d469163b39fea9c41b9 100644 (file)
@@ -63,7 +63,7 @@ static inline
 __wsum csum_and_copy_from_user(const void __user *src, void *dst,
                               int len, __wsum sum, int *err_ptr)
 {
-       if (access_ok(VERIFY_READ, src, len))
+       if (access_ok(src, len))
                return csum_partial_copy_from_user(src, dst, len, sum,
                                                   err_ptr);
        if (len)
@@ -81,7 +81,7 @@ __wsum csum_and_copy_to_user(const void *src, void __user *dst, int len,
                             __wsum sum, int *err_ptr)
 {
        might_fault();
-       if (access_ok(VERIFY_WRITE, dst, len)) {
+       if (access_ok(dst, len)) {
                if (uaccess_kernel())
                        return __csum_partial_copy_kernel(src,
                                                          (__force void *)dst,
index 8eff134b3a4314382180e5e56e33b0e94b3c517f..c14d798f38886c15b0f8d8adfbcf7008ad863d74 100644 (file)
@@ -129,7 +129,7 @@ futex_atomic_cmpxchg_inatomic(u32 *uval, u32 __user *uaddr,
        int ret = 0;
        u32 val;
 
-       if (!access_ok(VERIFY_WRITE, uaddr, sizeof(u32)))
+       if (!access_ok(uaddr, sizeof(u32)))
                return -EFAULT;
 
        if (cpu_has_llsc && R10000_LLSC_WAR) {
index ce2d72e34274c0f2d2e217277aa6706ab5f4cb93..bc29eeacc55adb17ac7b95759d62222636619c9e 100644 (file)
@@ -32,7 +32,7 @@ static inline int user_termio_to_kernel_termios(struct ktermios *termios,
        unsigned short iflag, oflag, cflag, lflag;
        unsigned int err;
 
-       if (!access_ok(VERIFY_READ, termio, sizeof(struct termio)))
+       if (!access_ok(termio, sizeof(struct termio)))
                return -EFAULT;
 
        err = __get_user(iflag, &termio->c_iflag);
@@ -61,7 +61,7 @@ static inline int kernel_termios_to_user_termio(struct termio __user *termio,
 {
        int err;
 
-       if (!access_ok(VERIFY_WRITE, termio, sizeof(struct termio)))
+       if (!access_ok(termio, sizeof(struct termio)))
                return -EFAULT;
 
        err = __put_user(termios->c_iflag, &termio->c_iflag);
index 06629011a4342f490bf4bcabd9e4fe06ed0952ac..d43c1dc6ef157a59c4b96d456aacc9d69ce077ed 100644 (file)
@@ -109,9 +109,6 @@ static inline bool eva_kernel_access(void)
 
 /*
  * 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
  *
@@ -134,7 +131,7 @@ static inline int __access_ok(const void __user *p, unsigned long size)
        return (get_fs().seg & (addr | (addr + size) | __ua_size(size))) == 0;
 }
 
-#define access_ok(type, addr, size)                                    \
+#define access_ok(addr, size)                                  \
        likely(__access_ok((addr), (size)))
 
 /*
@@ -304,7 +301,7 @@ do {                                                                        \
        const __typeof__(*(ptr)) __user * __gu_ptr = (ptr);             \
                                                                        \
        might_fault();                                                  \
-       if (likely(access_ok(VERIFY_READ,  __gu_ptr, size))) {          \
+       if (likely(access_ok( __gu_ptr, size))) {               \
                if (eva_kernel_access())                                \
                        __get_kernel_common((x), size, __gu_ptr);       \
                else                                                    \
@@ -446,7 +443,7 @@ do {                                                                        \
        int __pu_err = -EFAULT;                                         \
                                                                        \
        might_fault();                                                  \
-       if (likely(access_ok(VERIFY_WRITE,  __pu_addr, size))) {        \
+       if (likely(access_ok( __pu_addr, size))) {      \
                if (eva_kernel_access())                                \
                        __put_kernel_common(__pu_addr, size);           \
                else                                                    \
@@ -691,8 +688,7 @@ __clear_user(void __user *addr, __kernel_size_t size)
 ({                                                                     \
        void __user * __cl_addr = (addr);                               \
        unsigned long __cl_size = (n);                                  \
-       if (__cl_size && access_ok(VERIFY_WRITE,                        \
-                                       __cl_addr, __cl_size))          \
+       if (__cl_size && access_ok(__cl_addr, __cl_size))               \
                __cl_size = __clear_user(__cl_addr, __cl_size);         \
        __cl_size;                                                      \
 })
index cb22a558431e21ce4fca50fc87a51311f2fdc27e..c50c89a978f12761b7ed688517343e4ba37ed7bb 100644 (file)
@@ -1205,7 +1205,7 @@ fpu_emul:
        case lwl_op:
                rt = regs->regs[MIPSInst_RT(inst)];
                vaddr = regs->regs[MIPSInst_RS(inst)] + MIPSInst_SIMM(inst);
-               if (!access_ok(VERIFY_READ, (void __user *)vaddr, 4)) {
+               if (!access_ok((void __user *)vaddr, 4)) {
                        current->thread.cp0_baduaddr = vaddr;
                        err = SIGSEGV;
                        break;
@@ -1278,7 +1278,7 @@ fpu_emul:
        case lwr_op:
                rt = regs->regs[MIPSInst_RT(inst)];
                vaddr = regs->regs[MIPSInst_RS(inst)] + MIPSInst_SIMM(inst);
-               if (!access_ok(VERIFY_READ, (void __user *)vaddr, 4)) {
+               if (!access_ok((void __user *)vaddr, 4)) {
                        current->thread.cp0_baduaddr = vaddr;
                        err = SIGSEGV;
                        break;
@@ -1352,7 +1352,7 @@ fpu_emul:
        case swl_op:
                rt = regs->regs[MIPSInst_RT(inst)];
                vaddr = regs->regs[MIPSInst_RS(inst)] + MIPSInst_SIMM(inst);
-               if (!access_ok(VERIFY_WRITE, (void __user *)vaddr, 4)) {
+               if (!access_ok((void __user *)vaddr, 4)) {
                        current->thread.cp0_baduaddr = vaddr;
                        err = SIGSEGV;
                        break;
@@ -1422,7 +1422,7 @@ fpu_emul:
        case swr_op:
                rt = regs->regs[MIPSInst_RT(inst)];
                vaddr = regs->regs[MIPSInst_RS(inst)] + MIPSInst_SIMM(inst);
-               if (!access_ok(VERIFY_WRITE, (void __user *)vaddr, 4)) {
+               if (!access_ok((void __user *)vaddr, 4)) {
                        current->thread.cp0_baduaddr = vaddr;
                        err = SIGSEGV;
                        break;
@@ -1497,7 +1497,7 @@ fpu_emul:
 
                rt = regs->regs[MIPSInst_RT(inst)];
                vaddr = regs->regs[MIPSInst_RS(inst)] + MIPSInst_SIMM(inst);
-               if (!access_ok(VERIFY_READ, (void __user *)vaddr, 8)) {
+               if (!access_ok((void __user *)vaddr, 8)) {
                        current->thread.cp0_baduaddr = vaddr;
                        err = SIGSEGV;
                        break;
@@ -1616,7 +1616,7 @@ fpu_emul:
 
                rt = regs->regs[MIPSInst_RT(inst)];
                vaddr = regs->regs[MIPSInst_RS(inst)] + MIPSInst_SIMM(inst);
-               if (!access_ok(VERIFY_READ, (void __user *)vaddr, 8)) {
+               if (!access_ok((void __user *)vaddr, 8)) {
                        current->thread.cp0_baduaddr = vaddr;
                        err = SIGSEGV;
                        break;
@@ -1735,7 +1735,7 @@ fpu_emul:
 
                rt = regs->regs[MIPSInst_RT(inst)];
                vaddr = regs->regs[MIPSInst_RS(inst)] + MIPSInst_SIMM(inst);
-               if (!access_ok(VERIFY_WRITE, (void __user *)vaddr, 8)) {
+               if (!access_ok((void __user *)vaddr, 8)) {
                        current->thread.cp0_baduaddr = vaddr;
                        err = SIGSEGV;
                        break;
@@ -1853,7 +1853,7 @@ fpu_emul:
 
                rt = regs->regs[MIPSInst_RT(inst)];
                vaddr = regs->regs[MIPSInst_RS(inst)] + MIPSInst_SIMM(inst);
-               if (!access_ok(VERIFY_WRITE, (void __user *)vaddr, 8)) {
+               if (!access_ok((void __user *)vaddr, 8)) {
                        current->thread.cp0_baduaddr = vaddr;
                        err = SIGSEGV;
                        break;
@@ -1970,7 +1970,7 @@ fpu_emul:
                        err = SIGBUS;
                        break;
                }
-               if (!access_ok(VERIFY_READ, (void __user *)vaddr, 4)) {
+               if (!access_ok((void __user *)vaddr, 4)) {
                        current->thread.cp0_baduaddr = vaddr;
                        err = SIGBUS;
                        break;
@@ -2026,7 +2026,7 @@ fpu_emul:
                        err = SIGBUS;
                        break;
                }
-               if (!access_ok(VERIFY_WRITE, (void __user *)vaddr, 4)) {
+               if (!access_ok((void __user *)vaddr, 4)) {
                        current->thread.cp0_baduaddr = vaddr;
                        err = SIGBUS;
                        break;
@@ -2089,7 +2089,7 @@ fpu_emul:
                        err = SIGBUS;
                        break;
                }
-               if (!access_ok(VERIFY_READ, (void __user *)vaddr, 8)) {
+               if (!access_ok((void __user *)vaddr, 8)) {
                        current->thread.cp0_baduaddr = vaddr;
                        err = SIGBUS;
                        break;
@@ -2150,7 +2150,7 @@ fpu_emul:
                        err = SIGBUS;
                        break;
                }
-               if (!access_ok(VERIFY_WRITE, (void __user *)vaddr, 8)) {
+               if (!access_ok((void __user *)vaddr, 8)) {
                        current->thread.cp0_baduaddr = vaddr;
                        err = SIGBUS;
                        break;
index ea54575255eaea11ff464935b742fef55601ef1b..0057c910bc2f34de0f518c43d2e234c845db0da1 100644 (file)
@@ -71,7 +71,7 @@ int ptrace_getregs(struct task_struct *child, struct user_pt_regs __user *data)
        struct pt_regs *regs;
        int i;
 
-       if (!access_ok(VERIFY_WRITE, data, 38 * 8))
+       if (!access_ok(data, 38 * 8))
                return -EIO;
 
        regs = task_pt_regs(child);
@@ -98,7 +98,7 @@ int ptrace_setregs(struct task_struct *child, struct user_pt_regs __user *data)
        struct pt_regs *regs;
        int i;
 
-       if (!access_ok(VERIFY_READ, data, 38 * 8))
+       if (!access_ok(data, 38 * 8))
                return -EIO;
 
        regs = task_pt_regs(child);
@@ -125,7 +125,7 @@ int ptrace_get_watch_regs(struct task_struct *child,
 
        if (!cpu_has_watch || boot_cpu_data.watch_reg_use_cnt == 0)
                return -EIO;
-       if (!access_ok(VERIFY_WRITE, addr, sizeof(struct pt_watch_regs)))
+       if (!access_ok(addr, sizeof(struct pt_watch_regs)))
                return -EIO;
 
 #ifdef CONFIG_32BIT
@@ -167,7 +167,7 @@ int ptrace_set_watch_regs(struct task_struct *child,
 
        if (!cpu_has_watch || boot_cpu_data.watch_reg_use_cnt == 0)
                return -EIO;
-       if (!access_ok(VERIFY_READ, addr, sizeof(struct pt_watch_regs)))
+       if (!access_ok(addr, sizeof(struct pt_watch_regs)))
                return -EIO;
        /* Check the values. */
        for (i = 0; i < boot_cpu_data.watch_reg_use_cnt; i++) {
@@ -359,7 +359,7 @@ int ptrace_getfpregs(struct task_struct *child, __u32 __user *data)
 {
        int i;
 
-       if (!access_ok(VERIFY_WRITE, data, 33 * 8))
+       if (!access_ok(data, 33 * 8))
                return -EIO;
 
        if (tsk_used_math(child)) {
@@ -385,7 +385,7 @@ int ptrace_setfpregs(struct task_struct *child, __u32 __user *data)
        u32 value;
        int i;
 
-       if (!access_ok(VERIFY_READ, data, 33 * 8))
+       if (!access_ok(data, 33 * 8))
                return -EIO;
 
        init_fp_ctx(child);
index d3a23758592ca17e6c3f4dc13edd168ad45cd496..d75337974ee9b8ef8b8adb223f82cb4e17598659 100644 (file)
@@ -590,7 +590,7 @@ SYSCALL_DEFINE3(sigaction, int, sig, const struct sigaction __user *, act,
        if (act) {
                old_sigset_t mask;
 
-               if (!access_ok(VERIFY_READ, act, sizeof(*act)))
+               if (!access_ok(act, sizeof(*act)))
                        return -EFAULT;
                err |= __get_user(new_ka.sa.sa_handler, &act->sa_handler);
                err |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
@@ -604,7 +604,7 @@ SYSCALL_DEFINE3(sigaction, int, sig, const struct sigaction __user *, act,
        ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 
        if (!ret && oact) {
-               if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
+               if (!access_ok(oact, sizeof(*oact)))
                        return -EFAULT;
                err |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
                err |= __put_user(old_ka.sa.sa_handler, &oact->sa_handler);
@@ -630,7 +630,7 @@ asmlinkage void sys_sigreturn(void)
 
        regs = current_pt_regs();
        frame = (struct sigframe __user *)regs->regs[29];
-       if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
+       if (!access_ok(frame, sizeof(*frame)))
                goto badframe;
        if (__copy_from_user(&blocked, &frame->sf_mask, sizeof(blocked)))
                goto badframe;
@@ -667,7 +667,7 @@ asmlinkage void sys_rt_sigreturn(void)
 
        regs = current_pt_regs();
        frame = (struct rt_sigframe __user *)regs->regs[29];
-       if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
+       if (!access_ok(frame, sizeof(*frame)))
                goto badframe;
        if (__copy_from_user(&set, &frame->rs_uc.uc_sigmask, sizeof(set)))
                goto badframe;
@@ -705,7 +705,7 @@ static int setup_frame(void *sig_return, struct ksignal *ksig,
        int err = 0;
 
        frame = get_sigframe(ksig, regs, sizeof(*frame));
-       if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
+       if (!access_ok(frame, sizeof (*frame)))
                return -EFAULT;
 
        err |= setup_sigcontext(regs, &frame->sf_sc);
@@ -744,7 +744,7 @@ static int setup_rt_frame(void *sig_return, struct ksignal *ksig,
        int err = 0;
 
        frame = get_sigframe(ksig, regs, sizeof(*frame));
-       if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
+       if (!access_ok(frame, sizeof (*frame)))
                return -EFAULT;
 
        /* Create siginfo.  */
index b5d9e1784aff35ef0724a96e2784d11eb9e15057..59b8965433c2fdb2f8337de49680ca6a50b09dde 100644 (file)
@@ -46,7 +46,7 @@ SYSCALL_DEFINE3(32_sigaction, long, sig, const struct compat_sigaction __user *,
                old_sigset_t mask;
                s32 handler;
 
-               if (!access_ok(VERIFY_READ, act, sizeof(*act)))
+               if (!access_ok(act, sizeof(*act)))
                        return -EFAULT;
                err |= __get_user(handler, &act->sa_handler);
                new_ka.sa.sa_handler = (void __user *)(s64)handler;
@@ -61,7 +61,7 @@ SYSCALL_DEFINE3(32_sigaction, long, sig, const struct compat_sigaction __user *,
        ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 
        if (!ret && oact) {
-               if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
+               if (!access_ok(oact, sizeof(*oact)))
                        return -EFAULT;
                err |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
                err |= __put_user((u32)(u64)old_ka.sa.sa_handler,
index 8f65aaf9206d1ba88ab0f68e580eb176aacd173e..c498b027823e695a31f39bdee86d7056ccc56403 100644 (file)
@@ -73,7 +73,7 @@ asmlinkage void sysn32_rt_sigreturn(void)
 
        regs = current_pt_regs();
        frame = (struct rt_sigframe_n32 __user *)regs->regs[29];
-       if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
+       if (!access_ok(frame, sizeof(*frame)))
                goto badframe;
        if (__copy_conv_sigset_from_user(&set, &frame->rs_uc.uc_sigmask))
                goto badframe;
@@ -110,7 +110,7 @@ static int setup_rt_frame_n32(void *sig_return, struct ksignal *ksig,
        int err = 0;
 
        frame = get_sigframe(ksig, regs, sizeof(*frame));
-       if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
+       if (!access_ok(frame, sizeof (*frame)))
                return -EFAULT;
 
        /* Create siginfo.  */
index b6e3ddef48a06f9a543a10edc3c96e5ce1116b2b..df259618e834bb390629b7df18e6a65225c9d109 100644 (file)
@@ -118,7 +118,7 @@ static int setup_frame_32(void *sig_return, struct ksignal *ksig,
        int err = 0;
 
        frame = get_sigframe(ksig, regs, sizeof(*frame));
-       if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
+       if (!access_ok(frame, sizeof (*frame)))
                return -EFAULT;
 
        err |= setup_sigcontext32(regs, &frame->sf_sc);
@@ -160,7 +160,7 @@ asmlinkage void sys32_rt_sigreturn(void)
 
        regs = current_pt_regs();
        frame = (struct rt_sigframe32 __user *)regs->regs[29];
-       if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
+       if (!access_ok(frame, sizeof(*frame)))
                goto badframe;
        if (__copy_conv_sigset_from_user(&set, &frame->rs_uc.uc_sigmask))
                goto badframe;
@@ -197,7 +197,7 @@ static int setup_rt_frame_32(void *sig_return, struct ksignal *ksig,
        int err = 0;
 
        frame = get_sigframe(ksig, regs, sizeof(*frame));
-       if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
+       if (!access_ok(frame, sizeof (*frame)))
                return -EFAULT;
 
        /* Convert (siginfo_t -> compat_siginfo_t) and copy to user. */
@@ -262,7 +262,7 @@ asmlinkage void sys32_sigreturn(void)
 
        regs = current_pt_regs();
        frame = (struct sigframe32 __user *)regs->regs[29];
-       if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
+       if (!access_ok(frame, sizeof(*frame)))
                goto badframe;
        if (__copy_conv_sigset_from_user(&blocked, &frame->sf_mask))
                goto badframe;
index 41a0db08cd37a21affab3b8911b99715525f181a..b6dc78ad5d8c050fc75badc33c33ac46496238bc 100644 (file)
@@ -101,7 +101,7 @@ static inline int mips_atomic_set(unsigned long addr, unsigned long new)
        if (unlikely(addr & 3))
                return -EINVAL;
 
-       if (unlikely(!access_ok(VERIFY_WRITE, (const void __user *)addr, 4)))
+       if (unlikely(!access_ok((const void __user *)addr, 4)))
                return -EINVAL;
 
        if (cpu_has_llsc && R10000_LLSC_WAR) {
index c60e7719ef77e434803b3f47aa7add3883416035..595ca9c851110db0a76847f596ba21197db9aaf9 100644 (file)
@@ -936,7 +936,7 @@ static void emulate_load_store_insn(struct pt_regs *regs,
                if (insn.dsp_format.func == lx_op) {
                        switch (insn.dsp_format.op) {
                        case lwx_op:
-                               if (!access_ok(VERIFY_READ, addr, 4))
+                               if (!access_ok(addr, 4))
                                        goto sigbus;
                                LoadW(addr, value, res);
                                if (res)
@@ -945,7 +945,7 @@ static void emulate_load_store_insn(struct pt_regs *regs,
                                regs->regs[insn.dsp_format.rd] = value;
                                break;
                        case lhx_op:
-                               if (!access_ok(VERIFY_READ, addr, 2))
+                               if (!access_ok(addr, 2))
                                        goto sigbus;
                                LoadHW(addr, value, res);
                                if (res)
@@ -968,7 +968,7 @@ static void emulate_load_store_insn(struct pt_regs *regs,
                        set_fs(USER_DS);
                        switch (insn.spec3_format.func) {
                        case lhe_op:
-                               if (!access_ok(VERIFY_READ, addr, 2)) {
+                               if (!access_ok(addr, 2)) {
                                        set_fs(seg);
                                        goto sigbus;
                                }
@@ -981,7 +981,7 @@ static void emulate_load_store_insn(struct pt_regs *regs,
                                regs->regs[insn.spec3_format.rt] = value;
                                break;
                        case lwe_op:
-                               if (!access_ok(VERIFY_READ, addr, 4)) {
+                               if (!access_ok(addr, 4)) {
                                        set_fs(seg);
                                        goto sigbus;
                                }
@@ -994,7 +994,7 @@ static void emulate_load_store_insn(struct pt_regs *regs,
                                regs->regs[insn.spec3_format.rt] = value;
                                break;
                        case lhue_op:
-                               if (!access_ok(VERIFY_READ, addr, 2)) {
+                               if (!access_ok(addr, 2)) {
                                        set_fs(seg);
                                        goto sigbus;
                                }
@@ -1007,7 +1007,7 @@ static void emulate_load_store_insn(struct pt_regs *regs,
                                regs->regs[insn.spec3_format.rt] = value;
                                break;
                        case she_op:
-                               if (!access_ok(VERIFY_WRITE, addr, 2)) {
+                               if (!access_ok(addr, 2)) {
                                        set_fs(seg);
                                        goto sigbus;
                                }
@@ -1020,7 +1020,7 @@ static void emulate_load_store_insn(struct pt_regs *regs,
                                }
                                break;
                        case swe_op:
-                               if (!access_ok(VERIFY_WRITE, addr, 4)) {
+                               if (!access_ok(addr, 4)) {
                                        set_fs(seg);
                                        goto sigbus;
                                }
@@ -1041,7 +1041,7 @@ static void emulate_load_store_insn(struct pt_regs *regs,
 #endif
                break;
        case lh_op:
-               if (!access_ok(VERIFY_READ, addr, 2))
+               if (!access_ok(addr, 2))
                        goto sigbus;
 
                if (IS_ENABLED(CONFIG_EVA)) {
@@ -1060,7 +1060,7 @@ static void emulate_load_store_insn(struct pt_regs *regs,
                break;
 
        case lw_op:
-               if (!access_ok(VERIFY_READ, addr, 4))
+               if (!access_ok(addr, 4))
                        goto sigbus;
 
                if (IS_ENABLED(CONFIG_EVA)) {
@@ -1079,7 +1079,7 @@ static void emulate_load_store_insn(struct pt_regs *regs,
                break;
 
        case lhu_op:
-               if (!access_ok(VERIFY_READ, addr, 2))
+               if (!access_ok(addr, 2))
                        goto sigbus;
 
                if (IS_ENABLED(CONFIG_EVA)) {
@@ -1106,7 +1106,7 @@ static void emulate_load_store_insn(struct pt_regs *regs,
                 * would blow up, so for now we don't handle unaligned 64-bit
                 * instructions on 32-bit kernels.
                 */
-               if (!access_ok(VERIFY_READ, addr, 4))
+               if (!access_ok(addr, 4))
                        goto sigbus;
 
                LoadWU(addr, value, res);
@@ -1129,7 +1129,7 @@ static void emulate_load_store_insn(struct pt_regs *regs,
                 * would blow up, so for now we don't handle unaligned 64-bit
                 * instructions on 32-bit kernels.
                 */
-               if (!access_ok(VERIFY_READ, addr, 8))
+               if (!access_ok(addr, 8))
                        goto sigbus;
 
                LoadDW(addr, value, res);
@@ -1144,7 +1144,7 @@ static void emulate_load_store_insn(struct pt_regs *regs,
                goto sigill;
 
        case sh_op:
-               if (!access_ok(VERIFY_WRITE, addr, 2))
+               if (!access_ok(addr, 2))
                        goto sigbus;
 
                compute_return_epc(regs);
@@ -1164,7 +1164,7 @@ static void emulate_load_store_insn(struct pt_regs *regs,
                break;
 
        case sw_op:
-               if (!access_ok(VERIFY_WRITE, addr, 4))
+               if (!access_ok(addr, 4))
                        goto sigbus;
 
                compute_return_epc(regs);
@@ -1192,7 +1192,7 @@ static void emulate_load_store_insn(struct pt_regs *regs,
                 * would blow up, so for now we don't handle unaligned 64-bit
                 * instructions on 32-bit kernels.
                 */
-               if (!access_ok(VERIFY_WRITE, addr, 8))
+               if (!access_ok(addr, 8))
                        goto sigbus;
 
                compute_return_epc(regs);
@@ -1254,7 +1254,7 @@ static void emulate_load_store_insn(struct pt_regs *regs,
 
                switch (insn.msa_mi10_format.func) {
                case msa_ld_op:
-                       if (!access_ok(VERIFY_READ, addr, sizeof(*fpr)))
+                       if (!access_ok(addr, sizeof(*fpr)))
                                goto sigbus;
 
                        do {
@@ -1290,7 +1290,7 @@ static void emulate_load_store_insn(struct pt_regs *regs,
                        break;
 
                case msa_st_op:
-                       if (!access_ok(VERIFY_WRITE, addr, sizeof(*fpr)))
+                       if (!access_ok(addr, sizeof(*fpr)))
                                goto sigbus;
 
                        /*
@@ -1463,7 +1463,7 @@ static void emulate_load_store_microMIPS(struct pt_regs *regs,
                        if (reg == 31)
                                goto sigbus;
 
-                       if (!access_ok(VERIFY_READ, addr, 8))
+                       if (!access_ok(addr, 8))
                                goto sigbus;
 
                        LoadW(addr, value, res);
@@ -1482,7 +1482,7 @@ static void emulate_load_store_microMIPS(struct pt_regs *regs,
                        if (reg == 31)
                                goto sigbus;
 
-                       if (!access_ok(VERIFY_WRITE, addr, 8))
+                       if (!access_ok(addr, 8))
                                goto sigbus;
 
                        value = regs->regs[reg];
@@ -1502,7 +1502,7 @@ static void emulate_load_store_microMIPS(struct pt_regs *regs,
                        if (reg == 31)
                                goto sigbus;
 
-                       if (!access_ok(VERIFY_READ, addr, 16))
+                       if (!access_ok(addr, 16))
                                goto sigbus;
 
                        LoadDW(addr, value, res);
@@ -1525,7 +1525,7 @@ static void emulate_load_store_microMIPS(struct pt_regs *regs,
                        if (reg == 31)
                                goto sigbus;
 
-                       if (!access_ok(VERIFY_WRITE, addr, 16))
+                       if (!access_ok(addr, 16))
                                goto sigbus;
 
                        value = regs->regs[reg];
@@ -1548,11 +1548,10 @@ static void emulate_load_store_microMIPS(struct pt_regs *regs,
                        if ((rvar > 9) || !reg)
                                goto sigill;
                        if (reg & 0x10) {
-                               if (!access_ok
-                                   (VERIFY_READ, addr, 4 * (rvar + 1)))
+                               if (!access_ok(addr, 4 * (rvar + 1)))
                                        goto sigbus;
                        } else {
-                               if (!access_ok(VERIFY_READ, addr, 4 * rvar))
+                               if (!access_ok(addr, 4 * rvar))
                                        goto sigbus;
                        }
                        if (rvar == 9)
@@ -1585,11 +1584,10 @@ static void emulate_load_store_microMIPS(struct pt_regs *regs,
                        if ((rvar > 9) || !reg)
                                goto sigill;
                        if (reg & 0x10) {
-                               if (!access_ok
-                                   (VERIFY_WRITE, addr, 4 * (rvar + 1)))
+                               if (!access_ok(addr, 4 * (rvar + 1)))
                                        goto sigbus;
                        } else {
-                               if (!access_ok(VERIFY_WRITE, addr, 4 * rvar))
+                               if (!access_ok(addr, 4 * rvar))
                                        goto sigbus;
                        }
                        if (rvar == 9)
@@ -1623,11 +1621,10 @@ static void emulate_load_store_microMIPS(struct pt_regs *regs,
                        if ((rvar > 9) || !reg)
                                goto sigill;
                        if (reg & 0x10) {
-                               if (!access_ok
-                                   (VERIFY_READ, addr, 8 * (rvar + 1)))
+                               if (!access_ok(addr, 8 * (rvar + 1)))
                                        goto sigbus;
                        } else {
-                               if (!access_ok(VERIFY_READ, addr, 8 * rvar))
+                               if (!access_ok(addr, 8 * rvar))
                                        goto sigbus;
                        }
                        if (rvar == 9)
@@ -1665,11 +1662,10 @@ static void emulate_load_store_microMIPS(struct pt_regs *regs,
                        if ((rvar > 9) || !reg)
                                goto sigill;
                        if (reg & 0x10) {
-                               if (!access_ok
-                                   (VERIFY_WRITE, addr, 8 * (rvar + 1)))
+                               if (!access_ok(addr, 8 * (rvar + 1)))
                                        goto sigbus;
                        } else {
-                               if (!access_ok(VERIFY_WRITE, addr, 8 * rvar))
+                               if (!access_ok(addr, 8 * rvar))
                                        goto sigbus;
                        }
                        if (rvar == 9)
@@ -1788,7 +1784,7 @@ fpu_emul:
                case mm_lwm16_op:
                        reg = insn.mm16_m_format.rlist;
                        rvar = reg + 1;
-                       if (!access_ok(VERIFY_READ, addr, 4 * rvar))
+                       if (!access_ok(addr, 4 * rvar))
                                goto sigbus;
 
                        for (i = 16; rvar; rvar--, i++) {
@@ -1808,7 +1804,7 @@ fpu_emul:
                case mm_swm16_op:
                        reg = insn.mm16_m_format.rlist;
                        rvar = reg + 1;
-                       if (!access_ok(VERIFY_WRITE, addr, 4 * rvar))
+                       if (!access_ok(addr, 4 * rvar))
                                goto sigbus;
 
                        for (i = 16; rvar; rvar--, i++) {
@@ -1862,7 +1858,7 @@ fpu_emul:
        }
 
 loadHW:
-       if (!access_ok(VERIFY_READ, addr, 2))
+       if (!access_ok(addr, 2))
                goto sigbus;
 
        LoadHW(addr, value, res);
@@ -1872,7 +1868,7 @@ loadHW:
        goto success;
 
 loadHWU:
-       if (!access_ok(VERIFY_READ, addr, 2))
+       if (!access_ok(addr, 2))
                goto sigbus;
 
        LoadHWU(addr, value, res);
@@ -1882,7 +1878,7 @@ loadHWU:
        goto success;
 
 loadW:
-       if (!access_ok(VERIFY_READ, addr, 4))
+       if (!access_ok(addr, 4))
                goto sigbus;
 
        LoadW(addr, value, res);
@@ -1900,7 +1896,7 @@ loadWU:
         * would blow up, so for now we don't handle unaligned 64-bit
         * instructions on 32-bit kernels.
         */
-       if (!access_ok(VERIFY_READ, addr, 4))
+       if (!access_ok(addr, 4))
                goto sigbus;
 
        LoadWU(addr, value, res);
@@ -1922,7 +1918,7 @@ loadDW:
         * would blow up, so for now we don't handle unaligned 64-bit
         * instructions on 32-bit kernels.
         */
-       if (!access_ok(VERIFY_READ, addr, 8))
+       if (!access_ok(addr, 8))
                goto sigbus;
 
        LoadDW(addr, value, res);
@@ -1936,7 +1932,7 @@ loadDW:
        goto sigill;
 
 storeHW:
-       if (!access_ok(VERIFY_WRITE, addr, 2))
+       if (!access_ok(addr, 2))
                goto sigbus;
 
        value = regs->regs[reg];
@@ -1946,7 +1942,7 @@ storeHW:
        goto success;
 
 storeW:
-       if (!access_ok(VERIFY_WRITE, addr, 4))
+       if (!access_ok(addr, 4))
                goto sigbus;
 
        value = regs->regs[reg];
@@ -1964,7 +1960,7 @@ storeDW:
         * would blow up, so for now we don't handle unaligned 64-bit
         * instructions on 32-bit kernels.
         */
-       if (!access_ok(VERIFY_WRITE, addr, 8))
+       if (!access_ok(addr, 8))
                goto sigbus;
 
        value = regs->regs[reg];
@@ -2122,7 +2118,7 @@ static void emulate_load_store_MIPS16e(struct pt_regs *regs, void __user * addr)
                goto sigbus;
 
        case MIPS16e_lh_op:
-               if (!access_ok(VERIFY_READ, addr, 2))
+               if (!access_ok(addr, 2))
                        goto sigbus;
 
                LoadHW(addr, value, res);
@@ -2133,7 +2129,7 @@ static void emulate_load_store_MIPS16e(struct pt_regs *regs, void __user * addr)
                break;
 
        case MIPS16e_lhu_op:
-               if (!access_ok(VERIFY_READ, addr, 2))
+               if (!access_ok(addr, 2))
                        goto sigbus;
 
                LoadHWU(addr, value, res);
@@ -2146,7 +2142,7 @@ static void emulate_load_store_MIPS16e(struct pt_regs *regs, void __user * addr)
        case MIPS16e_lw_op:
        case MIPS16e_lwpc_op:
        case MIPS16e_lwsp_op:
-               if (!access_ok(VERIFY_READ, addr, 4))
+               if (!access_ok(addr, 4))
                        goto sigbus;
 
                LoadW(addr, value, res);
@@ -2165,7 +2161,7 @@ static void emulate_load_store_MIPS16e(struct pt_regs *regs, void __user * addr)
                 * would blow up, so for now we don't handle unaligned 64-bit
                 * instructions on 32-bit kernels.
                 */
-               if (!access_ok(VERIFY_READ, addr, 4))
+               if (!access_ok(addr, 4))
                        goto sigbus;
 
                LoadWU(addr, value, res);
@@ -2189,7 +2185,7 @@ loadDW:
                 * would blow up, so for now we don't handle unaligned 64-bit
                 * instructions on 32-bit kernels.
                 */
-               if (!access_ok(VERIFY_READ, addr, 8))
+               if (!access_ok(addr, 8))
                        goto sigbus;
 
                LoadDW(addr, value, res);
@@ -2204,7 +2200,7 @@ loadDW:
                goto sigill;
 
        case MIPS16e_sh_op:
-               if (!access_ok(VERIFY_WRITE, addr, 2))
+               if (!access_ok(addr, 2))
                        goto sigbus;
 
                MIPS16e_compute_return_epc(regs, &oldinst);
@@ -2217,7 +2213,7 @@ loadDW:
        case MIPS16e_sw_op:
        case MIPS16e_swsp_op:
        case MIPS16e_i8_op:     /* actually - MIPS16e_swrasp_func */
-               if (!access_ok(VERIFY_WRITE, addr, 4))
+               if (!access_ok(addr, 4))
                        goto sigbus;
 
                MIPS16e_compute_return_epc(regs, &oldinst);
@@ -2237,7 +2233,7 @@ writeDW:
                 * would blow up, so for now we don't handle unaligned 64-bit
                 * instructions on 32-bit kernels.
                 */
-               if (!access_ok(VERIFY_WRITE, addr, 8))
+               if (!access_ok(addr, 8))
                        goto sigbus;
 
                MIPS16e_compute_return_epc(regs, &oldinst);
index 82e2993c1a2c49c3fcb31b803abb60642ade1f30..e60e29078ef55cc0cf8f56f24aaa90b6026edbcf 100644 (file)
@@ -1063,7 +1063,7 @@ emul:
                                     MIPSInst_SIMM(ir));
                MIPS_FPU_EMU_INC_STATS(loads);
 
-               if (!access_ok(VERIFY_READ, dva, sizeof(u64))) {
+               if (!access_ok(dva, sizeof(u64))) {
                        MIPS_FPU_EMU_INC_STATS(errors);
                        *fault_addr = dva;
                        return SIGBUS;
@@ -1081,7 +1081,7 @@ emul:
                                      MIPSInst_SIMM(ir));
                MIPS_FPU_EMU_INC_STATS(stores);
                DIFROMREG(dval, MIPSInst_RT(ir));
-               if (!access_ok(VERIFY_WRITE, dva, sizeof(u64))) {
+               if (!access_ok(dva, sizeof(u64))) {
                        MIPS_FPU_EMU_INC_STATS(errors);
                        *fault_addr = dva;
                        return SIGBUS;
@@ -1097,7 +1097,7 @@ emul:
                wva = (u32 __user *) (xcp->regs[MIPSInst_RS(ir)] +
                                      MIPSInst_SIMM(ir));
                MIPS_FPU_EMU_INC_STATS(loads);
-               if (!access_ok(VERIFY_READ, wva, sizeof(u32))) {
+               if (!access_ok(wva, sizeof(u32))) {
                        MIPS_FPU_EMU_INC_STATS(errors);
                        *fault_addr = wva;
                        return SIGBUS;
@@ -1115,7 +1115,7 @@ emul:
                                      MIPSInst_SIMM(ir));
                MIPS_FPU_EMU_INC_STATS(stores);
                SIFROMREG(wval, MIPSInst_RT(ir));
-               if (!access_ok(VERIFY_WRITE, wva, sizeof(u32))) {
+               if (!access_ok(wva, sizeof(u32))) {
                        MIPS_FPU_EMU_INC_STATS(errors);
                        *fault_addr = wva;
                        return SIGBUS;
@@ -1493,7 +1493,7 @@ static int fpux_emu(struct pt_regs *xcp, struct mips_fpu_struct *ctx,
                                xcp->regs[MIPSInst_FT(ir)]);
 
                        MIPS_FPU_EMU_INC_STATS(loads);
-                       if (!access_ok(VERIFY_READ, va, sizeof(u32))) {
+                       if (!access_ok(va, sizeof(u32))) {
                                MIPS_FPU_EMU_INC_STATS(errors);
                                *fault_addr = va;
                                return SIGBUS;
@@ -1513,7 +1513,7 @@ static int fpux_emu(struct pt_regs *xcp, struct mips_fpu_struct *ctx,
                        MIPS_FPU_EMU_INC_STATS(stores);
 
                        SIFROMREG(val, MIPSInst_FS(ir));
-                       if (!access_ok(VERIFY_WRITE, va, sizeof(u32))) {
+                       if (!access_ok(va, sizeof(u32))) {
                                MIPS_FPU_EMU_INC_STATS(errors);
                                *fault_addr = va;
                                return SIGBUS;
@@ -1590,7 +1590,7 @@ static int fpux_emu(struct pt_regs *xcp, struct mips_fpu_struct *ctx,
                                xcp->regs[MIPSInst_FT(ir)]);
 
                        MIPS_FPU_EMU_INC_STATS(loads);
-                       if (!access_ok(VERIFY_READ, va, sizeof(u64))) {
+                       if (!access_ok(va, sizeof(u64))) {
                                MIPS_FPU_EMU_INC_STATS(errors);
                                *fault_addr = va;
                                return SIGBUS;
@@ -1609,7 +1609,7 @@ static int fpux_emu(struct pt_regs *xcp, struct mips_fpu_struct *ctx,
 
                        MIPS_FPU_EMU_INC_STATS(stores);
                        DIFROMREG(val, MIPSInst_FS(ir));
-                       if (!access_ok(VERIFY_WRITE, va, sizeof(u64))) {
+                       if (!access_ok(va, sizeof(u64))) {
                                MIPS_FPU_EMU_INC_STATS(errors);
                                *fault_addr = va;
                                return SIGBUS;
index 70a523151ff39dfa41b330f03c1dd1330838b4f5..55099fbff4e6d783ce184d8a6bb7242c27e1f164 100644 (file)
@@ -76,7 +76,7 @@ SYSCALL_DEFINE3(cacheflush, unsigned long, addr, unsigned long, bytes,
 {
        if (bytes == 0)
                return 0;
-       if (!access_ok(VERIFY_WRITE, (void __user *) addr, bytes))
+       if (!access_ok((void __user *) addr, bytes))
                return -EFAULT;
 
        __flush_icache_user_range(addr, addr + bytes);
index 5a4875cac1ec979da60be7ed3f80379eab5d6b65..0d14e0d8eacf058f49e25be97c1347847af6a137 100644 (file)
@@ -195,8 +195,7 @@ int __get_user_pages_fast(unsigned long start, int nr_pages, int write,
        addr = start;
        len = (unsigned long) nr_pages << PAGE_SHIFT;
        end = start + len;
-       if (unlikely(!access_ok(write ? VERIFY_WRITE : VERIFY_READ,
-                                       (void __user *)start, len)))
+       if (unlikely(!access_ok((void __user *)start, len)))
                return 0;
 
        /*
index 806fb798091f36f7a31d5efdab2e604c812e6ddb..07d98ba7f49e3a12a7c71ab5406d2e974e203e71 100644 (file)
@@ -19,7 +19,7 @@ struct stackframe {
 static inline int get_mem(unsigned long addr, unsigned long *result)
 {
        unsigned long *address = (unsigned long *) addr;
-       if (!access_ok(VERIFY_READ, address, sizeof(unsigned long)))
+       if (!access_ok(address, sizeof(unsigned long)))
                return -1;
        if (__copy_from_user_inatomic(result, address, sizeof(unsigned long)))
                return -3;
index 99c720be72d261abed3ff920f28716cdebafab51..9ff26b0cd3b660d8f31efdf0771e54f30da7fe80 100644 (file)
@@ -458,7 +458,7 @@ static ssize_t sbprof_tb_read(struct file *filp, char *buf,
        char *dest    =  buf;
        long  cur_off = *offp;
 
-       if (!access_ok(VERIFY_WRITE, buf, size))
+       if (!access_ok(buf, size))
                return -EFAULT;
 
        mutex_lock(&sbp.lock);
index cb6cb91cfdf81622dc170286d83803e2d4e7ad73..baf178bf1d0b2aa39ec940bbf833de228adb2882 100644 (file)
@@ -40,7 +40,7 @@ futex_atomic_cmpxchg_inatomic(u32 * uval, u32 __user * uaddr,
        int ret = 0;
        u32 val, tmp, flags;
 
-       if (!access_ok(VERIFY_WRITE, uaddr, sizeof(u32)))
+       if (!access_ok(uaddr, sizeof(u32)))
                return -EFAULT;
 
        smp_mb();
index 362a32d9bd16871e1db6c45d544eb2c4450bfeb5..53dcb49b0b12f5b8a85dd1858f71d3b4a0f23939 100644 (file)
@@ -13,9 +13,6 @@
 #include <asm/types.h>
 #include <linux/mm.h>
 
-#define VERIFY_READ    0
-#define VERIFY_WRITE   1
-
 #define __asmeq(x, y)  ".ifnc " x "," y " ; .err ; .endif\n\t"
 
 /*
@@ -53,7 +50,7 @@ static inline void set_fs(mm_segment_t fs)
 
 #define __range_ok(addr, size) (size <= get_fs() && addr <= (get_fs() -size))
 
-#define access_ok(type, addr, size)    \
+#define access_ok(addr, size)  \
        __range_ok((unsigned long)addr, (unsigned long)size)
 /*
  * Single-value transfer routines.  They automatically use the right
@@ -94,7 +91,7 @@ static inline void set_fs(mm_segment_t fs)
 ({                                                                     \
        const __typeof__(*(ptr)) __user *__p = (ptr);                   \
        might_fault();                                                  \
-       if (access_ok(VERIFY_READ, __p, sizeof(*__p))) {                \
+       if (access_ok(__p, sizeof(*__p))) {             \
                __get_user_err((x), __p, (err));                        \
        } else {                                                        \
                (x) = 0; (err) = -EFAULT;                               \
@@ -189,7 +186,7 @@ do {                                                                        \
 ({                                                                     \
        __typeof__(*(ptr)) __user *__p = (ptr);                         \
        might_fault();                                                  \
-       if (access_ok(VERIFY_WRITE, __p, sizeof(*__p))) {               \
+       if (access_ok(__p, sizeof(*__p))) {             \
                __put_user_err((x), __p, (err));                        \
        } else  {                                                       \
                (err) = -EFAULT;                                        \
@@ -279,7 +276,7 @@ extern unsigned long __arch_copy_to_user(void __user * to, const void *from,
 #define INLINE_COPY_TO_USER
 static inline unsigned long clear_user(void __user * to, unsigned long n)
 {
-       if (access_ok(VERIFY_WRITE, to, n))
+       if (access_ok(to, n))
                n = __arch_clear_user(to, n);
        return n;
 }
index 5e00ce54d0ff33ec399cc1bb421cc393c81afb73..334c2a6cec23ddc1df7458737c15a4673159eef7 100644 (file)
@@ -1306,7 +1306,7 @@ user_backtrace(struct perf_callchain_entry_ctx *entry, unsigned long fp)
                (unsigned long *)(fp - (unsigned long)sizeof(buftail));
 
        /* Check accessibility of one struct frame_tail beyond */
-       if (!access_ok(VERIFY_READ, user_frame_tail, sizeof(buftail)))
+       if (!access_ok(user_frame_tail, sizeof(buftail)))
                return 0;
        if (__copy_from_user_inatomic
                (&buftail, user_frame_tail, sizeof(buftail)))
@@ -1332,7 +1332,7 @@ user_backtrace_opt_size(struct perf_callchain_entry_ctx *entry,
                (unsigned long *)(fp - (unsigned long)sizeof(buftail));
 
        /* Check accessibility of one struct frame_tail beyond */
-       if (!access_ok(VERIFY_READ, user_frame_tail, sizeof(buftail)))
+       if (!access_ok(user_frame_tail, sizeof(buftail)))
                return 0;
        if (__copy_from_user_inatomic
                (&buftail, user_frame_tail, sizeof(buftail)))
@@ -1386,7 +1386,7 @@ perf_callchain_user(struct perf_callchain_entry_ctx *entry,
                user_frame_tail =
                        (unsigned long *)(fp - (unsigned long)sizeof(fp));
 
-               if (!access_ok(VERIFY_READ, user_frame_tail, sizeof(fp)))
+               if (!access_ok(user_frame_tail, sizeof(fp)))
                        return;
 
                if (__copy_from_user_inatomic
@@ -1406,8 +1406,7 @@ perf_callchain_user(struct perf_callchain_entry_ctx *entry,
                                (unsigned long *)(fp -
                                        (unsigned long)sizeof(buftail));
 
-                       if (!access_ok
-                               (VERIFY_READ, user_frame_tail, sizeof(buftail)))
+                       if (!access_ok(user_frame_tail, sizeof(buftail)))
                                return;
 
                        if (__copy_from_user_inatomic
@@ -1424,7 +1423,7 @@ perf_callchain_user(struct perf_callchain_entry_ctx *entry,
                                        (unsigned long *)(fp - (unsigned long)
                                                sizeof(buftail_opt_size));
 
-                               if (!access_ok(VERIFY_READ, user_frame_tail,
+                               if (!access_ok(user_frame_tail,
                                               sizeof(buftail_opt_size)))
                                        return;
 
index 5b5be082cfa40896b21fc4c7c2115a70066fef3d..5f7660aa2d68a7904e68d9b8ad5ad5a5389d53b2 100644 (file)
@@ -151,7 +151,7 @@ asmlinkage long sys_rt_sigreturn(struct pt_regs *regs)
 
        frame = (struct rt_sigframe __user *)regs->sp;
 
-       if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
+       if (!access_ok(frame, sizeof(*frame)))
                goto badframe;
 
        if (restore_sigframe(regs, frame))
@@ -275,7 +275,7 @@ setup_rt_frame(struct ksignal *ksig, sigset_t * set, struct pt_regs *regs)
            get_sigframe(ksig, regs, sizeof(*frame));
        int err = 0;
 
-       if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+       if (!access_ok(frame, sizeof(*frame)))
                return -EFAULT;
 
        __put_user_error(0, &frame->uc.uc_flags, err);
index e1aed9dc692dd3bac752720a82880de865e7cb2d..c8b9061a2ee3d58f713dfa6194e0e9d82bd71ce0 100644 (file)
@@ -289,13 +289,13 @@ static inline int do_16(unsigned long inst, struct pt_regs *regs)
                unaligned_addr += shift;
 
        if (load) {
-               if (!access_ok(VERIFY_READ, (void *)unaligned_addr, len))
+               if (!access_ok((void *)unaligned_addr, len))
                        return -EACCES;
 
                get_data(unaligned_addr, &target_val, len);
                *idx_to_addr(regs, target_idx) = target_val;
        } else {
-               if (!access_ok(VERIFY_WRITE, (void *)unaligned_addr, len))
+               if (!access_ok((void *)unaligned_addr, len))
                        return -EACCES;
                target_val = *idx_to_addr(regs, target_idx);
                set_data((void *)unaligned_addr, target_val, len);
@@ -479,7 +479,7 @@ static inline int do_32(unsigned long inst, struct pt_regs *regs)
 
        if (load) {
 
-               if (!access_ok(VERIFY_READ, (void *)unaligned_addr, len))
+               if (!access_ok((void *)unaligned_addr, len))
                        return -EACCES;
 
                get_data(unaligned_addr, &target_val, len);
@@ -491,7 +491,7 @@ static inline int do_32(unsigned long inst, struct pt_regs *regs)
                        *idx_to_addr(regs, RT(inst)) = target_val;
        } else {
 
-               if (!access_ok(VERIFY_WRITE, (void *)unaligned_addr, len))
+               if (!access_ok((void *)unaligned_addr, len))
                        return -EACCES;
 
                target_val = *idx_to_addr(regs, RT(inst));
index dfa3c7cb30b47cf3b8acd981af49d658d3adb3a8..e0ea10806491f47f8e9e7b21b8edd938881b1b5b 100644 (file)
@@ -37,7 +37,7 @@
        (((signed long)(((long)get_fs().seg) &  \
                ((long)(addr) | (((long)(addr)) + (len)) | (len)))) == 0)
 
-#define access_ok(type, addr, len)             \
+#define access_ok(addr, len)           \
        likely(__access_ok((unsigned long)(addr), (unsigned long)(len)))
 
 # define __EX_TABLE_SECTION    ".section __ex_table,\"a\"\n"
@@ -70,7 +70,7 @@ static inline unsigned long __must_check __clear_user(void __user *to,
 static inline unsigned long __must_check clear_user(void __user *to,
                                                    unsigned long n)
 {
-       if (!access_ok(VERIFY_WRITE, to, n))
+       if (!access_ok(to, n))
                return n;
        return __clear_user(to, n);
 }
@@ -142,7 +142,7 @@ do {                                                                        \
        long __gu_err = -EFAULT;                                        \
        const __typeof__(*(ptr)) __user *__gu_ptr = (ptr);              \
        unsigned long __gu_val = 0;                                     \
-       if (access_ok(VERIFY_READ,  __gu_ptr, sizeof(*__gu_ptr)))       \
+       if (access_ok( __gu_ptr, sizeof(*__gu_ptr)))    \
                __get_user_common(__gu_val, sizeof(*__gu_ptr),          \
                        __gu_ptr, __gu_err);                            \
        (x) = (__force __typeof__(x))__gu_val;                          \
@@ -168,7 +168,7 @@ do {                                                                        \
        long __pu_err = -EFAULT;                                        \
        __typeof__(*(ptr)) __user *__pu_ptr = (ptr);                    \
        __typeof__(*(ptr)) __pu_val = (__typeof(*ptr))(x);              \
-       if (access_ok(VERIFY_WRITE, __pu_ptr, sizeof(*__pu_ptr))) {     \
+       if (access_ok(__pu_ptr, sizeof(*__pu_ptr))) {   \
                switch (sizeof(*__pu_ptr)) {                            \
                case 1:                                                 \
                        __put_user_asm(__pu_val, "stb", __pu_ptr, __pu_err); \
index 20662b0f6c9e30cd52279ce3274bcbc463fa5236..4a81876b6086e57fb066e74817d976c74cdb1a23 100644 (file)
@@ -106,7 +106,7 @@ asmlinkage int do_rt_sigreturn(struct switch_stack *sw)
        sigset_t set;
        int rval;
 
-       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)))
index 618da4a1bffb9a54aa48daf8942324ea59d7e96f..fe894e6331aedb7c517eba144318494ab3ac623a 100644 (file)
@@ -72,7 +72,7 @@ futex_atomic_cmpxchg_inatomic(u32 *uval, u32 __user *uaddr,
        int ret = 0;
        u32 prev;
 
-       if (!access_ok(VERIFY_WRITE, uaddr, sizeof(u32)))
+       if (!access_ok(uaddr, sizeof(u32)))
                return -EFAULT;
 
        __asm__ __volatile__ (                          \
index bbf5c79cce7a30832422c1a290e895074fab1042..bc8191a34db7889ef816676b19b643abf1494536 100644 (file)
@@ -58,7 +58,7 @@
 /* Ensure that addr is below task's addr_limit */
 #define __addr_ok(addr) ((unsigned long) addr < get_fs())
 
-#define access_ok(type, addr, size) \
+#define access_ok(addr, size) \
        __range_ok((unsigned long)addr, (unsigned long)size)
 
 /*
@@ -102,7 +102,7 @@ extern long __put_user_bad(void);
 ({                                                                     \
        long __pu_err = -EFAULT;                                        \
        __typeof__(*(ptr)) *__pu_addr = (ptr);                          \
-       if (access_ok(VERIFY_WRITE, __pu_addr, size))                   \
+       if (access_ok(__pu_addr, size))                 \
                __put_user_size((x), __pu_addr, (size), __pu_err);      \
        __pu_err;                                                       \
 })
@@ -175,7 +175,7 @@ struct __large_struct {
 ({                                                                     \
        long __gu_err = -EFAULT, __gu_val = 0;                          \
        const __typeof__(*(ptr)) * __gu_addr = (ptr);                   \
-       if (access_ok(VERIFY_READ, __gu_addr, size))                    \
+       if (access_ok(__gu_addr, size))                 \
                __get_user_size(__gu_val, __gu_addr, (size), __gu_err); \
        (x) = (__force __typeof__(*(ptr)))__gu_val;                     \
        __gu_err;                                                       \
@@ -254,7 +254,7 @@ extern unsigned long __clear_user(void *addr, unsigned long size);
 static inline __must_check unsigned long
 clear_user(void *addr, unsigned long size)
 {
-       if (likely(access_ok(VERIFY_WRITE, addr, size)))
+       if (likely(access_ok(addr, size)))
                size = __clear_user(addr, size);
        return size;
 }
index 265f10fb393071a7264d350a8e88d3d498354cd0..5ac9d3b1d6158ba166c382ee70264613e763598d 100644 (file)
@@ -50,7 +50,7 @@ static int restore_sigcontext(struct pt_regs *regs,
 
        /*
         * Restore the regs from &sc->regs.
-        * (sc is already checked for VERIFY_READ since the sigframe was
+        * (sc is already checked since the sigframe was
         *  checked in sys_sigreturn previously)
         */
        err |= __copy_from_user(regs, sc->regs.gpr, 32 * sizeof(unsigned long));
@@ -83,7 +83,7 @@ asmlinkage long _sys_rt_sigreturn(struct pt_regs *regs)
        if (((long)frame) & 3)
                goto badframe;
 
-       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;
@@ -161,7 +161,7 @@ static int setup_rt_frame(struct ksignal *ksig, sigset_t *set,
 
        frame = get_sigframe(ksig, regs, sizeof(*frame));
 
-       if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+       if (!access_ok(frame, sizeof(*frame)))
                return -EFAULT;
 
        /* Create siginfo.  */
index cf7ba058f619a94d25d3d26ca7dfc3da27c91290..d2c3e410685188d24d54263f08c3c7c35c154053 100644 (file)
@@ -95,7 +95,7 @@ futex_atomic_cmpxchg_inatomic(u32 *uval, u32 __user *uaddr,
        if (uaccess_kernel() && !uaddr)
                return -EFAULT;
 
-       if (!access_ok(VERIFY_WRITE, uaddr, sizeof(u32)))
+       if (!access_ok(uaddr, sizeof(u32)))
                return -EFAULT;
 
        /* HPPA has no cmpxchg in hardware and therefore the
index ea70e36ce6af52e5fe4b244ee61ce0769d7b6e93..30ac2865ea730cdf650efd7ca993cfd6daa79d2e 100644 (file)
@@ -27,7 +27,7 @@
  * that put_user is the same as __put_user, etc.
  */
 
-#define access_ok(type, uaddr, size)   \
+#define access_ok(uaddr, size) \
        ( (uaddr) == (uaddr) )
 
 #define put_user __put_user
index 94542776a62d630f6c9037e28264fc371d839245..88b38b37c21b160e2dbe43da5894f145ee6a4043 100644 (file)
@@ -72,7 +72,7 @@ futex_atomic_cmpxchg_inatomic(u32 *uval, u32 __user *uaddr,
        int ret = 0;
        u32 prev;
 
-       if (!access_ok(VERIFY_WRITE, uaddr, sizeof(u32)))
+       if (!access_ok(uaddr, sizeof(u32)))
                return -EFAULT;
 
         __asm__ __volatile__ (
index ebc0b916dcf9047b5ec00d597a8d01137aef93de..b31bf45eebd49ddce0c6fa46da8691ffb5a70bf1 100644 (file)
@@ -62,7 +62,7 @@ static inline int __access_ok(unsigned long addr, unsigned long size,
 
 #endif
 
-#define access_ok(type, addr, size)            \
+#define access_ok(addr, size)          \
        (__chk_user_ptr(addr), (void)(type),            \
         __access_ok((__force unsigned long)(addr), (size), get_fs()))
 
@@ -166,7 +166,7 @@ do {                                                                \
        long __pu_err = -EFAULT;                                        \
        __typeof__(*(ptr)) __user *__pu_addr = (ptr);                   \
        might_fault();                                                  \
-       if (access_ok(VERIFY_WRITE, __pu_addr, size))                   \
+       if (access_ok(__pu_addr, size))                 \
                __put_user_size((x), __pu_addr, (size), __pu_err);      \
        __pu_err;                                                       \
 })
@@ -276,7 +276,7 @@ do {                                                                \
        __long_type(*(ptr)) __gu_val = 0;                               \
        __typeof__(*(ptr)) __user *__gu_addr = (ptr);           \
        might_fault();                                                  \
-       if (access_ok(VERIFY_READ, __gu_addr, (size))) {                \
+       if (access_ok(__gu_addr, (size))) {             \
                barrier_nospec();                                       \
                __get_user_size(__gu_val, __gu_addr, (size), __gu_err); \
        }                                                               \
@@ -374,7 +374,7 @@ extern unsigned long __clear_user(void __user *addr, unsigned long size);
 static inline unsigned long clear_user(void __user *addr, unsigned long size)
 {
        might_fault();
-       if (likely(access_ok(VERIFY_WRITE, addr, size)))
+       if (likely(access_ok(addr, size)))
                return __clear_user(addr, size);
        return size;
 }
index 11550a3d1ac2e8c5cf092de7f4a849d4a3439d32..0d1b6370bae00bb1ce44442c19b8480e2a0b1d6e 100644 (file)
@@ -131,8 +131,7 @@ static int emulate_spe(struct pt_regs *regs, unsigned int reg,
 
        /* Verify the address of the operand */
        if (unlikely(user_mode(regs) &&
-                    !access_ok((flags & ST ? VERIFY_WRITE : VERIFY_READ),
-                               addr, nb)))
+                    !access_ok(addr, nb)))
                return -EFAULT;
 
        /* userland only */
index 10fabae2574d5910b3cbf5ada83d912879d71351..8246f437bbc69b7bf2fdcda32e18fc6ebfe85a06 100644 (file)
@@ -523,7 +523,7 @@ static ssize_t validate_flash_write(struct file *file, const char __user *buf,
                args_buf->status = VALIDATE_INCOMPLETE;
        }
 
-       if (!access_ok(VERIFY_READ, buf, count)) {
+       if (!access_ok(buf, count)) {
                rc = -EFAULT;
                goto done;
        }
index 38cadae4ca4f70436fdd865b602f078d390d3ba8..8a1746d755c90b0e5d90bcfb7da6a7b8550c9a0a 100644 (file)
@@ -335,7 +335,7 @@ static ssize_t rtas_log_read(struct file * file, char __user * buf,
 
        count = rtas_error_log_buffer_max;
 
-       if (!access_ok(VERIFY_WRITE, buf, count))
+       if (!access_ok(buf, count))
                return -EFAULT;
 
        tmp = kmalloc(count, GFP_KERNEL);
index b3e8db376ecde459bb8b5a1cd00b10c9606df289..e6c30cee6abf1748e52fe5a4ae9a0fbc01c3274a 100644 (file)
@@ -44,7 +44,7 @@ void __user *get_sigframe(struct ksignal *ksig, unsigned long sp,
        newsp = (oldsp - frame_size) & ~0xFUL;
 
        /* Check access */
-       if (!access_ok(VERIFY_WRITE, (void __user *)newsp, oldsp - newsp))
+       if (!access_ok((void __user *)newsp, oldsp - newsp))
                return NULL;
 
         return (void __user *)newsp;
index 2d47cc79e5b3f332ab71dc9c4bb19c524c74644f..ede4f04281ae01ef36537b421504b297149fd6d9 100644 (file)
@@ -1017,7 +1017,7 @@ static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int
 #else
        if (__get_user(mcp, &ucp->uc_regs))
                return -EFAULT;
-       if (!access_ok(VERIFY_READ, mcp, sizeof(*mcp)))
+       if (!access_ok(mcp, sizeof(*mcp)))
                return -EFAULT;
 #endif
        set_current_blocked(&set);
@@ -1120,7 +1120,7 @@ SYSCALL_DEFINE3(swapcontext, struct ucontext __user *, old_ctx,
                 */
                mctx = (struct mcontext __user *)
                        ((unsigned long) &old_ctx->uc_mcontext & ~0xfUL);
-               if (!access_ok(VERIFY_WRITE, old_ctx, ctx_size)
+               if (!access_ok(old_ctx, ctx_size)
                    || save_user_regs(regs, mctx, NULL, 0, ctx_has_vsx_region)
                    || put_sigset_t(&old_ctx->uc_sigmask, &current->blocked)
                    || __put_user(to_user_ptr(mctx), &old_ctx->uc_regs))
@@ -1128,7 +1128,7 @@ SYSCALL_DEFINE3(swapcontext, struct ucontext __user *, old_ctx,
        }
        if (new_ctx == NULL)
                return 0;
-       if (!access_ok(VERIFY_READ, new_ctx, ctx_size) ||
+       if (!access_ok(new_ctx, ctx_size) ||
            fault_in_pages_readable((u8 __user *)new_ctx, ctx_size))
                return -EFAULT;
 
@@ -1169,7 +1169,7 @@ SYSCALL_DEFINE0(rt_sigreturn)
 
        rt_sf = (struct rt_sigframe __user *)
                (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16);
-       if (!access_ok(VERIFY_READ, rt_sf, sizeof(*rt_sf)))
+       if (!access_ok(rt_sf, sizeof(*rt_sf)))
                goto bad;
 
 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
@@ -1315,7 +1315,7 @@ SYSCALL_DEFINE3(debug_setcontext, struct ucontext __user *, ctx,
        current->thread.debug.dbcr0 = new_dbcr0;
 #endif
 
-       if (!access_ok(VERIFY_READ, ctx, sizeof(*ctx)) ||
+       if (!access_ok(ctx, sizeof(*ctx)) ||
            fault_in_pages_readable((u8 __user *)ctx, sizeof(*ctx)))
                return -EFAULT;
 
@@ -1500,7 +1500,7 @@ SYSCALL_DEFINE0(sigreturn)
        {
                sr = (struct mcontext __user *)from_user_ptr(sigctx.regs);
                addr = sr;
-               if (!access_ok(VERIFY_READ, sr, sizeof(*sr))
+               if (!access_ok(sr, sizeof(*sr))
                    || restore_user_regs(regs, sr, 1))
                        goto badframe;
        }
index 0935fe6c282a54b0fd6a86332a16b282a1d36c1b..bd5e6834ca6928c54a627a470dd1932fd4f91497 100644 (file)
@@ -383,7 +383,7 @@ static long restore_sigcontext(struct task_struct *tsk, sigset_t *set, int sig,
        err |= __get_user(v_regs, &sc->v_regs);
        if (err)
                return err;
-       if (v_regs && !access_ok(VERIFY_READ, v_regs, 34 * sizeof(vector128)))
+       if (v_regs && !access_ok(v_regs, 34 * sizeof(vector128)))
                return -EFAULT;
        /* Copy 33 vec registers (vr0..31 and vscr) from the stack */
        if (v_regs != NULL && (msr & MSR_VEC) != 0) {
@@ -502,10 +502,9 @@ static long restore_tm_sigcontexts(struct task_struct *tsk,
        err |= __get_user(tm_v_regs, &tm_sc->v_regs);
        if (err)
                return err;
-       if (v_regs && !access_ok(VERIFY_READ, v_regs, 34 * sizeof(vector128)))
+       if (v_regs && !access_ok(v_regs, 34 * sizeof(vector128)))
                return -EFAULT;
-       if (tm_v_regs && !access_ok(VERIFY_READ,
-                                   tm_v_regs, 34 * sizeof(vector128)))
+       if (tm_v_regs && !access_ok(tm_v_regs, 34 * sizeof(vector128)))
                return -EFAULT;
        /* Copy 33 vec registers (vr0..31 and vscr) from the stack */
        if (v_regs != NULL && tm_v_regs != NULL && (msr & MSR_VEC) != 0) {
@@ -671,7 +670,7 @@ SYSCALL_DEFINE3(swapcontext, struct ucontext __user *, old_ctx,
                ctx_has_vsx_region = 1;
 
        if (old_ctx != NULL) {
-               if (!access_ok(VERIFY_WRITE, old_ctx, ctx_size)
+               if (!access_ok(old_ctx, ctx_size)
                    || setup_sigcontext(&old_ctx->uc_mcontext, current, 0, NULL, 0,
                                        ctx_has_vsx_region)
                    || __copy_to_user(&old_ctx->uc_sigmask,
@@ -680,7 +679,7 @@ SYSCALL_DEFINE3(swapcontext, struct ucontext __user *, old_ctx,
        }
        if (new_ctx == NULL)
                return 0;
-       if (!access_ok(VERIFY_READ, new_ctx, ctx_size)
+       if (!access_ok(new_ctx, ctx_size)
            || __get_user(tmp, (u8 __user *) new_ctx)
            || __get_user(tmp, (u8 __user *) new_ctx + ctx_size - 1))
                return -EFAULT;
@@ -725,7 +724,7 @@ SYSCALL_DEFINE0(rt_sigreturn)
        /* Always make any pending restarted system calls return -EINTR */
        current->restart_block.fn = do_no_restart_syscall;
 
-       if (!access_ok(VERIFY_READ, uc, sizeof(*uc)))
+       if (!access_ok(uc, sizeof(*uc)))
                goto badframe;
 
        if (__copy_from_user(&set, &uc->uc_sigmask, sizeof(set)))
index 466216506eb2f4bfa7b6b94ed89140914b1ea682..e6982ab2181663037b210b24f697d8a1bb52e269 100644 (file)
@@ -89,7 +89,7 @@ ppc_select(int n, fd_set __user *inp, fd_set __user *outp, fd_set __user *exp, s
        if ( (unsigned long)n >= 4096 )
        {
                unsigned long __user *buffer = (unsigned long __user *)n;
-               if (!access_ok(VERIFY_READ, buffer, 5*sizeof(unsigned long))
+               if (!access_ok(buffer, 5*sizeof(unsigned long))
                    || __get_user(n, buffer)
                    || __get_user(inp, ((fd_set __user * __user *)(buffer+1)))
                    || __get_user(outp, ((fd_set  __user * __user *)(buffer+2)))
index 00af2c4febf4877fd30e41e73a830723e91e68fa..64936b60d5216e185670ebbb3424be395fe740d9 100644 (file)
@@ -837,7 +837,7 @@ static void p9_hmi_special_emu(struct pt_regs *regs)
        addr = (__force const void __user *)ea;
 
        /* Check it */
-       if (!access_ok(VERIFY_READ, addr, 16)) {
+       if (!access_ok(addr, 16)) {
                pr_devel("HMI vec emu: bad access %i:%s[%d] nip=%016lx"
                         " instr=%08x addr=%016lx\n",
                         smp_processor_id(), current->comm, current->pid,
index 6f2d2fb4e0982237ba2b1ca0daa778bab6fc7ae7..bd2dcfbf00cdb1cc6a20a766bb68bf17d9f5e3dc 100644 (file)
@@ -1744,7 +1744,7 @@ static ssize_t kvm_htab_read(struct file *file, char __user *buf,
        int first_pass;
        unsigned long hpte[2];
 
-       if (!access_ok(VERIFY_WRITE, buf, count))
+       if (!access_ok(buf, count))
                return -EFAULT;
        if (kvm_is_radix(kvm))
                return 0;
@@ -1844,7 +1844,7 @@ static ssize_t kvm_htab_write(struct file *file, const char __user *buf,
        int mmu_ready;
        int pshift;
 
-       if (!access_ok(VERIFY_READ, buf, count))
+       if (!access_ok(buf, count))
                return -EFAULT;
        if (kvm_is_radix(kvm))
                return -EINVAL;
index a0cb63fb76a1ada4b6ab727533c62e0cc681e33c..890d4ddd91d619c33d21f41f7b39db7621ec443c 100644 (file)
@@ -37,7 +37,7 @@ __wsum csum_and_copy_from_user(const void __user *src, void *dst,
                goto out;
        }
 
-       if (unlikely((len < 0) || !access_ok(VERIFY_READ, src, len))) {
+       if (unlikely((len < 0) || !access_ok(src, len))) {
                *err_ptr = -EFAULT;
                csum = (__force unsigned int)sum;
                goto out;
@@ -78,7 +78,7 @@ __wsum csum_and_copy_to_user(const void *src, void __user *dst, int len,
                goto out;
        }
 
-       if (unlikely((len < 0) || !access_ok(VERIFY_WRITE, dst, len))) {
+       if (unlikely((len < 0) || !access_ok(dst, len))) {
                *err_ptr = -EFAULT;
                csum = -1; /* invalid checksum */
                goto out;
index a6dcfda3e11e675c544f5523be1b86858f741f2a..887f11bcf3300a638d15c926ac91b883346fd569 100644 (file)
@@ -274,7 +274,7 @@ static bool bad_stack_expansion(struct pt_regs *regs, unsigned long address,
                        return false;
 
                if ((flags & FAULT_FLAG_WRITE) && (flags & FAULT_FLAG_USER) &&
-                   access_ok(VERIFY_READ, nip, sizeof(*nip))) {
+                   access_ok(nip, sizeof(*nip))) {
                        unsigned int inst;
                        int res;
 
index 3327551c8b47ceb693e40b4da4f7a068a7d63fcc..5e4178790deef77d7edebd8601113c4c96829e9c 100644 (file)
@@ -214,7 +214,7 @@ SYSCALL_DEFINE3(subpage_prot, unsigned long, addr,
                return 0;
        }
 
-       if (!access_ok(VERIFY_READ, map, (len >> PAGE_SHIFT) * sizeof(u32)))
+       if (!access_ok(map, (len >> PAGE_SHIFT) * sizeof(u32)))
                return -EFAULT;
 
        down_write(&mm->mmap_sem);
index 5df6290d1ccc02fed2ba71d14ec9c06017046f3c..260c5370097880e4e8f2a274c17d3f0276ea4b57 100644 (file)
@@ -31,7 +31,7 @@ static unsigned int user_getsp32(unsigned int sp, int is_first)
        unsigned int stack_frame[2];
        void __user *p = compat_ptr(sp);
 
-       if (!access_ok(VERIFY_READ, p, sizeof(stack_frame)))
+       if (!access_ok(p, sizeof(stack_frame)))
                return 0;
 
        /*
@@ -57,7 +57,7 @@ static unsigned long user_getsp64(unsigned long sp, int is_first)
 {
        unsigned long stack_frame[3];
 
-       if (!access_ok(VERIFY_READ, (void __user *)sp, sizeof(stack_frame)))
+       if (!access_ok((void __user *)sp, sizeof(stack_frame)))
                return 0;
 
        if (__copy_from_user_inatomic(stack_frame, (void __user *)sp,
index 43e7b93f27c71c609d75b96089aa4e34d958a899..ae8123edddc670ed2b413129ee8a97aade121200 100644 (file)
@@ -609,7 +609,7 @@ static ssize_t spufs_mbox_read(struct file *file, char __user *buf,
        if (len < 4)
                return -EINVAL;
 
-       if (!access_ok(VERIFY_WRITE, buf, len))
+       if (!access_ok(buf, len))
                return -EFAULT;
 
        udata = (void __user *)buf;
@@ -717,7 +717,7 @@ static ssize_t spufs_ibox_read(struct file *file, char __user *buf,
        if (len < 4)
                return -EINVAL;
 
-       if (!access_ok(VERIFY_WRITE, buf, len))
+       if (!access_ok(buf, len))
                return -EFAULT;
 
        udata = (void __user *)buf;
@@ -856,7 +856,7 @@ static ssize_t spufs_wbox_write(struct file *file, const char __user *buf,
                return -EINVAL;
 
        udata = (void __user *)buf;
-       if (!access_ok(VERIFY_READ, buf, len))
+       if (!access_ok(buf, len))
                return -EFAULT;
 
        if (__get_user(wbox_data, udata))
@@ -1994,7 +1994,7 @@ static ssize_t spufs_mbox_info_read(struct file *file, char __user *buf,
        int ret;
        struct spu_context *ctx = file->private_data;
 
-       if (!access_ok(VERIFY_WRITE, buf, len))
+       if (!access_ok(buf, len))
                return -EFAULT;
 
        ret = spu_acquire_saved(ctx);
@@ -2034,7 +2034,7 @@ static ssize_t spufs_ibox_info_read(struct file *file, char __user *buf,
        struct spu_context *ctx = file->private_data;
        int ret;
 
-       if (!access_ok(VERIFY_WRITE, buf, len))
+       if (!access_ok(buf, len))
                return -EFAULT;
 
        ret = spu_acquire_saved(ctx);
@@ -2077,7 +2077,7 @@ static ssize_t spufs_wbox_info_read(struct file *file, char __user *buf,
        struct spu_context *ctx = file->private_data;
        int ret;
 
-       if (!access_ok(VERIFY_WRITE, buf, len))
+       if (!access_ok(buf, len))
                return -EFAULT;
 
        ret = spu_acquire_saved(ctx);
@@ -2129,7 +2129,7 @@ static ssize_t spufs_dma_info_read(struct file *file, char __user *buf,
        struct spu_context *ctx = file->private_data;
        int ret;
 
-       if (!access_ok(VERIFY_WRITE, buf, len))
+       if (!access_ok(buf, len))
                return -EFAULT;
 
        ret = spu_acquire_saved(ctx);
@@ -2160,7 +2160,7 @@ static ssize_t __spufs_proxydma_info_read(struct spu_context *ctx,
        if (len < ret)
                return -EINVAL;
 
-       if (!access_ok(VERIFY_WRITE, buf, len))
+       if (!access_ok(buf, len))
                return -EFAULT;
 
        info.proxydma_info_type = ctx->csa.prob.dma_querytype_RW;
index 6c7ad1d8b32edad20154322a246385aea42ee244..2623996a193ab292cab4c9e37bf0dcf3824cc414 100644 (file)
@@ -192,7 +192,7 @@ static ssize_t lpc_debug_read(struct file *filp, char __user *ubuf,
        u32 data, pos, len, todo;
        int rc;
 
-       if (!access_ok(VERIFY_WRITE, ubuf, count))
+       if (!access_ok(ubuf, count))
                return -EFAULT;
 
        todo = count;
@@ -283,7 +283,7 @@ static ssize_t lpc_debug_write(struct file *filp, const char __user *ubuf,
        u32 data, pos, len, todo;
        int rc;
 
-       if (!access_ok(VERIFY_READ, ubuf, count))
+       if (!access_ok(ubuf, count))
                return -EFAULT;
 
        todo = count;
index 054ce7a16fc336b42b1c05243be5a45a68b91d5a..24b157e1e89020de3c881187bbc3b96ea643b9dd 100644 (file)
@@ -63,7 +63,7 @@ static ssize_t scanlog_read(struct file *file, char __user *buf,
                return -EINVAL;
        }
 
-       if (!access_ok(VERIFY_WRITE, buf, count))
+       if (!access_ok(buf, count))
                return -EFAULT;
 
        for (;;) {
index 3b19eba1bc8e24a65278a5be5a2a4d06cf8c8e47..66641624d8a5e0ff915f04e0461c124a1decddc6 100644 (file)
@@ -95,7 +95,7 @@ futex_atomic_cmpxchg_inatomic(u32 *uval, u32 __user *uaddr,
        u32 val;
        uintptr_t tmp;
 
-       if (!access_ok(VERIFY_WRITE, uaddr, sizeof(u32)))
+       if (!access_ok(uaddr, sizeof(u32)))
                return -EFAULT;
 
        __enable_user_access();
index 8c3e3e3c8be1204b67076985a9b54e80217707b1..637b896894fc4380ad19e8f96fa0d76e35da7b69 100644 (file)
@@ -54,14 +54,8 @@ static inline void set_fs(mm_segment_t fs)
 #define user_addr_max()        (get_fs())
 
 
-#define VERIFY_READ    0
-#define VERIFY_WRITE   1
-
 /**
  * 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
  *
@@ -76,7 +70,7 @@ static inline void set_fs(mm_segment_t fs)
  * 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) ({                                       \
        __chk_user_ptr(addr);                                           \
        likely(__access_ok((unsigned long __force)(addr), (size)));     \
 })
@@ -258,7 +252,7 @@ do {                                                                \
 ({                                                             \
        const __typeof__(*(ptr)) __user *__p = (ptr);           \
        might_fault();                                          \
-       access_ok(VERIFY_READ, __p, sizeof(*__p)) ?             \
+       access_ok(__p, sizeof(*__p)) ?          \
                __get_user((x), __p) :                          \
                ((x) = 0, -EFAULT);                             \
 })
@@ -386,7 +380,7 @@ do {                                                                \
 ({                                                             \
        __typeof__(*(ptr)) __user *__p = (ptr);                 \
        might_fault();                                          \
-       access_ok(VERIFY_WRITE, __p, sizeof(*__p)) ?            \
+       access_ok(__p, sizeof(*__p)) ?          \
                __put_user((x), __p) :                          \
                -EFAULT;                                        \
 })
@@ -421,7 +415,7 @@ static inline
 unsigned long __must_check clear_user(void __user *to, unsigned long n)
 {
        might_fault();
-       return access_ok(VERIFY_WRITE, to, n) ?
+       return access_ok(to, n) ?
                __clear_user(to, n) : n;
 }
 
index f9b5e7e352ef7c489a582edf4982cfddeb1e457a..837e1646091a83ecb81feda8ddefb4b5914cdce8 100644 (file)
@@ -115,7 +115,7 @@ SYSCALL_DEFINE0(rt_sigreturn)
 
        frame = (struct rt_sigframe __user *)regs->sp;
 
-       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)))
@@ -187,7 +187,7 @@ static int setup_rt_frame(struct ksignal *ksig, sigset_t *set,
        long err = 0;
 
        frame = get_sigframe(ksig, regs, sizeof(*frame));
-       if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+       if (!access_ok(frame, sizeof(*frame)))
                return -EFAULT;
 
        err |= copy_siginfo_to_user(&frame->info, &ksig->info);
index ad6b91013a0525d82002090788038e0c9773b34a..bd2545977ad35f33ee8c2f3fa63466e52a97a59b 100644 (file)
@@ -48,7 +48,7 @@ static inline int __range_ok(unsigned long addr, unsigned long size)
        __range_ok((unsigned long)(addr), (size));      \
 })
 
-#define access_ok(type, addr, size) __access_ok(addr, size)
+#define access_ok(addr, size) __access_ok(addr, size)
 
 unsigned long __must_check
 raw_copy_from_user(void *to, const void __user *from, unsigned long n);
index b58f3d95dc1913deacf48314535faac0ae4e37a9..36b84cfd3f673f25722eddaf7a4b5cbd397dc9d3 100644 (file)
@@ -197,7 +197,7 @@ static inline __wsum csum_and_copy_to_user(const void *src,
                                           int len, __wsum sum,
                                           int *err_ptr)
 {
-       if (access_ok(VERIFY_WRITE, dst, len))
+       if (access_ok(dst, len))
                return csum_partial_copy_generic((__force const void *)src,
                                                dst, len, sum, NULL, err_ptr);
 
index 6d192f4908a729c5d9d57b58dc060442a362ed49..3190ec89df81c3b41597fc7fbec032d2b5de7ba8 100644 (file)
@@ -22,7 +22,7 @@ static inline int
 futex_atomic_cmpxchg_inatomic(u32 *uval, u32 __user *uaddr,
                              u32 oldval, u32 newval)
 {
-       if (!access_ok(VERIFY_WRITE, uaddr, sizeof(u32)))
+       if (!access_ok(uaddr, sizeof(u32)))
                return -EFAULT;
 
        return atomic_futex_op_cmpxchg_inatomic(uval, uaddr, oldval, newval);
index 32eb56e00c11f9558b346a809d66643463203d4e..deebbfab5342dd858e1753b423ec53d58249d43f 100644 (file)
@@ -18,7 +18,7 @@
  */
 #define __access_ok(addr, size)                \
        (__addr_ok((addr) + (size)))
-#define access_ok(type, addr, size)    \
+#define access_ok(addr, size)  \
        (__chk_user_ptr(addr),          \
         __access_ok((unsigned long __force)(addr), (size)))
 
@@ -66,7 +66,7 @@ struct __large_struct { unsigned long buf[100]; };
        long __gu_err = -EFAULT;                                        \
        unsigned long __gu_val = 0;                                     \
        const __typeof__(*(ptr)) *__gu_addr = (ptr);                    \
-       if (likely(access_ok(VERIFY_READ, __gu_addr, (size))))          \
+       if (likely(access_ok(__gu_addr, (size))))               \
                __get_user_size(__gu_val, __gu_addr, (size), __gu_err); \
        (x) = (__force __typeof__(*(ptr)))__gu_val;                     \
        __gu_err;                                                       \
@@ -87,7 +87,7 @@ struct __large_struct { unsigned long buf[100]; };
        long __pu_err = -EFAULT;                                \
        __typeof__(*(ptr)) __user *__pu_addr = (ptr);           \
        __typeof__(*(ptr)) __pu_val = x;                        \
-       if (likely(access_ok(VERIFY_WRITE, __pu_addr, size)))   \
+       if (likely(access_ok(__pu_addr, size))) \
                __put_user_size(__pu_val, __pu_addr, (size),    \
                                __pu_err);                      \
        __pu_err;                                               \
@@ -132,8 +132,7 @@ __kernel_size_t __clear_user(void *addr, __kernel_size_t size);
        void __user * __cl_addr = (addr);                               \
        unsigned long __cl_size = (n);                                  \
                                                                        \
-       if (__cl_size && access_ok(VERIFY_WRITE,                        \
-               ((unsigned long)(__cl_addr)), __cl_size))               \
+       if (__cl_size && access_ok(__cl_addr, __cl_size))               \
                __cl_size = __clear_user(__cl_addr, __cl_size);         \
                                                                        \
        __cl_size;                                                      \
index c46c0020ff55edf0fdfda120ed90cd3fa7b65d17..2a2121ba8ebe2eee55e479abbdc29878701e86b7 100644 (file)
@@ -160,7 +160,7 @@ asmlinkage int sys_sigreturn(void)
         /* Always make any pending restarted system calls return -EINTR */
        current->restart_block.fn = do_no_restart_syscall;
 
-       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)
@@ -190,7 +190,7 @@ asmlinkage int sys_rt_sigreturn(void)
        /* Always make any pending restarted system calls return -EINTR */
        current->restart_block.fn = do_no_restart_syscall;
 
-       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)))
@@ -272,7 +272,7 @@ static int setup_frame(struct ksignal *ksig, sigset_t *set,
 
        frame = get_sigframe(&ksig->ka, regs->regs[15], sizeof(*frame));
 
-       if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+       if (!access_ok(frame, sizeof(*frame)))
                return -EFAULT;
 
        err |= setup_sigcontext(&frame->sc, regs, set->sig[0]);
@@ -338,7 +338,7 @@ static int setup_rt_frame(struct ksignal *ksig, sigset_t *set,
 
        frame = get_sigframe(&ksig->ka, regs->regs[15], sizeof(*frame));
 
-       if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+       if (!access_ok(frame, sizeof(*frame)))
                return -EFAULT;
 
        err |= copy_siginfo_to_user(&frame->info, &ksig->info);
index 76661dee3c65610b6589e3247959e537ea02ad5c..f1f1598879c22828f94be08fb201d44fbb1d26d1 100644 (file)
@@ -259,7 +259,7 @@ asmlinkage int sys_sigreturn(unsigned long r2, unsigned long r3,
        /* Always make any pending restarted system calls return -EINTR */
        current->restart_block.fn = do_no_restart_syscall;
 
-       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)
@@ -293,7 +293,7 @@ asmlinkage int sys_rt_sigreturn(unsigned long r2, unsigned long r3,
        /* Always make any pending restarted system calls return -EINTR */
        current->restart_block.fn = do_no_restart_syscall;
 
-       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)))
@@ -379,7 +379,7 @@ static int setup_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs
 
        frame = get_sigframe(&ksig->ka, regs->regs[REG_SP], sizeof(*frame));
 
-       if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+       if (!access_ok(frame, sizeof(*frame)))
                return -EFAULT;
 
        err |= setup_sigcontext(&frame->sc, regs, set->sig[0]);
@@ -465,7 +465,7 @@ static int setup_rt_frame(struct ksignal *kig, sigset_t *set,
 
        frame = get_sigframe(&ksig->ka, regs->regs[REG_SP], sizeof(*frame));
 
-       if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+       if (!access_ok(frame, sizeof(*frame)))
                return -EFAULT;
 
        err |= __put_user(&frame->info, &frame->pinfo);
index c52bda4d2574aab18d91329c27c6015720363765..8ce90a7da67d9b4dd77850fee840dfc2cfa87844 100644 (file)
@@ -40,7 +40,7 @@ static int read_opcode(reg_size_t pc, insn_size_t *result_opcode, int from_user_
                /* SHmedia */
                aligned_pc = pc & ~3;
                if (from_user_mode) {
-                       if (!access_ok(VERIFY_READ, aligned_pc, sizeof(insn_size_t))) {
+                       if (!access_ok(aligned_pc, sizeof(insn_size_t))) {
                                get_user_error = -EFAULT;
                        } else {
                                get_user_error = __get_user(opcode, (insn_size_t *)aligned_pc);
@@ -180,7 +180,7 @@ static int misaligned_load(struct pt_regs *regs,
        if (user_mode(regs)) {
                __u64 buffer;
 
-               if (!access_ok(VERIFY_READ, (unsigned long) address, 1UL<<width_shift)) {
+               if (!access_ok((unsigned long) address, 1UL<<width_shift)) {
                        return -1;
                }
 
@@ -254,7 +254,7 @@ static int misaligned_store(struct pt_regs *regs,
        if (user_mode(regs)) {
                __u64 buffer;
 
-               if (!access_ok(VERIFY_WRITE, (unsigned long) address, 1UL<<width_shift)) {
+               if (!access_ok((unsigned long) address, 1UL<<width_shift)) {
                        return -1;
                }
 
@@ -327,7 +327,7 @@ static int misaligned_fpu_load(struct pt_regs *regs,
                __u64 buffer;
                __u32 buflo, bufhi;
 
-               if (!access_ok(VERIFY_READ, (unsigned long) address, 1UL<<width_shift)) {
+               if (!access_ok((unsigned long) address, 1UL<<width_shift)) {
                        return -1;
                }
 
@@ -400,7 +400,7 @@ static int misaligned_fpu_store(struct pt_regs *regs,
                /* Initialise these to NaNs. */
                __u32 buflo=0xffffffffUL, bufhi=0xffffffffUL;
 
-               if (!access_ok(VERIFY_WRITE, (unsigned long) address, 1UL<<width_shift)) {
+               if (!access_ok((unsigned long) address, 1UL<<width_shift)) {
                        return -1;
                }
 
@@ -663,7 +663,7 @@ void do_reserved_inst(unsigned long error_code, struct pt_regs *regs)
        /* SHmedia : check for defect.  This requires executable vmas
           to be readable too. */
        aligned_pc = pc & ~3;
-       if (!access_ok(VERIFY_READ, aligned_pc, sizeof(insn_size_t)))
+       if (!access_ok(aligned_pc, sizeof(insn_size_t)))
                get_user_error = -EFAULT;
        else
                get_user_error = __get_user(opcode, (insn_size_t *)aligned_pc);
index 56c86ca98ecfe774eecf197af16aa90240423e15..3e27f6d1f1ec109e45d976eb3a38ef04d583bff7 100644 (file)
@@ -177,8 +177,7 @@ int __get_user_pages_fast(unsigned long start, int nr_pages, int write,
        addr = start;
        len = (unsigned long) nr_pages << PAGE_SHIFT;
        end = start + len;
-       if (unlikely(!access_ok(write ? VERIFY_WRITE : VERIFY_READ,
-                                       (void __user *)start, len)))
+       if (unlikely(!access_ok((void __user *)start, len)))
                return 0;
 
        /*
index c7695f99c8c3cb2e6fc2972607cca9f555d2e6d8..8279a7e91043cb079b8121c3a884c8ee0c8e98fb 100644 (file)
@@ -51,7 +51,7 @@ user_backtrace(unsigned long *stackaddr, struct pt_regs *regs)
        unsigned long buf_stack;
 
        /* Also check accessibility of address */
-       if (!access_ok(VERIFY_READ, stackaddr, sizeof(unsigned long)))
+       if (!access_ok(stackaddr, sizeof(unsigned long)))
                return NULL;
 
        if (__copy_from_user_inatomic(&buf_stack, stackaddr, sizeof(unsigned long)))
index d1e53d7aed39f1fe30b2c041e2aeba6d9cad8eff..5fc98d80b03bccd0a3be9aea757836bd0465535e 100644 (file)
@@ -87,7 +87,7 @@ static inline __wsum
 csum_partial_copy_to_user(const void *src, void __user *dst, int len,
                          __wsum sum, int *err)
 {
-       if (!access_ok (VERIFY_WRITE, dst, len)) {
+       if (!access_ok(dst, len)) {
                *err = -EFAULT;
                return sum;
        } else {
index de71c65b99f022b586c306df754ea36f3a9d7471..69afb856e18151e1b41d45b7d6da34d0dfb8f6ed 100644 (file)
@@ -39,7 +39,7 @@
 #define __user_ok(addr, size) ({ (void)(size); (addr) < STACK_TOP; })
 #define __kernel_ok (uaccess_kernel())
 #define __access_ok(addr, size) (__user_ok((addr) & get_fs().seg, (size)))
-#define access_ok(type, addr, size) \
+#define access_ok(addr, size) \
        ({ (void)(type); __access_ok((unsigned long)(addr), size); })
 
 /*
index cbb308cee394f51b0d5e161d34dfe1cfb2cc316b..87ae9ffb1521b199ea57b477c4fc8fb789bf3dc3 100644 (file)
@@ -68,7 +68,7 @@ static inline int __access_ok(const void __user * addr, unsigned long size)
        return 1;
 }
 
-static inline int access_ok(int type, const void __user * addr, unsigned long size)
+static inline int access_ok(const void __user * addr, unsigned long size)
 {
        return 1;
 }
index 1e9fae56a8530417a1a72667464dd35fa09c19f7..f25c6daa9f5254c45f3e4446cba33af4a4c995a8 100644 (file)
@@ -65,7 +65,7 @@ int restore_fpu_state(struct pt_regs *regs, __siginfo_fpu_t __user *fpu)
        set_used_math();
        clear_tsk_thread_flag(current, TIF_USEDFPU);
 
-       if (!access_ok(VERIFY_READ, fpu, sizeof(*fpu)))
+       if (!access_ok(fpu, sizeof(*fpu)))
                return -EFAULT;
 
        err = __copy_from_user(&current->thread.float_regs[0], &fpu->si_float_regs[0],
index 64ac8c0c14290e53543d58b77b8d9753729bfbf8..83db94c0b43189e4c938d30878368ee2cbf41c08 100644 (file)
@@ -278,7 +278,6 @@ static inline int ok_for_user(struct pt_regs *regs, unsigned int insn,
                              enum direction dir)
 {
        unsigned int reg;
-       int check = (dir == load) ? VERIFY_READ : VERIFY_WRITE;
        int size = ((insn >> 19) & 3) == 3 ? 8 : 4;
 
        if ((regs->pc | regs->npc) & 3)
@@ -290,18 +289,18 @@ static inline int ok_for_user(struct pt_regs *regs, unsigned int insn,
 
        reg = (insn >> 25) & 0x1f;
        if (reg >= 16) {
-               if (!access_ok(check, WINREG_ADDR(reg - 16), size))
+               if (!access_ok(WINREG_ADDR(reg - 16), size))
                        return -EFAULT;
        }
        reg = (insn >> 14) & 0x1f;
        if (reg >= 16) {
-               if (!access_ok(check, WINREG_ADDR(reg - 16), size))
+               if (!access_ok(WINREG_ADDR(reg - 16), size))
                        return -EFAULT;
        }
        if (!(insn & 0x2000)) {
                reg = (insn & 0x1f);
                if (reg >= 16) {
-                       if (!access_ok(check, WINREG_ADDR(reg - 16), size))
+                       if (!access_ok(WINREG_ADDR(reg - 16), size))
                                return -EFAULT;
                }
        }
index 1a1d88a4d94035b8cd0685ea5d6ea34ae23cd7f5..5f47422401e1e98d634d12882bd098a9c77a6207 100644 (file)
@@ -66,7 +66,7 @@ long arch_ptrace(struct task_struct *child, long request,
 
 #ifdef PTRACE_GETREGS
        case PTRACE_GETREGS: { /* Get all gp regs from the child. */
-               if (!access_ok(VERIFY_WRITE, p, MAX_REG_OFFSET)) {
+               if (!access_ok(p, MAX_REG_OFFSET)) {
                        ret = -EIO;
                        break;
                }
@@ -81,7 +81,7 @@ long arch_ptrace(struct task_struct *child, long request,
 #ifdef PTRACE_SETREGS
        case PTRACE_SETREGS: { /* Set all gp regs in the child. */
                unsigned long tmp = 0;
-               if (!access_ok(VERIFY_READ, p, MAX_REG_OFFSET)) {
+               if (!access_ok(p, MAX_REG_OFFSET)) {
                        ret = -EIO;
                        break;
                }
index 4ae51cf15adea6ef7ddc6741b431793b545903d3..63be04809d401df14681d4671ef38897f3abb1cd 100644 (file)
@@ -117,7 +117,7 @@ asmlinkage int __sys_rt_sigreturn(struct pt_regs *regs)
 
        frame = (struct rt_sigframe __user *)regs->UCreg_sp;
 
-       if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
+       if (!access_ok(frame, sizeof(*frame)))
                goto badframe;
 
        if (restore_sigframe(regs, &frame->sig))
@@ -205,7 +205,7 @@ static inline void __user *get_sigframe(struct k_sigaction *ka,
        /*
         * Check that we can actually write to the signal frame.
         */
-       if (!access_ok(VERIFY_WRITE, frame, framesize))
+       if (!access_ok(frame, framesize))
                frame = NULL;
 
        return frame;
index d78bcc03e60e740f9169813309cce71750a9c88e..d9d81ad7a4009aac0bfb37cd0345366a5d206164 100644 (file)
@@ -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;
index 8e02b30cf08e16a2ca5b3d0b6aa97bda051a2c85..f65b78d32f5eb7bb0a926c7c4e49b41cb0e66969 100644 (file)
@@ -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;
 
index 86b1341cba9ac5c6b32a3dd941091d59f8ebb56c..321fe5f5d0e96f8ed3f4962dbf982bc60551cf0e 100644 (file)
@@ -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 {
index 11ef7b7c9cc897940ec445498f338a31a3844d28..a4321203625797007091094be941587840558f59 100644 (file)
@@ -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) ||
index 7a659c74cd037039896c8c3313a5967a86393020..f57b94e02c5770f9c33f281b8ff647adc7280e12 100644 (file)
@@ -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);
index b3ec519e39827e58eaeb8a567303e37a6bc2e919..4fe9e7fc74d37d8a5af686cebf7d4a21d9c38b95 100644 (file)
@@ -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
 
index b5e58cc0c5e75d29aed2cf45ecf52d86ebac1a37..3920f456db79a11f24ecf0f5f859ee4fc00ea258 100644 (file)
@@ -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;                                                \
index d99a8ee9e185e00be294bace7596bddd1dcc02d1..f6a1d299627c5825adb8214afe18731a3d39a53e 100644 (file)
@@ -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);
index 92a3b312a53c465bbde5f006b5707b62671a49ae..08dfd4c1a4f95a19c78c855028e95b6be01ba02b 100644 (file)
@@ -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;
index 7627455047c2d58e2db96cc6af1186debc2bdff1..5c2d71a1dc069fd2b7ea2457fdd83e85c5e3383a 100644 (file)
@@ -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;
index c2fd39752da886776f0ff9a32b7acef157f12e6a..a092b6b40c6b5113f95d374fbbc966717ddf8ca4 100644 (file)
@@ -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;
index 8bd53589ecfb93337c920d254e9307617bc21a32..a6a2b7dccbfff163ff650fce42f422c5bf20cc7e 100644 (file)
@@ -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;
        }
index 71fb58d44d5867dcaa1441c5cf1b630553382798..bfd94e7812fcb8642817784ab7be3032fa95ef37 100644 (file)
@@ -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;
 }
index 1bd837cdc4b197483a7b694a9084151db8e27770..ee42bb0cbeb3f66d1e17fdec0c4994749fc55828 100644 (file)
@@ -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;
 }
index c8b1b31ed7c44b9bcfc0b570d5643e80655147ab..f98a0c956764687e9afc8a982edc5e4f40d61aee 100644 (file)
@@ -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))
index f821a9cd7753c8940901911472423e6f280b2995..f15263e158e8e669d82398bd40b3f2f8415cd88d 100644 (file)
@@ -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;
index d40ff45497b9bb554aa14d49fe5d7f15da660b97..f3779743d15e695fae569b969825857c38610a4a 100644 (file)
@@ -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))
index 2385538e80656aca15b9507827d45885b453cf8d..de1851d156997b58969455cf3ea9ce92336beb87 100644 (file)
@@ -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) {
index 83a75f8a12330237a73b20a9d5c96c9a77d4b450..b9ac7c9eb72c553fdd13ac4e3a8a5282f3d2f2b8 100644 (file)
@@ -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;
index 727ed442e0a52f0b60b57567abf5bbc59c8e6e5f..8b4a71efe7eef1c71e778bf17ff1929c6d68b0a8 100644 (file)
@@ -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) {
index 3ae74d7e074b5970c92b4e2e5158ea631809eccf..f302ef57973a45e8a9dccf82a8329158f48172a3 100644 (file)
@@ -243,7 +243,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))
                return csum_partial_copy_generic(src,dst,len,sum,NULL,err_ptr);
 
        if (len)
index fd0eef6b8e7c967b9563856ba0aa89711a946ac1..505d09eff184dba703f8e3ef52203de03faa0617 100644 (file)
@@ -93,7 +93,7 @@ futex_atomic_cmpxchg_inatomic(u32 *uval, u32 __user *uaddr,
 {
        int ret = 0;
 
-       if (!access_ok(VERIFY_WRITE, uaddr, sizeof(u32)))
+       if (!access_ok(uaddr, sizeof(u32)))
                return -EFAULT;
 
 #if !XCHAL_HAVE_S32C1I
index d11ef29396528a43dba06ff0a781311611e0f2e5..4b2480304bc311ffd8c1769efa885a2b78e65357 100644 (file)
@@ -42,7 +42,7 @@
 #define __user_ok(addr, size) \
                (((size) <= TASK_SIZE)&&((addr) <= TASK_SIZE-(size)))
 #define __access_ok(addr, size) (__kernel_ok || __user_ok((addr), (size)))
-#define access_ok(type, addr, size) __access_ok((unsigned long)(addr), (size))
+#define access_ok(addr, size) __access_ok((unsigned long)(addr), (size))
 
 #define user_addr_max() (uaccess_kernel() ? ~0UL : TASK_SIZE)
 
@@ -86,7 +86,7 @@ extern long __put_user_bad(void);
 ({                                                                     \
        long __pu_err = -EFAULT;                                        \
        __typeof__(*(ptr)) *__pu_addr = (ptr);                          \
-       if (access_ok(VERIFY_WRITE, __pu_addr, size))                   \
+       if (access_ok(__pu_addr, size))                 \
                __put_user_size((x), __pu_addr, (size), __pu_err);      \
        __pu_err;                                                       \
 })
@@ -183,7 +183,7 @@ __asm__ __volatile__(                                       \
 ({                                                                     \
        long __gu_err = -EFAULT, __gu_val = 0;                          \
        const __typeof__(*(ptr)) *__gu_addr = (ptr);                    \
-       if (access_ok(VERIFY_READ, __gu_addr, size))                    \
+       if (access_ok(__gu_addr, size))                 \
                __get_user_size(__gu_val, __gu_addr, (size), __gu_err); \
        (x) = (__force __typeof__(*(ptr)))__gu_val;                     \
        __gu_err;                                                       \
@@ -269,7 +269,7 @@ __xtensa_clear_user(void *addr, unsigned long size)
 static inline unsigned long
 clear_user(void *addr, unsigned long size)
 {
-       if (access_ok(VERIFY_WRITE, addr, size))
+       if (access_ok(addr, size))
                return __xtensa_clear_user(addr, size);
        return size ? -EFAULT : 0;
 }
@@ -284,7 +284,7 @@ extern long __strncpy_user(char *, const char *, long);
 static inline long
 strncpy_from_user(char *dst, const char *src, long count)
 {
-       if (access_ok(VERIFY_READ, src, 1))
+       if (access_ok(src, 1))
                return __strncpy_user(dst, src, count);
        return -EFAULT;
 }
index 74e1682876acbd36cd318195ba49a99dc42df890..dc22a238ed9c18d59f8d2721cc1fab16b41bfdae 100644 (file)
@@ -251,7 +251,7 @@ asmlinkage long xtensa_rt_sigreturn(long a0, long a1, long a2, long a3,
 
        frame = (struct rt_sigframe __user *) regs->areg[1];
 
-       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)))
@@ -348,7 +348,7 @@ static int setup_frame(struct ksignal *ksig, sigset_t *set,
        if (regs->depc > 64)
                panic ("Double exception sys_sigreturn\n");
 
-       if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) {
+       if (!access_ok(frame, sizeof(*frame))) {
                return -EFAULT;
        }
 
index 0df4080fa20f2276563eb64f8694959548a3f557..174c11f13bba375472f77a02eca75b1408d5e2de 100644 (file)
@@ -91,7 +91,7 @@ void xtensa_backtrace_user(struct pt_regs *regs, unsigned int depth,
                pc = MAKE_PC_FROM_RA(a0, pc);
 
                /* Check if the region is OK to access. */
-               if (!access_ok(VERIFY_READ, &SPILL_SLOT(a1, 0), 8))
+               if (!access_ok(&SPILL_SLOT(a1, 0), 8))
                        return;
                /* Copy a1, a0 from user space stack frame. */
                if (__get_user(a0, &SPILL_SLOT(a1, 0)) ||
index f21c99ec46ee0935605f09d28e4e2161be1abdc4..a2dcd62ea32ffb54818a3f16482608f12ee92cc0 100644 (file)
@@ -614,7 +614,7 @@ static ssize_t acpi_aml_read(struct file *file, char __user *buf,
 
        if (!count)
                return 0;
-       if (!access_ok(VERIFY_WRITE, buf, count))
+       if (!access_ok(buf, count))
                return -EFAULT;
 
        while (count > 0) {
@@ -684,7 +684,7 @@ static ssize_t acpi_aml_write(struct file *file, const char __user *buf,
 
        if (!count)
                return 0;
-       if (!access_ok(VERIFY_READ, buf, count))
+       if (!access_ok(buf, count))
                return -EFAULT;
 
        while (count > 0) {
index 14e728fbb8a009bcb8988c63f52c812c122943b7..ff5394f475875b6fe0c666d760a1a45daae8a0db 100644 (file)
@@ -44,7 +44,7 @@ static ssize_t read_nvram(struct file *file, char __user *buf,
        unsigned int i;
        char __user *p = buf;
 
-       if (!access_ok(VERIFY_WRITE, buf, count))
+       if (!access_ok(buf, count))
                return -EFAULT;
        if (*ppos >= nvram_len)
                return 0;
@@ -62,7 +62,7 @@ static ssize_t write_nvram(struct file *file, const char __user *buf,
        const char __user *p = buf;
        char c;
 
-       if (!access_ok(VERIFY_READ, buf, count))
+       if (!access_ok(buf, count))
                return -EFAULT;
        if (*ppos >= nvram_len)
                return 0;
index 7b4e4de778e45f7900732a243f6d53f783089d32..b08dc50f9f26026730c5eb12ee8e4be47012c2f8 100644 (file)
@@ -609,7 +609,7 @@ static ssize_t read_port(struct file *file, char __user *buf,
        unsigned long i = *ppos;
        char __user *tmp = buf;
 
-       if (!access_ok(VERIFY_WRITE, buf, count))
+       if (!access_ok(buf, count))
                return -EFAULT;
        while (count-- > 0 && i < 65536) {
                if (__put_user(inb(i), tmp) < 0)
@@ -627,7 +627,7 @@ static ssize_t write_port(struct file *file, const char __user *buf,
        unsigned long i = *ppos;
        const char __user *tmp = buf;
 
-       if (!access_ok(VERIFY_READ, buf, count))
+       if (!access_ok(buf, count))
                return -EFAULT;
        while (count-- > 0 && i < 65536) {
                char c;
index a284ae25e69a1bcee2b4eda407c51b616e9432cc..76fb434068d4f7b85be5ab6b2abf3ebd5c58ae4a 100644 (file)
@@ -167,7 +167,7 @@ static ssize_t flash_write(struct file *file, const char __user *buf,
        if (count > gbFlashSize - p)
                count = gbFlashSize - p;
                        
-       if (!access_ok(VERIFY_READ, buf, count))
+       if (!access_ok(buf, count))
                return -EFAULT;
 
        /*
index 809507bf8f1cd8c371845e450cfd4e7151b59eb0..7a4eb86aedac6862f947a85b726eab9660427cd6 100644 (file)
@@ -1445,11 +1445,11 @@ static long cmm_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
              _IOC_DIR(cmd), _IOC_READ, _IOC_WRITE, size, cmd);
 
        if (_IOC_DIR(cmd) & _IOC_READ) {
-               if (!access_ok(VERIFY_WRITE, argp, size))
+               if (!access_ok(argp, size))
                        goto out;
        }
        if (_IOC_DIR(cmd) & _IOC_WRITE) {
-               if (!access_ok(VERIFY_READ, argp, size))
+               if (!access_ok(argp, size))
                        goto out;
        }
        rc = 0;
index d64a78ccc03e318986daa8cda8200c1dbe709ff7..b16be8a11d92d63382612461d7a7bedafa0ba966 100644 (file)
@@ -364,7 +364,7 @@ static int sev_ioctl_do_pek_csr(struct sev_issue_cmd *argp)
                goto cmd;
 
        /* allocate a physically contiguous buffer to store the CSR blob */
-       if (!access_ok(VERIFY_WRITE, input.address, input.length) ||
+       if (!access_ok(input.address, input.length) ||
            input.length > SEV_FW_BLOB_MAX_SIZE) {
                ret = -EFAULT;
                goto e_free;
@@ -644,14 +644,14 @@ static int sev_ioctl_do_pdh_export(struct sev_issue_cmd *argp)
 
        /* Allocate a physically contiguous buffer to store the PDH blob. */
        if ((input.pdh_cert_len > SEV_FW_BLOB_MAX_SIZE) ||
-           !access_ok(VERIFY_WRITE, input.pdh_cert_address, input.pdh_cert_len)) {
+           !access_ok(input.pdh_cert_address, input.pdh_cert_len)) {
                ret = -EFAULT;
                goto e_free;
        }
 
        /* Allocate a physically contiguous buffer to store the cert chain blob. */
        if ((input.cert_chain_len > SEV_FW_BLOB_MAX_SIZE) ||
-           !access_ok(VERIFY_WRITE, input.cert_chain_address, input.cert_chain_len)) {
+           !access_ok(input.cert_chain_address, input.cert_chain_len)) {
                ret = -EFAULT;
                goto e_free;
        }
index d8e185582642bcdc72e7989c4d47e7529a458353..16a7045736a94e156e3375d5901facac009e513d 100644 (file)
@@ -1094,7 +1094,7 @@ static int ioctl_queue_iso(struct client *client, union ioctl_arg *arg)
                return -EINVAL;
 
        p = (struct fw_cdev_iso_packet __user *)u64_to_uptr(a->packets);
-       if (!access_ok(VERIFY_READ, p, a->size))
+       if (!access_ok(p, a->size))
                return -EFAULT;
 
        end = (void __user *)p + a->size;
index 769640940c9fc86dff2ce107e3500aeb6a33f93f..51ecf7d6da48a383c8afed701fcfaa7faa6465cb 100644 (file)
@@ -68,7 +68,7 @@ copy_ucs2_from_user_len(efi_char16_t **dst, efi_char16_t __user *src,
                return 0;
        }
 
-       if (!access_ok(VERIFY_READ, src, 1))
+       if (!access_ok(src, 1))
                return -EFAULT;
 
        buf = memdup_user(src, len);
@@ -89,7 +89,7 @@ copy_ucs2_from_user_len(efi_char16_t **dst, efi_char16_t __user *src,
 static inline int
 get_ucs2_strsize_from_user(efi_char16_t __user *src, size_t *len)
 {
-       if (!access_ok(VERIFY_READ, src, 1))
+       if (!access_ok(src, 1))
                return -EFAULT;
 
        *len = user_ucs2_strsize(src);
@@ -116,7 +116,7 @@ copy_ucs2_from_user(efi_char16_t **dst, efi_char16_t __user *src)
 {
        size_t len;
 
-       if (!access_ok(VERIFY_READ, src, 1))
+       if (!access_ok(src, 1))
                return -EFAULT;
 
        len = user_ucs2_strsize(src);
@@ -140,7 +140,7 @@ copy_ucs2_to_user_len(efi_char16_t __user *dst, efi_char16_t *src, size_t len)
        if (!src)
                return 0;
 
-       if (!access_ok(VERIFY_WRITE, dst, 1))
+       if (!access_ok(dst, 1))
                return -EFAULT;
 
        return copy_to_user(dst, src, len);
index 025aba3ea76c044591590aab3525f9fdaad85008..e18a786fc94383e2fbd5f6b1c9a4692de6506fa6 100644 (file)
@@ -369,7 +369,7 @@ int afu_dma_map_region(struct dfl_feature_platform_data *pdata,
        if (user_addr + length < user_addr)
                return -EINVAL;
 
-       if (!access_ok(VERIFY_WRITE, (void __user *)(unsigned long)user_addr,
+       if (!access_ok((void __user *)(unsigned long)user_addr,
                       length))
                return -EINVAL;
 
index fe5a5578fbf7039a24b8b61a43d17d3247da62c8..d9ca9554844abd3386322ba9ce830b2a19017317 100644 (file)
@@ -99,8 +99,7 @@ static int fme_pr(struct platform_device *pdev, unsigned long arg)
                return -EINVAL;
        }
 
-       if (!access_ok(VERIFY_READ,
-                      (void __user *)(unsigned long)port_pr.buffer_address,
+       if (!access_ok((void __user *)(unsigned long)port_pr.buffer_address,
                       port_pr.buffer_size))
                return -EFAULT;
 
index 3623538baf6fc9c20dd79167826ded7d52acbc9e..be68752c3469f32296c0cb369389fb259aa34ff2 100644 (file)
@@ -158,8 +158,7 @@ static int set_queue_properties_from_user(struct queue_properties *q_properties,
        }
 
        if ((args->ring_base_address) &&
-               (!access_ok(VERIFY_WRITE,
-                       (const void __user *) args->ring_base_address,
+               (!access_ok((const void __user *) args->ring_base_address,
                        sizeof(uint64_t)))) {
                pr_err("Can't access ring base address\n");
                return -EFAULT;
@@ -170,31 +169,27 @@ static int set_queue_properties_from_user(struct queue_properties *q_properties,
                return -EINVAL;
        }
 
-       if (!access_ok(VERIFY_WRITE,
-                       (const void __user *) args->read_pointer_address,
+       if (!access_ok((const void __user *) args->read_pointer_address,
                        sizeof(uint32_t))) {
                pr_err("Can't access read pointer\n");
                return -EFAULT;
        }
 
-       if (!access_ok(VERIFY_WRITE,
-                       (const void __user *) args->write_pointer_address,
+       if (!access_ok((const void __user *) args->write_pointer_address,
                        sizeof(uint32_t))) {
                pr_err("Can't access write pointer\n");
                return -EFAULT;
        }
 
        if (args->eop_buffer_address &&
-               !access_ok(VERIFY_WRITE,
-                       (const void __user *) args->eop_buffer_address,
+               !access_ok((const void __user *) args->eop_buffer_address,
                        sizeof(uint32_t))) {
                pr_debug("Can't access eop buffer");
                return -EFAULT;
        }
 
        if (args->ctx_save_restore_address &&
-               !access_ok(VERIFY_WRITE,
-                       (const void __user *) args->ctx_save_restore_address,
+               !access_ok((const void __user *) args->ctx_save_restore_address,
                        sizeof(uint32_t))) {
                pr_debug("Can't access ctx save restore buffer");
                return -EFAULT;
@@ -365,8 +360,7 @@ static int kfd_ioctl_update_queue(struct file *filp, struct kfd_process *p,
        }
 
        if ((args->ring_base_address) &&
-               (!access_ok(VERIFY_WRITE,
-                       (const void __user *) args->ring_base_address,
+               (!access_ok((const void __user *) args->ring_base_address,
                        sizeof(uint64_t)))) {
                pr_err("Can't access ring base address\n");
                return -EFAULT;
index 892c1d9304bb7640d46f192c587958c0946c48b1..642d0e70d0f8ffe4634046b5327039321e08a1a4 100644 (file)
@@ -334,7 +334,7 @@ int armada_gem_pwrite_ioctl(struct drm_device *dev, void *data,
 
        ptr = (char __user *)(uintptr_t)args->ptr;
 
-       if (!access_ok(VERIFY_READ, ptr, args->size))
+       if (!access_ok(ptr, args->size))
                return -EFAULT;
 
        ret = fault_in_pages_readable(ptr, args->size);
index ffa8dc35515ffaddf0f87c56cc2108e0be4151f6..46f48f245eb5a5df0db52e17d188ac01da723510 100644 (file)
@@ -525,7 +525,7 @@ ssize_t drm_read(struct file *filp, char __user *buffer,
        struct drm_device *dev = file_priv->minor->dev;
        ssize_t ret;
 
-       if (!access_ok(VERIFY_WRITE, buffer, count))
+       if (!access_ok(buffer, count))
                return -EFAULT;
 
        ret = mutex_lock_interruptible(&file_priv->event_read_lock);
index 96efc84396bf73e7abe6dfe3cac90384099f9db2..18c27f795cf612c89304cab2e72e94aa46e199b3 100644 (file)
@@ -339,7 +339,6 @@ static int etnaviv_ioctl_gem_userptr(struct drm_device *dev, void *data,
        struct drm_file *file)
 {
        struct drm_etnaviv_gem_userptr *args = data;
-       int access;
 
        if (args->flags & ~(ETNA_USERPTR_READ|ETNA_USERPTR_WRITE) ||
            args->flags == 0)
@@ -351,12 +350,7 @@ static int etnaviv_ioctl_gem_userptr(struct drm_device *dev, void *data,
            args->user_ptr & ~PAGE_MASK)
                return -EINVAL;
 
-       if (args->flags & ETNA_USERPTR_WRITE)
-               access = VERIFY_WRITE;
-       else
-               access = VERIFY_READ;
-
-       if (!access_ok(access, (void __user *)(unsigned long)args->user_ptr,
+       if (!access_ok((void __user *)(unsigned long)args->user_ptr,
                       args->user_size))
                return -EFAULT;
 
index a9de07bb72c896e8f3714799fd3a9264010bb79e..216f52b744a637fca6406fe31a25f5d5befa4c2c 100644 (file)
@@ -1282,8 +1282,7 @@ i915_gem_pread_ioctl(struct drm_device *dev, void *data,
        if (args->size == 0)
                return 0;
 
-       if (!access_ok(VERIFY_WRITE,
-                      u64_to_user_ptr(args->data_ptr),
+       if (!access_ok(u64_to_user_ptr(args->data_ptr),
                       args->size))
                return -EFAULT;
 
@@ -1609,9 +1608,7 @@ i915_gem_pwrite_ioctl(struct drm_device *dev, void *data,
        if (args->size == 0)
                return 0;
 
-       if (!access_ok(VERIFY_READ,
-                      u64_to_user_ptr(args->data_ptr),
-                      args->size))
+       if (!access_ok(u64_to_user_ptr(args->data_ptr), args->size))
                return -EFAULT;
 
        obj = i915_gem_object_lookup(file, args->handle);
index 8ff6b581cf1c73f318be40bbf1d0718129c765ae..fee66ccebed63b546d03ebf93c9248379711cfdb 100644 (file)
@@ -1447,7 +1447,7 @@ static int eb_relocate_vma(struct i915_execbuffer *eb, struct i915_vma *vma)
         * to read. However, if the array is not writable the user loses
         * the updated relocation values.
         */
-       if (unlikely(!access_ok(VERIFY_READ, urelocs, remain*sizeof(*urelocs))))
+       if (unlikely(!access_ok(urelocs, remain*sizeof(*urelocs))))
                return -EFAULT;
 
        do {
@@ -1554,7 +1554,7 @@ static int check_relocations(const struct drm_i915_gem_exec_object2 *entry)
 
        addr = u64_to_user_ptr(entry->relocs_ptr);
        size *= sizeof(struct drm_i915_gem_relocation_entry);
-       if (!access_ok(VERIFY_READ, addr, size))
+       if (!access_ok(addr, size))
                return -EFAULT;
 
        end = addr + size;
@@ -2090,7 +2090,7 @@ get_fence_array(struct drm_i915_gem_execbuffer2 *args,
                return ERR_PTR(-EINVAL);
 
        user = u64_to_user_ptr(args->cliprects_ptr);
-       if (!access_ok(VERIFY_READ, user, nfences * sizeof(*user)))
+       if (!access_ok(user, nfences * sizeof(*user)))
                return ERR_PTR(-EFAULT);
 
        fences = kvmalloc_array(nfences, sizeof(*fences),
index 3df77020aada8539330a8d3b86f1f23fbadd20f9..9558582c105ec4953ba0616b23966000a095cfab 100644 (file)
@@ -789,8 +789,7 @@ i915_gem_userptr_ioctl(struct drm_device *dev,
        if (offset_in_page(args->user_ptr | args->user_size))
                return -EINVAL;
 
-       if (!access_ok(args->flags & I915_USERPTR_READ_ONLY ? VERIFY_READ : VERIFY_WRITE,
-                      (char __user *)(unsigned long)args->user_ptr, args->user_size))
+       if (!access_ok((char __user *)(unsigned long)args->user_ptr, args->user_size))
                return -EFAULT;
 
        if (args->flags & I915_USERPTR_READ_ONLY) {
index 0e5c580d117cfcced6254ddab4dfcec04611bea9..e869daf9c8a9e0c21f409506ab60240f76bd95c7 100644 (file)
@@ -52,7 +52,7 @@ static int compat_i915_getparam(struct file *file, unsigned int cmd,
                return -EFAULT;
 
        request = compat_alloc_user_space(sizeof(*request));
-       if (!access_ok(VERIFY_WRITE, request, sizeof(*request)) ||
+       if (!access_ok(request, sizeof(*request)) ||
            __put_user(req32.param, &request->param) ||
            __put_user((void __user *)(unsigned long)req32.value,
                       &request->value))
index 4529edfdcfc80580ea66b306713a42250e1f2626..2b2eb57ca71f2905020aed9f7797684f69c148e7 100644 (file)
@@ -3052,7 +3052,7 @@ static struct i915_oa_reg *alloc_oa_regs(struct drm_i915_private *dev_priv,
        if (!n_regs)
                return NULL;
 
-       if (!access_ok(VERIFY_READ, regs, n_regs * sizeof(u32) * 2))
+       if (!access_ok(regs, n_regs * sizeof(u32) * 2))
                return ERR_PTR(-EFAULT);
 
        /* No is_valid function means we're not allowing any register to be programmed. */
index 6fc4b8eeab428f7b10bf56ba5c07eba5789b59a7..fe56465cdfd67512aca73d3cdf0bc3b7e7f6bf2f 100644 (file)
@@ -46,7 +46,7 @@ static int query_topology_info(struct drm_i915_private *dev_priv,
        if (topo.flags != 0)
                return -EINVAL;
 
-       if (!access_ok(VERIFY_WRITE, u64_to_user_ptr(query_item->data_ptr),
+       if (!access_ok(u64_to_user_ptr(query_item->data_ptr),
                       total_length))
                return -EFAULT;
 
index a28465d9052908787d569a970f431ac564ba2f22..12b983fc0b567601fa796840b65f7135209b933b 100644 (file)
@@ -77,7 +77,7 @@ void msm_gem_submit_free(struct msm_gem_submit *submit)
 static inline unsigned long __must_check
 copy_from_user_inatomic(void *to, const void __user *from, unsigned long n)
 {
-       if (access_ok(VERIFY_READ, from, n))
+       if (access_ok(from, n))
                return __copy_from_user_inatomic(to, from, n);
        return -EFAULT;
 }
index 6e828158bcb02d3e5dbc09225c7c353ea3766eb2..d410e29251629d494efe0e14a525be6e26573da6 100644 (file)
@@ -163,8 +163,7 @@ static int qxl_process_single_command(struct qxl_device *qdev,
        if (cmd->command_size > PAGE_SIZE - sizeof(union qxl_release_info))
                return -EINVAL;
 
-       if (!access_ok(VERIFY_READ,
-                      u64_to_user_ptr(cmd->command),
+       if (!access_ok(u64_to_user_ptr(cmd->command),
                       cmd->command_size))
                return -EFAULT;
 
index 9f9172eb15123a8fd5078b56db5700e7aeb8a93a..fb0007aa0c27eb8dd279b58dfb4a40c5d51950d2 100644 (file)
@@ -611,8 +611,7 @@ static ssize_t verify_hdr(struct ib_uverbs_cmd_hdr *hdr,
                        if (hdr->out_words * 8 < method_elm->resp_size)
                                return -ENOSPC;
 
-                       if (!access_ok(VERIFY_WRITE,
-                                      u64_to_user_ptr(ex_hdr->response),
+                       if (!access_ok(u64_to_user_ptr(ex_hdr->response),
                                       (hdr->out_words + ex_hdr->provider_out_words) * 8))
                                return -EFAULT;
                } else {
diff --git