]> git.karo-electronics.de Git - karo-tx-linux.git/blob - mm/util.c
ARM: dts: imx6ul: whitespace cleanup; no functional change
[karo-tx-linux.git] / mm / util.c
1 #include <linux/mm.h>
2 #include <linux/slab.h>
3 #include <linux/string.h>
4 #include <linux/compiler.h>
5 #include <linux/export.h>
6 #include <linux/ctype.h>
7 #include <linux/err.h>
8 #include <linux/sched.h>
9 #include <linux/security.h>
10 #include <linux/swap.h>
11 #include <linux/swapops.h>
12 #include <linux/mman.h>
13 #include <linux/hugetlb.h>
14 #include <linux/vmalloc.h>
15
16 #include <asm/sections.h>
17 #include <asm/uaccess.h>
18
19 #include "internal.h"
20
21 static inline int is_kernel_rodata(unsigned long addr)
22 {
23         return addr >= (unsigned long)__start_rodata &&
24                 addr < (unsigned long)__end_rodata;
25 }
26
27 /**
28  * kfree_const - conditionally free memory
29  * @x: pointer to the memory
30  *
31  * Function calls kfree only if @x is not in .rodata section.
32  */
33 void kfree_const(const void *x)
34 {
35         if (!is_kernel_rodata((unsigned long)x))
36                 kfree(x);
37 }
38 EXPORT_SYMBOL(kfree_const);
39
40 /**
41  * kstrdup - allocate space for and copy an existing string
42  * @s: the string to duplicate
43  * @gfp: the GFP mask used in the kmalloc() call when allocating memory
44  */
45 char *kstrdup(const char *s, gfp_t gfp)
46 {
47         size_t len;
48         char *buf;
49
50         if (!s)
51                 return NULL;
52
53         len = strlen(s) + 1;
54         buf = kmalloc_track_caller(len, gfp);
55         if (buf)
56                 memcpy(buf, s, len);
57         return buf;
58 }
59 EXPORT_SYMBOL(kstrdup);
60
61 /**
62  * kstrdup_const - conditionally duplicate an existing const string
63  * @s: the string to duplicate
64  * @gfp: the GFP mask used in the kmalloc() call when allocating memory
65  *
66  * Function returns source string if it is in .rodata section otherwise it
67  * fallbacks to kstrdup.
68  * Strings allocated by kstrdup_const should be freed by kfree_const.
69  */
70 const char *kstrdup_const(const char *s, gfp_t gfp)
71 {
72         if (is_kernel_rodata((unsigned long)s))
73                 return s;
74
75         return kstrdup(s, gfp);
76 }
77 EXPORT_SYMBOL(kstrdup_const);
78
79 /**
80  * kstrndup - allocate space for and copy an existing string
81  * @s: the string to duplicate
82  * @max: read at most @max chars from @s
83  * @gfp: the GFP mask used in the kmalloc() call when allocating memory
84  */
85 char *kstrndup(const char *s, size_t max, gfp_t gfp)
86 {
87         size_t len;
88         char *buf;
89
90         if (!s)
91                 return NULL;
92
93         len = strnlen(s, max);
94         buf = kmalloc_track_caller(len+1, gfp);
95         if (buf) {
96                 memcpy(buf, s, len);
97                 buf[len] = '\0';
98         }
99         return buf;
100 }
101 EXPORT_SYMBOL(kstrndup);
102
103 /**
104  * kstrimdup - Trim and copy a %NUL terminated string.
105  * @s: the string to trim and duplicate
106  * @gfp: the GFP mask used in the kmalloc() call when allocating memory
107  *
108  * Returns an address, which the caller must kfree, containing
109  * a duplicate of the passed string with leading and/or trailing
110  * whitespace (as defined by isspace) removed.
111  */
112 char *kstrimdup(const char *s, gfp_t gfp)
113 {
114         char *buf;
115         char *begin = skip_spaces(s);
116         size_t len = strlen(begin);
117
118         while (len && isspace(begin[len - 1]))
119                 len--;
120
121         buf = kmalloc_track_caller(len + 1, gfp);
122         if (!buf)
123                 return NULL;
124
125         memcpy(buf, begin, len);
126         buf[len] = '\0';
127
128         return buf;
129 }
130 EXPORT_SYMBOL(kstrimdup);
131
132 /**
133  * kmemdup - duplicate region of memory
134  *
135  * @src: memory region to duplicate
136  * @len: memory region length
137  * @gfp: GFP mask to use
138  */
139 void *kmemdup(const void *src, size_t len, gfp_t gfp)
140 {
141         void *p;
142
143         p = kmalloc_track_caller(len, gfp);
144         if (p)
145                 memcpy(p, src, len);
146         return p;
147 }
148 EXPORT_SYMBOL(kmemdup);
149
150 /**
151  * memdup_user - duplicate memory region from user space
152  *
153  * @src: source address in user space
154  * @len: number of bytes to copy
155  *
156  * Returns an ERR_PTR() on failure.
157  */
158 void *memdup_user(const void __user *src, size_t len)
159 {
160         void *p;
161
162         /*
163          * Always use GFP_KERNEL, since copy_from_user() can sleep and
164          * cause pagefault, which makes it pointless to use GFP_NOFS
165          * or GFP_ATOMIC.
166          */
167         p = kmalloc_track_caller(len, GFP_KERNEL);
168         if (!p)
169                 return ERR_PTR(-ENOMEM);
170
171         if (copy_from_user(p, src, len)) {
172                 kfree(p);
173                 return ERR_PTR(-EFAULT);
174         }
175
176         return p;
177 }
178 EXPORT_SYMBOL(memdup_user);
179
180 /*
181  * strndup_user - duplicate an existing string from user space
182  * @s: The string to duplicate
183  * @n: Maximum number of bytes to copy, including the trailing NUL.
184  */
185 char *strndup_user(const char __user *s, long n)
186 {
187         char *p;
188         long length;
189
190         length = strnlen_user(s, n);
191
192         if (!length)
193                 return ERR_PTR(-EFAULT);
194
195         if (length > n)
196                 return ERR_PTR(-EINVAL);
197
198         p = memdup_user(s, length);
199
200         if (IS_ERR(p))
201                 return p;
202
203         p[length - 1] = '\0';
204
205         return p;
206 }
207 EXPORT_SYMBOL(strndup_user);
208
209 /**
210  * memdup_user_nul - duplicate memory region from user space and NUL-terminate
211  *
212  * @src: source address in user space
213  * @len: number of bytes to copy
214  *
215  * Returns an ERR_PTR() on failure.
216  */
217 void *memdup_user_nul(const void __user *src, size_t len)
218 {
219         char *p;
220
221         /*
222          * Always use GFP_KERNEL, since copy_from_user() can sleep and
223          * cause pagefault, which makes it pointless to use GFP_NOFS
224          * or GFP_ATOMIC.
225          */
226         p = kmalloc_track_caller(len + 1, GFP_KERNEL);
227         if (!p)
228                 return ERR_PTR(-ENOMEM);
229
230         if (copy_from_user(p, src, len)) {
231                 kfree(p);
232                 return ERR_PTR(-EFAULT);
233         }
234         p[len] = '\0';
235
236         return p;
237 }
238 EXPORT_SYMBOL(memdup_user_nul);
239
240 void __vma_link_list(struct mm_struct *mm, struct vm_area_struct *vma,
241                 struct vm_area_struct *prev, struct rb_node *rb_parent)
242 {
243         struct vm_area_struct *next;
244
245         vma->vm_prev = prev;
246         if (prev) {
247                 next = prev->vm_next;
248                 prev->vm_next = vma;
249         } else {
250                 mm->mmap = vma;
251                 if (rb_parent)
252                         next = rb_entry(rb_parent,
253                                         struct vm_area_struct, vm_rb);
254                 else
255                         next = NULL;
256         }
257         vma->vm_next = next;
258         if (next)
259                 next->vm_prev = vma;
260 }
261
262 /* Check if the vma is being used as a stack by this task */
263 int vma_is_stack_for_task(struct vm_area_struct *vma, struct task_struct *t)
264 {
265         return (vma->vm_start <= KSTK_ESP(t) && vma->vm_end >= KSTK_ESP(t));
266 }
267
268 #if defined(CONFIG_MMU) && !defined(HAVE_ARCH_PICK_MMAP_LAYOUT)
269 void arch_pick_mmap_layout(struct mm_struct *mm)
270 {
271         mm->mmap_base = TASK_UNMAPPED_BASE;
272         mm->get_unmapped_area = arch_get_unmapped_area;
273 }
274 #endif
275
276 /*
277  * Like get_user_pages_fast() except its IRQ-safe in that it won't fall
278  * back to the regular GUP.
279  * If the architecture not support this function, simply return with no
280  * page pinned
281  */
282 int __weak __get_user_pages_fast(unsigned long start,
283                                  int nr_pages, int write, struct page **pages)
284 {
285         return 0;
286 }
287 EXPORT_SYMBOL_GPL(__get_user_pages_fast);
288
289 /**
290  * get_user_pages_fast() - pin user pages in memory
291  * @start:      starting user address
292  * @nr_pages:   number of pages from start to pin
293  * @write:      whether pages will be written to
294  * @pages:      array that receives pointers to the pages pinned.
295  *              Should be at least nr_pages long.
296  *
297  * Returns number of pages pinned. This may be fewer than the number
298  * requested. If nr_pages is 0 or negative, returns 0. If no pages
299  * were pinned, returns -errno.
300  *
301  * get_user_pages_fast provides equivalent functionality to get_user_pages,
302  * operating on current and current->mm, with force=0 and vma=NULL. However
303  * unlike get_user_pages, it must be called without mmap_sem held.
304  *
305  * get_user_pages_fast may take mmap_sem and page table locks, so no
306  * assumptions can be made about lack of locking. get_user_pages_fast is to be
307  * implemented in a way that is advantageous (vs get_user_pages()) when the
308  * user memory area is already faulted in and present in ptes. However if the
309  * pages have to be faulted in, it may turn out to be slightly slower so
310  * callers need to carefully consider what to use. On many architectures,
311  * get_user_pages_fast simply falls back to get_user_pages.
312  */
313 int __weak get_user_pages_fast(unsigned long start,
314                                 int nr_pages, int write, struct page **pages)
315 {
316         struct mm_struct *mm = current->mm;
317         return get_user_pages_unlocked(current, mm, start, nr_pages,
318                                        write, 0, pages);
319 }
320 EXPORT_SYMBOL_GPL(get_user_pages_fast);
321
322 unsigned long vm_mmap_pgoff(struct file *file, unsigned long addr,
323         unsigned long len, unsigned long prot,
324         unsigned long flag, unsigned long pgoff)
325 {
326         unsigned long ret;
327         struct mm_struct *mm = current->mm;
328         unsigned long populate;
329
330         ret = security_mmap_file(file, prot, flag);
331         if (!ret) {
332                 down_write(&mm->mmap_sem);
333                 ret = do_mmap_pgoff(file, addr, len, prot, flag, pgoff,
334                                     &populate);
335                 up_write(&mm->mmap_sem);
336                 if (populate)
337                         mm_populate(ret, populate);
338         }
339         return ret;
340 }
341
342 unsigned long vm_mmap(struct file *file, unsigned long addr,
343         unsigned long len, unsigned long prot,
344         unsigned long flag, unsigned long offset)
345 {
346         if (unlikely(offset + PAGE_ALIGN(len) < offset))
347                 return -EINVAL;
348         if (unlikely(offset_in_page(offset)))
349                 return -EINVAL;
350
351         return vm_mmap_pgoff(file, addr, len, prot, flag, offset >> PAGE_SHIFT);
352 }
353 EXPORT_SYMBOL(vm_mmap);
354
355 void kvfree(const void *addr)
356 {
357         if (is_vmalloc_addr(addr))
358                 vfree(addr);
359         else
360                 kfree(addr);
361 }
362 EXPORT_SYMBOL(kvfree);
363
364 static inline void *__page_rmapping(struct page *page)
365 {
366         unsigned long mapping;
367
368         mapping = (unsigned long)page->mapping;
369         mapping &= ~PAGE_MAPPING_FLAGS;
370
371         return (void *)mapping;
372 }
373
374 /* Neutral page->mapping pointer to address_space or anon_vma or other */
375 void *page_rmapping(struct page *page)
376 {
377         page = compound_head(page);
378         return __page_rmapping(page);
379 }
380
381 struct anon_vma *page_anon_vma(struct page *page)
382 {
383         unsigned long mapping;
384
385         page = compound_head(page);
386         mapping = (unsigned long)page->mapping;
387         if ((mapping & PAGE_MAPPING_FLAGS) != PAGE_MAPPING_ANON)
388                 return NULL;
389         return __page_rmapping(page);
390 }
391
392 struct address_space *page_mapping(struct page *page)
393 {
394         struct address_space *mapping;
395
396         page = compound_head(page);
397
398         /* This happens if someone calls flush_dcache_page on slab page */
399         if (unlikely(PageSlab(page)))
400                 return NULL;
401
402         if (unlikely(PageSwapCache(page))) {
403                 swp_entry_t entry;
404
405                 entry.val = page_private(page);
406                 return swap_address_space(entry);
407         }
408
409         mapping = page->mapping;
410         if ((unsigned long)mapping & PAGE_MAPPING_FLAGS)
411                 return NULL;
412         return mapping;
413 }
414
415 /* Slow path of page_mapcount() for compound pages */
416 int __page_mapcount(struct page *page)
417 {
418         int ret;
419
420         ret = atomic_read(&page->_mapcount) + 1;
421         page = compound_head(page);
422         ret += atomic_read(compound_mapcount_ptr(page)) + 1;
423         if (PageDoubleMap(page))
424                 ret--;
425         return ret;
426 }
427 EXPORT_SYMBOL_GPL(__page_mapcount);
428
429 int overcommit_ratio_handler(struct ctl_table *table, int write,
430                              void __user *buffer, size_t *lenp,
431                              loff_t *ppos)
432 {
433         int ret;
434
435         ret = proc_dointvec(table, write, buffer, lenp, ppos);
436         if (ret == 0 && write)
437                 sysctl_overcommit_kbytes = 0;
438         return ret;
439 }
440
441 int overcommit_kbytes_handler(struct ctl_table *table, int write,
442                              void __user *buffer, size_t *lenp,
443                              loff_t *ppos)
444 {
445         int ret;
446
447         ret = proc_doulongvec_minmax(table, write, buffer, lenp, ppos);
448         if (ret == 0 && write)
449                 sysctl_overcommit_ratio = 0;
450         return ret;
451 }
452
453 /*
454  * Committed memory limit enforced when OVERCOMMIT_NEVER policy is used
455  */
456 unsigned long vm_commit_limit(void)
457 {
458         unsigned long allowed;
459
460         if (sysctl_overcommit_kbytes)
461                 allowed = sysctl_overcommit_kbytes >> (PAGE_SHIFT - 10);
462         else
463                 allowed = ((totalram_pages - hugetlb_total_pages())
464                            * sysctl_overcommit_ratio / 100);
465         allowed += total_swap_pages;
466
467         return allowed;
468 }
469
470 /**
471  * get_cmdline() - copy the cmdline value to a buffer.
472  * @task:     the task whose cmdline value to copy.
473  * @buffer:   the buffer to copy to.
474  * @buflen:   the length of the buffer. Larger cmdline values are truncated
475  *            to this length.
476  * Returns the size of the cmdline field copied. Note that the copy does
477  * not guarantee an ending NULL byte.
478  */
479 int get_cmdline(struct task_struct *task, char *buffer, int buflen)
480 {
481         int res = 0;
482         unsigned int len;
483         struct mm_struct *mm = get_task_mm(task);
484         unsigned long arg_start, arg_end, env_start, env_end;
485         if (!mm)
486                 goto out;
487         if (!mm->arg_end)
488                 goto out_mm;    /* Shh! No looking before we're done */
489
490         down_read(&mm->mmap_sem);
491         arg_start = mm->arg_start;
492         arg_end = mm->arg_end;
493         env_start = mm->env_start;
494         env_end = mm->env_end;
495         up_read(&mm->mmap_sem);
496
497         len = arg_end - arg_start;
498
499         if (len > buflen)
500                 len = buflen;
501
502         res = access_process_vm(task, arg_start, buffer, len, 0);
503
504         /*
505          * If the nul at the end of args has been overwritten, then
506          * assume application is using setproctitle(3).
507          */
508         if (res > 0 && buffer[res-1] != '\0' && len < buflen) {
509                 len = strnlen(buffer, res);
510                 if (len < res) {
511                         res = len;
512                 } else {
513                         len = env_end - env_start;
514                         if (len > buflen - res)
515                                 len = buflen - res;
516                         res += access_process_vm(task, env_start,
517                                                  buffer+res, len, 0);
518                         res = strnlen(buffer, res);
519                 }
520         }
521 out_mm:
522         mmput(mm);
523 out:
524         return res;
525 }