include/linux/uaccess.h

   1 #ifndef __LINUX_UACCESS_H__
   2 #define __LINUX_UACCESS_H__
   3
   4 #include <linux/sched.h>
   5 #include <asm/uaccess.h>
   6
   7 static __always_inline void pagefault_disabled_inc(void)
   8 {
   9         current->pagefault_disabled++;
  10 }
  11
  12 static __always_inline void pagefault_disabled_dec(void)
  13 {
  14         current->pagefault_disabled--;
  15         WARN_ON(current->pagefault_disabled < 0);
  16 }
  17
  18 /*
  19  * These routines enable/disable the pagefault handler. If disabled, it will
  20  * not take any locks and go straight to the fixup table.
  21  *
  22  * User access methods will not sleep when called from a pagefault_disabled()
  23  * environment.
  24  */
  25 static inline void pagefault_disable(void)
  26 {
  27         pagefault_disabled_inc();
  28         /*
  29          * make sure to have issued the store before a pagefault
  30          * can hit.
  31          */
  32         barrier();
  33 }
  34
  35 static inline void pagefault_enable(void)
  36 {
  37         /*
  38          * make sure to issue those last loads/stores before enabling
  39          * the pagefault handler again.
  40          */
  41         barrier();
  42         pagefault_disabled_dec();
  43 }
  44
  45 /*
  46  * Is the pagefault handler disabled? If so, user access methods will not sleep.
  47  */
  48 #define pagefault_disabled() (current->pagefault_disabled != 0)
  49
  50 /*
  51  * The pagefault handler is in general disabled by pagefault_disable() or
  52  * when in irq context (via in_atomic()).
  53  *
  54  * This function should only be used by the fault handlers. Other users should
  55  * stick to pagefault_disabled().
  56  * Please NEVER use preempt_disable() to disable the fault handler. With
  57  * !CONFIG_PREEMPT_COUNT, this is like a NOP. So the handler won't be disabled.
  58  * in_atomic() will report different values based on !CONFIG_PREEMPT_COUNT.
  59  */
  60 #define faulthandler_disabled() (pagefault_disabled() || in_atomic())
  61
  62 #ifndef ARCH_HAS_NOCACHE_UACCESS
  63
  64 static inline unsigned long __copy_from_user_inatomic_nocache(void *to,
  65                                 const void __user *from, unsigned long n)
  66 {
  67         return __copy_from_user_inatomic(to, from, n);
  68 }
  69
  70 static inline unsigned long __copy_from_user_nocache(void *to,
  71                                 const void __user *from, unsigned long n)
  72 {
  73         return __copy_from_user(to, from, n);
  74 }
  75
  76 #endif          /* ARCH_HAS_NOCACHE_UACCESS */
  77
  78 /*
  79  * probe_kernel_read(): safely attempt to read from a location
  80  * @dst: pointer to the buffer that shall take the data
  81  * @src: address to read from
  82  * @size: size of the data chunk
  83  *
  84  * Safely read from address @src to the buffer at @dst.  If a kernel fault
  85  * happens, handle that and return -EFAULT.
  86  */
  87 extern long probe_kernel_read(void *dst, const void *src, size_t size);
  88 extern long __probe_kernel_read(void *dst, const void *src, size_t size);
  89
  90 /*
  91  * probe_kernel_write(): safely attempt to write to a location
  92  * @dst: address to write to
  93  * @src: pointer to the data that shall be written
  94  * @size: size of the data chunk
  95  *
  96  * Safely write to address @dst from the buffer at @src.  If a kernel fault
  97  * happens, handle that and return -EFAULT.
  98  */
  99 extern long notrace probe_kernel_write(void *dst, const void *src, size_t size);
 100 extern long notrace __probe_kernel_write(void *dst, const void *src, size_t size);
 101
 102 extern long strncpy_from_unsafe(char *dst, const void *unsafe_addr, long count);
 103
 104 /**
 105  * probe_kernel_address(): safely attempt to read from a location
 106  * @addr: address to read from
 107  * @retval: read into this variable
 108  *
 109  * Returns 0 on success, or -EFAULT.
 110  */
 111 #define probe_kernel_address(addr, retval)              \
 112         probe_kernel_read(&retval, addr, sizeof(retval))
 113
 114 #ifndef user_access_begin
 115 #define user_access_begin() do { } while (0)
 116 #define user_access_end() do { } while (0)
 117 #define unsafe_get_user(x, ptr, err) do { if (unlikely(__get_user(x, ptr))) goto err; } while (0)
 118 #define unsafe_put_user(x, ptr, err) do { if (unlikely(__put_user(x, ptr))) goto err; } while (0)
 119 #endif
 120
 121 #endif          /* __LINUX_UACCESS_H__ */