1 // SPDX-License-Identifier: GPL-2.0-only
3 #include <linux/slab.h>
4 #include <linux/string.h>
5 #include <linux/compiler.h>
6 #include <linux/export.h>
8 #include <linux/sched.h>
9 #include <linux/sched/mm.h>
10 #include <linux/sched/signal.h>
11 #include <linux/sched/task_stack.h>
12 #include <linux/security.h>
13 #include <linux/swap.h>
14 #include <linux/swapops.h>
15 #include <linux/mman.h>
16 #include <linux/hugetlb.h>
17 #include <linux/vmalloc.h>
18 #include <linux/userfaultfd_k.h>
19 #include <linux/elf.h>
20 #include <linux/elf-randomize.h>
21 #include <linux/personality.h>
22 #include <linux/random.h>
23 #include <linux/processor.h>
24 #include <linux/sizes.h>
25 #include <linux/compat.h>
27 #include <linux/uaccess.h>
32 * kfree_const - conditionally free memory
33 * @x: pointer to the memory
35 * Function calls kfree only if @x is not in .rodata section.
37 void kfree_const(const void *x
)
39 if (!is_kernel_rodata((unsigned long)x
))
42 EXPORT_SYMBOL(kfree_const
);
45 * kstrdup - allocate space for and copy an existing string
46 * @s: the string to duplicate
47 * @gfp: the GFP mask used in the kmalloc() call when allocating memory
49 * Return: newly allocated copy of @s or %NULL in case of error
51 char *kstrdup(const char *s
, gfp_t gfp
)
60 buf
= kmalloc_track_caller(len
, gfp
);
65 EXPORT_SYMBOL(kstrdup
);
68 * kstrdup_const - conditionally duplicate an existing const string
69 * @s: the string to duplicate
70 * @gfp: the GFP mask used in the kmalloc() call when allocating memory
72 * Note: Strings allocated by kstrdup_const should be freed by kfree_const and
73 * must not be passed to krealloc().
75 * Return: source string if it is in .rodata section otherwise
76 * fallback to kstrdup.
78 const char *kstrdup_const(const char *s
, gfp_t gfp
)
80 if (is_kernel_rodata((unsigned long)s
))
83 return kstrdup(s
, gfp
);
85 EXPORT_SYMBOL(kstrdup_const
);
88 * kstrndup - allocate space for and copy an existing string
89 * @s: the string to duplicate
90 * @max: read at most @max chars from @s
91 * @gfp: the GFP mask used in the kmalloc() call when allocating memory
93 * Note: Use kmemdup_nul() instead if the size is known exactly.
95 * Return: newly allocated copy of @s or %NULL in case of error
97 char *kstrndup(const char *s
, size_t max
, gfp_t gfp
)
105 len
= strnlen(s
, max
);
106 buf
= kmalloc_track_caller(len
+1, gfp
);
113 EXPORT_SYMBOL(kstrndup
);
116 * kmemdup - duplicate region of memory
118 * @src: memory region to duplicate
119 * @len: memory region length
120 * @gfp: GFP mask to use
122 * Return: newly allocated copy of @src or %NULL in case of error
124 void *kmemdup(const void *src
, size_t len
, gfp_t gfp
)
128 p
= kmalloc_track_caller(len
, gfp
);
133 EXPORT_SYMBOL(kmemdup
);
136 * kmemdup_nul - Create a NUL-terminated string from unterminated data
137 * @s: The data to stringify
138 * @len: The size of the data
139 * @gfp: the GFP mask used in the kmalloc() call when allocating memory
141 * Return: newly allocated copy of @s with NUL-termination or %NULL in
144 char *kmemdup_nul(const char *s
, size_t len
, gfp_t gfp
)
151 buf
= kmalloc_track_caller(len
+ 1, gfp
);
158 EXPORT_SYMBOL(kmemdup_nul
);
161 * memdup_user - duplicate memory region from user space
163 * @src: source address in user space
164 * @len: number of bytes to copy
166 * Return: an ERR_PTR() on failure. Result is physically
167 * contiguous, to be freed by kfree().
169 void *memdup_user(const void __user
*src
, size_t len
)
173 p
= kmalloc_track_caller(len
, GFP_USER
| __GFP_NOWARN
);
175 return ERR_PTR(-ENOMEM
);
177 if (copy_from_user(p
, src
, len
)) {
179 return ERR_PTR(-EFAULT
);
184 EXPORT_SYMBOL(memdup_user
);
187 * vmemdup_user - duplicate memory region from user space
189 * @src: source address in user space
190 * @len: number of bytes to copy
192 * Return: an ERR_PTR() on failure. Result may be not
193 * physically contiguous. Use kvfree() to free.
195 void *vmemdup_user(const void __user
*src
, size_t len
)
199 p
= kvmalloc(len
, GFP_USER
);
201 return ERR_PTR(-ENOMEM
);
203 if (copy_from_user(p
, src
, len
)) {
205 return ERR_PTR(-EFAULT
);
210 EXPORT_SYMBOL(vmemdup_user
);
213 * strndup_user - duplicate an existing string from user space
214 * @s: The string to duplicate
215 * @n: Maximum number of bytes to copy, including the trailing NUL.
217 * Return: newly allocated copy of @s or an ERR_PTR() in case of error
219 char *strndup_user(const char __user
*s
, long n
)
224 length
= strnlen_user(s
, n
);
227 return ERR_PTR(-EFAULT
);
230 return ERR_PTR(-EINVAL
);
232 p
= memdup_user(s
, length
);
237 p
[length
- 1] = '\0';
241 EXPORT_SYMBOL(strndup_user
);
244 * memdup_user_nul - duplicate memory region from user space and NUL-terminate
246 * @src: source address in user space
247 * @len: number of bytes to copy
249 * Return: an ERR_PTR() on failure.
251 void *memdup_user_nul(const void __user
*src
, size_t len
)
256 * Always use GFP_KERNEL, since copy_from_user() can sleep and
257 * cause pagefault, which makes it pointless to use GFP_NOFS
260 p
= kmalloc_track_caller(len
+ 1, GFP_KERNEL
);
262 return ERR_PTR(-ENOMEM
);
264 if (copy_from_user(p
, src
, len
)) {
266 return ERR_PTR(-EFAULT
);
272 EXPORT_SYMBOL(memdup_user_nul
);
274 void __vma_link_list(struct mm_struct
*mm
, struct vm_area_struct
*vma
,
275 struct vm_area_struct
*prev
)
277 struct vm_area_struct
*next
;
281 next
= prev
->vm_next
;
292 void __vma_unlink_list(struct mm_struct
*mm
, struct vm_area_struct
*vma
)
294 struct vm_area_struct
*prev
, *next
;
299 prev
->vm_next
= next
;
303 next
->vm_prev
= prev
;
306 /* Check if the vma is being used as a stack by this task */
307 int vma_is_stack_for_current(struct vm_area_struct
*vma
)
309 struct task_struct
* __maybe_unused t
= current
;
311 return (vma
->vm_start
<= KSTK_ESP(t
) && vma
->vm_end
>= KSTK_ESP(t
));
314 #ifndef STACK_RND_MASK
315 #define STACK_RND_MASK (0x7ff >> (PAGE_SHIFT - 12)) /* 8MB of VA */
318 unsigned long randomize_stack_top(unsigned long stack_top
)
320 unsigned long random_variable
= 0;
322 if (current
->flags
& PF_RANDOMIZE
) {
323 random_variable
= get_random_long();
324 random_variable
&= STACK_RND_MASK
;
325 random_variable
<<= PAGE_SHIFT
;
327 #ifdef CONFIG_STACK_GROWSUP
328 return PAGE_ALIGN(stack_top
) + random_variable
;
330 return PAGE_ALIGN(stack_top
) - random_variable
;
334 #ifdef CONFIG_ARCH_WANT_DEFAULT_TOPDOWN_MMAP_LAYOUT
335 unsigned long arch_randomize_brk(struct mm_struct
*mm
)
337 /* Is the current task 32bit ? */
338 if (!IS_ENABLED(CONFIG_64BIT
) || is_compat_task())
339 return randomize_page(mm
->brk
, SZ_32M
);
341 return randomize_page(mm
->brk
, SZ_1G
);
344 unsigned long arch_mmap_rnd(void)
348 #ifdef CONFIG_HAVE_ARCH_MMAP_RND_COMPAT_BITS
349 if (is_compat_task())
350 rnd
= get_random_long() & ((1UL << mmap_rnd_compat_bits
) - 1);
352 #endif /* CONFIG_HAVE_ARCH_MMAP_RND_COMPAT_BITS */
353 rnd
= get_random_long() & ((1UL << mmap_rnd_bits
) - 1);
355 return rnd
<< PAGE_SHIFT
;
358 static int mmap_is_legacy(struct rlimit
*rlim_stack
)
360 if (current
->personality
& ADDR_COMPAT_LAYOUT
)
363 if (rlim_stack
->rlim_cur
== RLIM_INFINITY
)
366 return sysctl_legacy_va_layout
;
370 * Leave enough space between the mmap area and the stack to honour ulimit in
371 * the face of randomisation.
373 #define MIN_GAP (SZ_128M)
374 #define MAX_GAP (STACK_TOP / 6 * 5)
376 static unsigned long mmap_base(unsigned long rnd
, struct rlimit
*rlim_stack
)
378 unsigned long gap
= rlim_stack
->rlim_cur
;
379 unsigned long pad
= stack_guard_gap
;
381 /* Account for stack randomization if necessary */
382 if (current
->flags
& PF_RANDOMIZE
)
383 pad
+= (STACK_RND_MASK
<< PAGE_SHIFT
);
385 /* Values close to RLIM_INFINITY can overflow. */
391 else if (gap
> MAX_GAP
)
394 return PAGE_ALIGN(STACK_TOP
- gap
- rnd
);
397 void arch_pick_mmap_layout(struct mm_struct
*mm
, struct rlimit
*rlim_stack
)
399 unsigned long random_factor
= 0UL;
401 if (current
->flags
& PF_RANDOMIZE
)
402 random_factor
= arch_mmap_rnd();
404 if (mmap_is_legacy(rlim_stack
)) {
405 mm
->mmap_base
= TASK_UNMAPPED_BASE
+ random_factor
;
406 mm
->get_unmapped_area
= arch_get_unmapped_area
;
408 mm
->mmap_base
= mmap_base(random_factor
, rlim_stack
);
409 mm
->get_unmapped_area
= arch_get_unmapped_area_topdown
;
412 #elif defined(CONFIG_MMU) && !defined(HAVE_ARCH_PICK_MMAP_LAYOUT)
413 void arch_pick_mmap_layout(struct mm_struct
*mm
, struct rlimit
*rlim_stack
)
415 mm
->mmap_base
= TASK_UNMAPPED_BASE
;
416 mm
->get_unmapped_area
= arch_get_unmapped_area
;
421 * __account_locked_vm - account locked pages to an mm's locked_vm
422 * @mm: mm to account against
423 * @pages: number of pages to account
424 * @inc: %true if @pages should be considered positive, %false if not
425 * @task: task used to check RLIMIT_MEMLOCK
426 * @bypass_rlim: %true if checking RLIMIT_MEMLOCK should be skipped
428 * Assumes @task and @mm are valid (i.e. at least one reference on each), and
429 * that mmap_lock is held as writer.
433 * * -ENOMEM if RLIMIT_MEMLOCK would be exceeded.
435 int __account_locked_vm(struct mm_struct
*mm
, unsigned long pages
, bool inc
,
436 struct task_struct
*task
, bool bypass_rlim
)
438 unsigned long locked_vm
, limit
;
441 mmap_assert_write_locked(mm
);
443 locked_vm
= mm
->locked_vm
;
446 limit
= task_rlimit(task
, RLIMIT_MEMLOCK
) >> PAGE_SHIFT
;
447 if (locked_vm
+ pages
> limit
)
451 mm
->locked_vm
= locked_vm
+ pages
;
453 WARN_ON_ONCE(pages
> locked_vm
);
454 mm
->locked_vm
= locked_vm
- pages
;
457 pr_debug("%s: [%d] caller %ps %c%lu %lu/%lu%s\n", __func__
, task
->pid
,
458 (void *)_RET_IP_
, (inc
) ? '+' : '-', pages
<< PAGE_SHIFT
,
459 locked_vm
<< PAGE_SHIFT
, task_rlimit(task
, RLIMIT_MEMLOCK
),
460 ret
? " - exceeded" : "");
464 EXPORT_SYMBOL_GPL(__account_locked_vm
);
467 * account_locked_vm - account locked pages to an mm's locked_vm
468 * @mm: mm to account against, may be NULL
469 * @pages: number of pages to account
470 * @inc: %true if @pages should be considered positive, %false if not
472 * Assumes a non-NULL @mm is valid (i.e. at least one reference on it).
475 * * 0 on success, or if mm is NULL
476 * * -ENOMEM if RLIMIT_MEMLOCK would be exceeded.
478 int account_locked_vm(struct mm_struct
*mm
, unsigned long pages
, bool inc
)
482 if (pages
== 0 || !mm
)
486 ret
= __account_locked_vm(mm
, pages
, inc
, current
,
487 capable(CAP_IPC_LOCK
));
488 mmap_write_unlock(mm
);
492 EXPORT_SYMBOL_GPL(account_locked_vm
);
494 unsigned long vm_mmap_pgoff(struct file
*file
, unsigned long addr
,
495 unsigned long len
, unsigned long prot
,
496 unsigned long flag
, unsigned long pgoff
)
499 struct mm_struct
*mm
= current
->mm
;
500 unsigned long populate
;
503 ret
= security_mmap_file(file
, prot
, flag
);
505 if (mmap_write_lock_killable(mm
))
507 ret
= do_mmap(file
, addr
, len
, prot
, flag
, pgoff
, &populate
,
509 mmap_write_unlock(mm
);
510 userfaultfd_unmap_complete(mm
, &uf
);
512 mm_populate(ret
, populate
);
517 unsigned long vm_mmap(struct file
*file
, unsigned long addr
,
518 unsigned long len
, unsigned long prot
,
519 unsigned long flag
, unsigned long offset
)
521 if (unlikely(offset
+ PAGE_ALIGN(len
) < offset
))
523 if (unlikely(offset_in_page(offset
)))
526 return vm_mmap_pgoff(file
, addr
, len
, prot
, flag
, offset
>> PAGE_SHIFT
);
528 EXPORT_SYMBOL(vm_mmap
);
531 * kvmalloc_node - attempt to allocate physically contiguous memory, but upon
532 * failure, fall back to non-contiguous (vmalloc) allocation.
533 * @size: size of the request.
534 * @flags: gfp mask for the allocation - must be compatible (superset) with GFP_KERNEL.
535 * @node: numa node to allocate from
537 * Uses kmalloc to get the memory but if the allocation fails then falls back
538 * to the vmalloc allocator. Use kvfree for freeing the memory.
540 * Reclaim modifiers - __GFP_NORETRY and __GFP_NOFAIL are not supported.
541 * __GFP_RETRY_MAYFAIL is supported, and it should be used only if kmalloc is
542 * preferable to the vmalloc fallback, due to visible performance drawbacks.
544 * Please note that any use of gfp flags outside of GFP_KERNEL is careful to not
545 * fall back to vmalloc.
547 * Return: pointer to the allocated memory of %NULL in case of failure
549 void *kvmalloc_node(size_t size
, gfp_t flags
, int node
)
551 gfp_t kmalloc_flags
= flags
;
555 * vmalloc uses GFP_KERNEL for some internal allocations (e.g page tables)
556 * so the given set of flags has to be compatible.
558 if ((flags
& GFP_KERNEL
) != GFP_KERNEL
)
559 return kmalloc_node(size
, flags
, node
);
562 * We want to attempt a large physically contiguous block first because
563 * it is less likely to fragment multiple larger blocks and therefore
564 * contribute to a long term fragmentation less than vmalloc fallback.
565 * However make sure that larger requests are not too disruptive - no
566 * OOM killer and no allocation failure warnings as we have a fallback.
568 if (size
> PAGE_SIZE
) {
569 kmalloc_flags
|= __GFP_NOWARN
;
571 if (!(kmalloc_flags
& __GFP_RETRY_MAYFAIL
))
572 kmalloc_flags
|= __GFP_NORETRY
;
575 ret
= kmalloc_node(size
, kmalloc_flags
, node
);
578 * It doesn't really make sense to fallback to vmalloc for sub page
581 if (ret
|| size
<= PAGE_SIZE
)
584 return __vmalloc_node(size
, 1, flags
, node
,
585 __builtin_return_address(0));
587 EXPORT_SYMBOL(kvmalloc_node
);
590 * kvfree() - Free memory.
591 * @addr: Pointer to allocated memory.
593 * kvfree frees memory allocated by any of vmalloc(), kmalloc() or kvmalloc().
594 * It is slightly more efficient to use kfree() or vfree() if you are certain
595 * that you know which one to use.
597 * Context: Either preemptible task context or not-NMI interrupt.
599 void kvfree(const void *addr
)
601 if (is_vmalloc_addr(addr
))
606 EXPORT_SYMBOL(kvfree
);
609 * kvfree_sensitive - Free a data object containing sensitive information.
610 * @addr: address of the data object to be freed.
611 * @len: length of the data object.
613 * Use the special memzero_explicit() function to clear the content of a
614 * kvmalloc'ed object containing sensitive data to make sure that the
615 * compiler won't optimize out the data clearing.
617 void kvfree_sensitive(const void *addr
, size_t len
)
619 if (likely(!ZERO_OR_NULL_PTR(addr
))) {
620 memzero_explicit((void *)addr
, len
);
624 EXPORT_SYMBOL(kvfree_sensitive
);
626 static inline void *__page_rmapping(struct page
*page
)
628 unsigned long mapping
;
630 mapping
= (unsigned long)page
->mapping
;
631 mapping
&= ~PAGE_MAPPING_FLAGS
;
633 return (void *)mapping
;
636 /* Neutral page->mapping pointer to address_space or anon_vma or other */
637 void *page_rmapping(struct page
*page
)
639 page
= compound_head(page
);
640 return __page_rmapping(page
);
644 * Return true if this page is mapped into pagetables.
645 * For compound page it returns true if any subpage of compound page is mapped.
647 bool page_mapped(struct page
*page
)
651 if (likely(!PageCompound(page
)))
652 return atomic_read(&page
->_mapcount
) >= 0;
653 page
= compound_head(page
);
654 if (atomic_read(compound_mapcount_ptr(page
)) >= 0)
658 for (i
= 0; i
< compound_nr(page
); i
++) {
659 if (atomic_read(&page
[i
]._mapcount
) >= 0)
664 EXPORT_SYMBOL(page_mapped
);
666 struct anon_vma
*page_anon_vma(struct page
*page
)
668 unsigned long mapping
;
670 page
= compound_head(page
);
671 mapping
= (unsigned long)page
->mapping
;
672 if ((mapping
& PAGE_MAPPING_FLAGS
) != PAGE_MAPPING_ANON
)
674 return __page_rmapping(page
);
677 struct address_space
*page_mapping(struct page
*page
)
679 struct address_space
*mapping
;
681 page
= compound_head(page
);
683 /* This happens if someone calls flush_dcache_page on slab page */
684 if (unlikely(PageSlab(page
)))
687 if (unlikely(PageSwapCache(page
))) {
690 entry
.val
= page_private(page
);
691 return swap_address_space(entry
);
694 mapping
= page
->mapping
;
695 if ((unsigned long)mapping
& PAGE_MAPPING_ANON
)
698 return (void *)((unsigned long)mapping
& ~PAGE_MAPPING_FLAGS
);
700 EXPORT_SYMBOL(page_mapping
);
703 * For file cache pages, return the address_space, otherwise return NULL
705 struct address_space
*page_mapping_file(struct page
*page
)
707 if (unlikely(PageSwapCache(page
)))
709 return page_mapping(page
);
712 /* Slow path of page_mapcount() for compound pages */
713 int __page_mapcount(struct page
*page
)
717 ret
= atomic_read(&page
->_mapcount
) + 1;
719 * For file THP page->_mapcount contains total number of mapping
720 * of the page: no need to look into compound_mapcount.
722 if (!PageAnon(page
) && !PageHuge(page
))
724 page
= compound_head(page
);
725 ret
+= atomic_read(compound_mapcount_ptr(page
)) + 1;
726 if (PageDoubleMap(page
))
730 EXPORT_SYMBOL_GPL(__page_mapcount
);
732 int sysctl_overcommit_memory __read_mostly
= OVERCOMMIT_GUESS
;
733 int sysctl_overcommit_ratio __read_mostly
= 50;
734 unsigned long sysctl_overcommit_kbytes __read_mostly
;
735 int sysctl_max_map_count __read_mostly
= DEFAULT_MAX_MAP_COUNT
;
736 unsigned long sysctl_user_reserve_kbytes __read_mostly
= 1UL << 17; /* 128MB */
737 unsigned long sysctl_admin_reserve_kbytes __read_mostly
= 1UL << 13; /* 8MB */
739 int overcommit_ratio_handler(struct ctl_table
*table
, int write
, void *buffer
,
740 size_t *lenp
, loff_t
*ppos
)
744 ret
= proc_dointvec(table
, write
, buffer
, lenp
, ppos
);
745 if (ret
== 0 && write
)
746 sysctl_overcommit_kbytes
= 0;
750 static void sync_overcommit_as(struct work_struct
*dummy
)
752 percpu_counter_sync(&vm_committed_as
);
755 int overcommit_policy_handler(struct ctl_table
*table
, int write
, void *buffer
,
756 size_t *lenp
, loff_t
*ppos
)
763 * The deviation of sync_overcommit_as could be big with loose policy
764 * like OVERCOMMIT_ALWAYS/OVERCOMMIT_GUESS. When changing policy to
765 * strict OVERCOMMIT_NEVER, we need to reduce the deviation to comply
766 * with the strict "NEVER", and to avoid possible race condtion (even
767 * though user usually won't too frequently do the switching to policy
768 * OVERCOMMIT_NEVER), the switch is done in the following order:
769 * 1. changing the batch
770 * 2. sync percpu count on each CPU
771 * 3. switch the policy
775 t
.data
= &new_policy
;
776 ret
= proc_dointvec_minmax(&t
, write
, buffer
, lenp
, ppos
);
780 mm_compute_batch(new_policy
);
781 if (new_policy
== OVERCOMMIT_NEVER
)
782 schedule_on_each_cpu(sync_overcommit_as
);
783 sysctl_overcommit_memory
= new_policy
;
785 ret
= proc_dointvec_minmax(table
, write
, buffer
, lenp
, ppos
);
791 int overcommit_kbytes_handler(struct ctl_table
*table
, int write
, void *buffer
,
792 size_t *lenp
, loff_t
*ppos
)
796 ret
= proc_doulongvec_minmax(table
, write
, buffer
, lenp
, ppos
);
797 if (ret
== 0 && write
)
798 sysctl_overcommit_ratio
= 0;
803 * Committed memory limit enforced when OVERCOMMIT_NEVER policy is used
805 unsigned long vm_commit_limit(void)
807 unsigned long allowed
;
809 if (sysctl_overcommit_kbytes
)
810 allowed
= sysctl_overcommit_kbytes
>> (PAGE_SHIFT
- 10);
812 allowed
= ((totalram_pages() - hugetlb_total_pages())
813 * sysctl_overcommit_ratio
/ 100);
814 allowed
+= total_swap_pages
;
820 * Make sure vm_committed_as in one cacheline and not cacheline shared with
821 * other variables. It can be updated by several CPUs frequently.
823 struct percpu_counter vm_committed_as ____cacheline_aligned_in_smp
;
826 * The global memory commitment made in the system can be a metric
827 * that can be used to drive ballooning decisions when Linux is hosted
828 * as a guest. On Hyper-V, the host implements a policy engine for dynamically
829 * balancing memory across competing virtual machines that are hosted.
830 * Several metrics drive this policy engine including the guest reported
833 * The time cost of this is very low for small platforms, and for big
834 * platform like a 2S/36C/72T Skylake server, in worst case where
835 * vm_committed_as's spinlock is under severe contention, the time cost
836 * could be about 30~40 microseconds.
838 unsigned long vm_memory_committed(void)
840 return percpu_counter_sum_positive(&vm_committed_as
);
842 EXPORT_SYMBOL_GPL(vm_memory_committed
);
845 * Check that a process has enough memory to allocate a new virtual
846 * mapping. 0 means there is enough memory for the allocation to
847 * succeed and -ENOMEM implies there is not.
849 * We currently support three overcommit policies, which are set via the
850 * vm.overcommit_memory sysctl. See Documentation/vm/overcommit-accounting.rst
852 * Strict overcommit modes added 2002 Feb 26 by Alan Cox.
853 * Additional code 2002 Jul 20 by Robert Love.
855 * cap_sys_admin is 1 if the process has admin privileges, 0 otherwise.
857 * Note this is a helper function intended to be used by LSMs which
858 * wish to use this logic.
860 int __vm_enough_memory(struct mm_struct
*mm
, long pages
, int cap_sys_admin
)
864 vm_acct_memory(pages
);
867 * Sometimes we want to use more memory than we have
869 if (sysctl_overcommit_memory
== OVERCOMMIT_ALWAYS
)
872 if (sysctl_overcommit_memory
== OVERCOMMIT_GUESS
) {
873 if (pages
> totalram_pages() + total_swap_pages
)
878 allowed
= vm_commit_limit();
880 * Reserve some for root
883 allowed
-= sysctl_admin_reserve_kbytes
>> (PAGE_SHIFT
- 10);
886 * Don't let a single process grow so big a user can't recover
889 long reserve
= sysctl_user_reserve_kbytes
>> (PAGE_SHIFT
- 10);
891 allowed
-= min_t(long, mm
->total_vm
/ 32, reserve
);
894 if (percpu_counter_read_positive(&vm_committed_as
) < allowed
)
897 vm_unacct_memory(pages
);
903 * get_cmdline() - copy the cmdline value to a buffer.
904 * @task: the task whose cmdline value to copy.
905 * @buffer: the buffer to copy to.
906 * @buflen: the length of the buffer. Larger cmdline values are truncated
909 * Return: the size of the cmdline field copied. Note that the copy does
910 * not guarantee an ending NULL byte.
912 int get_cmdline(struct task_struct
*task
, char *buffer
, int buflen
)
916 struct mm_struct
*mm
= get_task_mm(task
);
917 unsigned long arg_start
, arg_end
, env_start
, env_end
;
921 goto out_mm
; /* Shh! No looking before we're done */
923 spin_lock(&mm
->arg_lock
);
924 arg_start
= mm
->arg_start
;
925 arg_end
= mm
->arg_end
;
926 env_start
= mm
->env_start
;
927 env_end
= mm
->env_end
;
928 spin_unlock(&mm
->arg_lock
);
930 len
= arg_end
- arg_start
;
935 res
= access_process_vm(task
, arg_start
, buffer
, len
, FOLL_FORCE
);
938 * If the nul at the end of args has been overwritten, then
939 * assume application is using setproctitle(3).
941 if (res
> 0 && buffer
[res
-1] != '\0' && len
< buflen
) {
942 len
= strnlen(buffer
, res
);
946 len
= env_end
- env_start
;
947 if (len
> buflen
- res
)
949 res
+= access_process_vm(task
, env_start
,
952 res
= strnlen(buffer
, res
);
961 int __weak
memcmp_pages(struct page
*page1
, struct page
*page2
)
966 addr1
= kmap_atomic(page1
);
967 addr2
= kmap_atomic(page2
);
968 ret
= memcmp(addr1
, addr2
, PAGE_SIZE
);
969 kunmap_atomic(addr2
);
970 kunmap_atomic(addr1
);