mm/maccess.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Access kernel or user memory without faulting.
   4  */
   5 #include <linux/export.h>
   6 #include <linux/mm.h>
   7 #include <linux/uaccess.h>
   8
   9 bool __weak copy_from_kernel_nofault_allowed(const void *unsafe_src,
  10                 size_t size)
  11 {
  12         return true;
  13 }
  14
  15 #define copy_from_kernel_nofault_loop(dst, src, len, type, err_label)   \
  16         while (len >= sizeof(type)) {                                   \
  17                 __get_kernel_nofault(dst, src, type, err_label);                \
  18                 dst += sizeof(type);                                    \
  19                 src += sizeof(type);                                    \
  20                 len -= sizeof(type);                                    \
  21         }
  22
  23 long copy_from_kernel_nofault(void *dst, const void *src, size_t size)
  24 {
  25         unsigned long align = 0;
  26
  27         if (!IS_ENABLED(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS))
  28                 align = (unsigned long)dst | (unsigned long)src;
  29
  30         if (!copy_from_kernel_nofault_allowed(src, size))
  31                 return -ERANGE;
  32
  33         pagefault_disable();
  34         if (!(align & 7))
  35                 copy_from_kernel_nofault_loop(dst, src, size, u64, Efault);
  36         if (!(align & 3))
  37                 copy_from_kernel_nofault_loop(dst, src, size, u32, Efault);
  38         if (!(align & 1))
  39                 copy_from_kernel_nofault_loop(dst, src, size, u16, Efault);
  40         copy_from_kernel_nofault_loop(dst, src, size, u8, Efault);
  41         pagefault_enable();
  42         return 0;
  43 Efault:
  44         pagefault_enable();
  45         return -EFAULT;
  46 }
  47 EXPORT_SYMBOL_GPL(copy_from_kernel_nofault);
  48
  49 #define copy_to_kernel_nofault_loop(dst, src, len, type, err_label)     \
  50         while (len >= sizeof(type)) {                                   \
  51                 __put_kernel_nofault(dst, src, type, err_label);                \
  52                 dst += sizeof(type);                                    \
  53                 src += sizeof(type);                                    \
  54                 len -= sizeof(type);                                    \
  55         }
  56
  57 long copy_to_kernel_nofault(void *dst, const void *src, size_t size)
  58 {
  59         unsigned long align = 0;
  60
  61         if (!IS_ENABLED(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS))
  62                 align = (unsigned long)dst | (unsigned long)src;
  63
  64         pagefault_disable();
  65         if (!(align & 7))
  66                 copy_to_kernel_nofault_loop(dst, src, size, u64, Efault);
  67         if (!(align & 3))
  68                 copy_to_kernel_nofault_loop(dst, src, size, u32, Efault);
  69         if (!(align & 1))
  70                 copy_to_kernel_nofault_loop(dst, src, size, u16, Efault);
  71         copy_to_kernel_nofault_loop(dst, src, size, u8, Efault);
  72         pagefault_enable();
  73         return 0;
  74 Efault:
  75         pagefault_enable();
  76         return -EFAULT;
  77 }
  78
  79 long strncpy_from_kernel_nofault(char *dst, const void *unsafe_addr, long count)
  80 {
  81         const void *src = unsafe_addr;
  82
  83         if (unlikely(count <= 0))
  84                 return 0;
  85         if (!copy_from_kernel_nofault_allowed(unsafe_addr, count))
  86                 return -ERANGE;
  87
  88         pagefault_disable();
  89         do {
  90                 __get_kernel_nofault(dst, src, u8, Efault);
  91                 dst++;
  92                 src++;
  93         } while (dst[-1] && src - unsafe_addr < count);
  94         pagefault_enable();
  95
  96         dst[-1] = '\0';
  97         return src - unsafe_addr;
  98 Efault:
  99         pagefault_enable();
 100         dst[-1] = '\0';
 101         return -EFAULT;
 102 }
 103
 104 /**
 105  * copy_from_user_nofault(): safely attempt to read from a user-space location
 106  * @dst: pointer to the buffer that shall take the data
 107  * @src: address to read from. This must be a user address.
 108  * @size: size of the data chunk
 109  *
 110  * Safely read from user address @src to the buffer at @dst. If a kernel fault
 111  * happens, handle that and return -EFAULT.
 112  */
 113 long copy_from_user_nofault(void *dst, const void __user *src, size_t size)
 114 {
 115         long ret = -EFAULT;
 116         if (access_ok(src, size)) {
 117                 pagefault_disable();
 118                 ret = __copy_from_user_inatomic(dst, src, size);
 119                 pagefault_enable();
 120         }
 121
 122         if (ret)
 123                 return -EFAULT;
 124         return 0;
 125 }
 126 EXPORT_SYMBOL_GPL(copy_from_user_nofault);
 127
 128 /**
 129  * copy_to_user_nofault(): safely attempt to write to a user-space location
 130  * @dst: address to write to
 131  * @src: pointer to the data that shall be written
 132  * @size: size of the data chunk
 133  *
 134  * Safely write to address @dst from the buffer at @src.  If a kernel fault
 135  * happens, handle that and return -EFAULT.
 136  */
 137 long copy_to_user_nofault(void __user *dst, const void *src, size_t size)
 138 {
 139         long ret = -EFAULT;
 140
 141         if (access_ok(dst, size)) {
 142                 pagefault_disable();
 143                 ret = __copy_to_user_inatomic(dst, src, size);
 144                 pagefault_enable();
 145         }
 146
 147         if (ret)
 148                 return -EFAULT;
 149         return 0;
 150 }
 151 EXPORT_SYMBOL_GPL(copy_to_user_nofault);
 152
 153 /**
 154  * strncpy_from_user_nofault: - Copy a NUL terminated string from unsafe user
 155  *                              address.
 156  * @dst:   Destination address, in kernel space.  This buffer must be at
 157  *         least @count bytes long.
 158  * @unsafe_addr: Unsafe user address.
 159  * @count: Maximum number of bytes to copy, including the trailing NUL.
 160  *
 161  * Copies a NUL-terminated string from unsafe user address to kernel buffer.
 162  *
 163  * On success, returns the length of the string INCLUDING the trailing NUL.
 164  *
 165  * If access fails, returns -EFAULT (some data may have been copied
 166  * and the trailing NUL added).
 167  *
 168  * If @count is smaller than the length of the string, copies @count-1 bytes,
 169  * sets the last byte of @dst buffer to NUL and returns @count.
 170  */
 171 long strncpy_from_user_nofault(char *dst, const void __user *unsafe_addr,
 172                               long count)
 173 {
 174         long ret;
 175
 176         if (unlikely(count <= 0))
 177                 return 0;
 178
 179         pagefault_disable();
 180         ret = strncpy_from_user(dst, unsafe_addr, count);
 181         pagefault_enable();
 182
 183         if (ret >= count) {
 184                 ret = count;
 185                 dst[ret - 1] = '\0';
 186         } else if (ret > 0) {
 187                 ret++;
 188         }
 189
 190         return ret;
 191 }
 192
 193 /**
 194  * strnlen_user_nofault: - Get the size of a user string INCLUDING final NUL.
 195  * @unsafe_addr: The string to measure.
 196  * @count: Maximum count (including NUL)
 197  *
 198  * Get the size of a NUL-terminated string in user space without pagefault.
 199  *
 200  * Returns the size of the string INCLUDING the terminating NUL.
 201  *
 202  * If the string is too long, returns a number larger than @count. User
 203  * has to check the return value against "> count".
 204  * On exception (or invalid count), returns 0.
 205  *
 206  * Unlike strnlen_user, this can be used from IRQ handler etc. because
 207  * it disables pagefaults.
 208  */
 209 long strnlen_user_nofault(const void __user *unsafe_addr, long count)
 210 {
 211         int ret;
 212
 213         pagefault_disable();
 214         ret = strnlen_user(unsafe_addr, count);
 215         pagefault_enable();
 216
 217         return ret;
 218 }
 219
 220 void __copy_overflow(int size, unsigned long count)
 221 {
 222         WARN(1, "Buffer overflow detected (%d < %lu)!\n", size, count);
 223 }
 224 EXPORT_SYMBOL(__copy_overflow);