1 #include <linux/mm.h> 2 #include <linux/slab.h> 3 #include <linux/string.h> 4 #include <linux/module.h> 5 #include <linux/err.h> 6 #include <linux/sched.h> 7 #include <asm/uaccess.h> 8 9 /** 10 * kstrdup - allocate space for and copy an existing string 11 * @s: the string to duplicate 12 * @gfp: the GFP mask used in the kmalloc() call when allocating memory 13 */ 14 char *kstrdup(const char *s, gfp_t gfp) 15 { 16 size_t len; 17 char *buf; 18 19 if (!s) 20 return NULL; 21 22 len = strlen(s) + 1; 23 buf = kmalloc_track_caller(len, gfp); 24 if (buf) 25 memcpy(buf, s, len); 26 return buf; 27 } 28 EXPORT_SYMBOL(kstrdup); 29 30 /** 31 * kstrndup - allocate space for and copy an existing string 32 * @s: the string to duplicate 33 * @max: read at most @max chars from @s 34 * @gfp: the GFP mask used in the kmalloc() call when allocating memory 35 */ 36 char *kstrndup(const char *s, size_t max, gfp_t gfp) 37 { 38 size_t len; 39 char *buf; 40 41 if (!s) 42 return NULL; 43 44 len = strnlen(s, max); 45 buf = kmalloc_track_caller(len+1, gfp); 46 if (buf) { 47 memcpy(buf, s, len); 48 buf[len] = '\0'; 49 } 50 return buf; 51 } 52 EXPORT_SYMBOL(kstrndup); 53 54 /** 55 * kmemdup - duplicate region of memory 56 * 57 * @src: memory region to duplicate 58 * @len: memory region length 59 * @gfp: GFP mask to use 60 */ 61 void *kmemdup(const void *src, size_t len, gfp_t gfp) 62 { 63 void *p; 64 65 p = kmalloc_track_caller(len, gfp); 66 if (p) 67 memcpy(p, src, len); 68 return p; 69 } 70 EXPORT_SYMBOL(kmemdup); 71 72 /** 73 * memdup_user - duplicate memory region from user space 74 * 75 * @src: source address in user space 76 * @len: number of bytes to copy 77 * 78 * Returns an ERR_PTR() on failure. 79 */ 80 void *memdup_user(const void __user *src, size_t len) 81 { 82 void *p; 83 84 /* 85 * Always use GFP_KERNEL, since copy_from_user() can sleep and 86 * cause pagefault, which makes it pointless to use GFP_NOFS 87 * or GFP_ATOMIC. 88 */ 89 p = kmalloc_track_caller(len, GFP_KERNEL); 90 if (!p) 91 return ERR_PTR(-ENOMEM); 92 93 if (copy_from_user(p, src, len)) { 94 kfree(p); 95 return ERR_PTR(-EFAULT); 96 } 97 98 return p; 99 } 100 EXPORT_SYMBOL(memdup_user); 101 102 /** 103 * __krealloc - like krealloc() but don't free @p. 104 * @p: object to reallocate memory for. 105 * @new_size: how many bytes of memory are required. 106 * @flags: the type of memory to allocate. 107 * 108 * This function is like krealloc() except it never frees the originally 109 * allocated buffer. Use this if you don't want to free the buffer immediately 110 * like, for example, with RCU. 111 */ 112 void *__krealloc(const void *p, size_t new_size, gfp_t flags) 113 { 114 void *ret; 115 size_t ks = 0; 116 117 if (unlikely(!new_size)) 118 return ZERO_SIZE_PTR; 119 120 if (p) 121 ks = ksize(p); 122 123 if (ks >= new_size) 124 return (void *)p; 125 126 ret = kmalloc_track_caller(new_size, flags); 127 if (ret && p) 128 memcpy(ret, p, ks); 129 130 return ret; 131 } 132 EXPORT_SYMBOL(__krealloc); 133 134 /** 135 * krealloc - reallocate memory. The contents will remain unchanged. 136 * @p: object to reallocate memory for. 137 * @new_size: how many bytes of memory are required. 138 * @flags: the type of memory to allocate. 139 * 140 * The contents of the object pointed to are preserved up to the 141 * lesser of the new and old sizes. If @p is %NULL, krealloc() 142 * behaves exactly like kmalloc(). If @size is 0 and @p is not a 143 * %NULL pointer, the object pointed to is freed. 144 */ 145 void *krealloc(const void *p, size_t new_size, gfp_t flags) 146 { 147 void *ret; 148 149 if (unlikely(!new_size)) { 150 kfree(p); 151 return ZERO_SIZE_PTR; 152 } 153 154 ret = __krealloc(p, new_size, flags); 155 if (ret && p != ret) 156 kfree(p); 157 158 return ret; 159 } 160 EXPORT_SYMBOL(krealloc); 161 162 /** 163 * kzfree - like kfree but zero memory 164 * @p: object to free memory of 165 * 166 * The memory of the object @p points to is zeroed before freed. 167 * If @p is %NULL, kzfree() does nothing. 168 */ 169 void kzfree(const void *p) 170 { 171 size_t ks; 172 void *mem = (void *)p; 173 174 if (unlikely(ZERO_OR_NULL_PTR(mem))) 175 return; 176 ks = ksize(mem); 177 memset(mem, 0, ks); 178 kfree(mem); 179 } 180 EXPORT_SYMBOL(kzfree); 181 182 /* 183 * strndup_user - duplicate an existing string from user space 184 * @s: The string to duplicate 185 * @n: Maximum number of bytes to copy, including the trailing NUL. 186 */ 187 char *strndup_user(const char __user *s, long n) 188 { 189 char *p; 190 long length; 191 192 length = strnlen_user(s, n); 193 194 if (!length) 195 return ERR_PTR(-EFAULT); 196 197 if (length > n) 198 return ERR_PTR(-EINVAL); 199 200 p = kmalloc(length, GFP_KERNEL); 201 202 if (!p) 203 return ERR_PTR(-ENOMEM); 204 205 if (copy_from_user(p, s, length)) { 206 kfree(p); 207 return ERR_PTR(-EFAULT); 208 } 209 210 p[length - 1] = '\0'; 211 212 return p; 213 } 214 EXPORT_SYMBOL(strndup_user); 215 216 #ifndef HAVE_ARCH_PICK_MMAP_LAYOUT 217 void arch_pick_mmap_layout(struct mm_struct *mm) 218 { 219 mm->mmap_base = TASK_UNMAPPED_BASE; 220 mm->get_unmapped_area = arch_get_unmapped_area; 221 mm->unmap_area = arch_unmap_area; 222 } 223 #endif 224 225 int __attribute__((weak)) get_user_pages_fast(unsigned long start, 226 int nr_pages, int write, struct page **pages) 227 { 228 struct mm_struct *mm = current->mm; 229 int ret; 230 231 down_read(&mm->mmap_sem); 232 ret = get_user_pages(current, mm, start, nr_pages, 233 write, 0, pages, NULL); 234 up_read(&mm->mmap_sem); 235 236 return ret; 237 } 238 EXPORT_SYMBOL_GPL(get_user_pages_fast); 239