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.
74 * Return: source string if it is in .rodata section otherwise
75 * fallback to kstrdup.
77 const char *kstrdup_const(const char *s
, gfp_t gfp
)
79 if (is_kernel_rodata((unsigned long)s
))
82 return kstrdup(s
, gfp
);
84 EXPORT_SYMBOL(kstrdup_const
);
87 * kstrndup - allocate space for and copy an existing string
88 * @s: the string to duplicate
89 * @max: read at most @max chars from @s
90 * @gfp: the GFP mask used in the kmalloc() call when allocating memory
92 * Note: Use kmemdup_nul() instead if the size is known exactly.
94 * Return: newly allocated copy of @s or %NULL in case of error
96 char *kstrndup(const char *s
, size_t max
, gfp_t gfp
)
104 len
= strnlen(s
, max
);
105 buf
= kmalloc_track_caller(len
+1, gfp
);
112 EXPORT_SYMBOL(kstrndup
);
115 * kmemdup - duplicate region of memory
117 * @src: memory region to duplicate
118 * @len: memory region length
119 * @gfp: GFP mask to use
121 * Return: newly allocated copy of @src or %NULL in case of error
123 void *kmemdup(const void *src
, size_t len
, gfp_t gfp
)
127 p
= kmalloc_track_caller(len
, gfp
);
132 EXPORT_SYMBOL(kmemdup
);
135 * kmemdup_nul - Create a NUL-terminated string from unterminated data
136 * @s: The data to stringify
137 * @len: The size of the data
138 * @gfp: the GFP mask used in the kmalloc() call when allocating memory
140 * Return: newly allocated copy of @s with NUL-termination or %NULL in
143 char *kmemdup_nul(const char *s
, size_t len
, gfp_t gfp
)
150 buf
= kmalloc_track_caller(len
+ 1, gfp
);
157 EXPORT_SYMBOL(kmemdup_nul
);
160 * memdup_user - duplicate memory region from user space
162 * @src: source address in user space
163 * @len: number of bytes to copy
165 * Return: an ERR_PTR() on failure. Result is physically
166 * contiguous, to be freed by kfree().
168 void *memdup_user(const void __user
*src
, size_t len
)
172 p
= kmalloc_track_caller(len
, GFP_USER
| __GFP_NOWARN
);
174 return ERR_PTR(-ENOMEM
);
176 if (copy_from_user(p
, src
, len
)) {
178 return ERR_PTR(-EFAULT
);
183 EXPORT_SYMBOL(memdup_user
);
186 * vmemdup_user - duplicate memory region from user space
188 * @src: source address in user space
189 * @len: number of bytes to copy
191 * Return: an ERR_PTR() on failure. Result may be not
192 * physically contiguous. Use kvfree() to free.
194 void *vmemdup_user(const void __user
*src
, size_t len
)
198 p
= kvmalloc(len
, GFP_USER
);
200 return ERR_PTR(-ENOMEM
);
202 if (copy_from_user(p
, src
, len
)) {
204 return ERR_PTR(-EFAULT
);
209 EXPORT_SYMBOL(vmemdup_user
);
212 * strndup_user - duplicate an existing string from user space
213 * @s: The string to duplicate
214 * @n: Maximum number of bytes to copy, including the trailing NUL.
216 * Return: newly allocated copy of @s or an ERR_PTR() in case of error
218 char *strndup_user(const char __user
*s
, long n
)
223 length
= strnlen_user(s
, n
);
226 return ERR_PTR(-EFAULT
);
229 return ERR_PTR(-EINVAL
);
231 p
= memdup_user(s
, length
);
236 p
[length
- 1] = '\0';
240 EXPORT_SYMBOL(strndup_user
);
243 * memdup_user_nul - duplicate memory region from user space and NUL-terminate
245 * @src: source address in user space
246 * @len: number of bytes to copy
248 * Return: an ERR_PTR() on failure.
250 void *memdup_user_nul(const void __user
*src
, size_t len
)
255 * Always use GFP_KERNEL, since copy_from_user() can sleep and
256 * cause pagefault, which makes it pointless to use GFP_NOFS
259 p
= kmalloc_track_caller(len
+ 1, GFP_KERNEL
);
261 return ERR_PTR(-ENOMEM
);
263 if (copy_from_user(p
, src
, len
)) {
265 return ERR_PTR(-EFAULT
);
271 EXPORT_SYMBOL(memdup_user_nul
);
273 void __vma_link_list(struct mm_struct
*mm
, struct vm_area_struct
*vma
,
274 struct vm_area_struct
*prev
, struct rb_node
*rb_parent
)
276 struct vm_area_struct
*next
;
280 next
= prev
->vm_next
;
285 next
= rb_entry(rb_parent
,
286 struct vm_area_struct
, vm_rb
);
295 void __vma_unlink_list(struct mm_struct
*mm
, struct vm_area_struct
*vma
)
297 struct vm_area_struct
*prev
, *next
;
302 prev
->vm_next
= next
;
306 next
->vm_prev
= prev
;
309 /* Check if the vma is being used as a stack by this task */
310 int vma_is_stack_for_current(struct vm_area_struct
*vma
)
312 struct task_struct
* __maybe_unused t
= current
;
314 return (vma
->vm_start
<= KSTK_ESP(t
) && vma
->vm_end
>= KSTK_ESP(t
));
317 #ifndef STACK_RND_MASK
318 #define STACK_RND_MASK (0x7ff >> (PAGE_SHIFT - 12)) /* 8MB of VA */
321 unsigned long randomize_stack_top(unsigned long stack_top
)
323 unsigned long random_variable
= 0;
325 if (current
->flags
& PF_RANDOMIZE
) {
326 random_variable
= get_random_long();
327 random_variable
&= STACK_RND_MASK
;
328 random_variable
<<= PAGE_SHIFT
;
330 #ifdef CONFIG_STACK_GROWSUP
331 return PAGE_ALIGN(stack_top
) + random_variable
;
333 return PAGE_ALIGN(stack_top
) - random_variable
;
337 #ifdef CONFIG_ARCH_WANT_DEFAULT_TOPDOWN_MMAP_LAYOUT
338 unsigned long arch_randomize_brk(struct mm_struct
*mm
)
340 /* Is the current task 32bit ? */
341 if (!IS_ENABLED(CONFIG_64BIT
) || is_compat_task())
342 return randomize_page(mm
->brk
, SZ_32M
);
344 return randomize_page(mm
->brk
, SZ_1G
);
347 unsigned long arch_mmap_rnd(void)
351 #ifdef CONFIG_HAVE_ARCH_MMAP_RND_COMPAT_BITS
352 if (is_compat_task())
353 rnd
= get_random_long() & ((1UL << mmap_rnd_compat_bits
) - 1);
355 #endif /* CONFIG_HAVE_ARCH_MMAP_RND_COMPAT_BITS */
356 rnd
= get_random_long() & ((1UL << mmap_rnd_bits
) - 1);
358 return rnd
<< PAGE_SHIFT
;
361 static int mmap_is_legacy(struct rlimit
*rlim_stack
)
363 if (current
->personality
& ADDR_COMPAT_LAYOUT
)
366 if (rlim_stack
->rlim_cur
== RLIM_INFINITY
)
369 return sysctl_legacy_va_layout
;
373 * Leave enough space between the mmap area and the stack to honour ulimit in
374 * the face of randomisation.
376 #define MIN_GAP (SZ_128M)
377 #define MAX_GAP (STACK_TOP / 6 * 5)
379 static unsigned long mmap_base(unsigned long rnd
, struct rlimit
*rlim_stack
)
381 unsigned long gap
= rlim_stack
->rlim_cur
;
382 unsigned long pad
= stack_guard_gap
;
384 /* Account for stack randomization if necessary */
385 if (current
->flags
& PF_RANDOMIZE
)
386 pad
+= (STACK_RND_MASK
<< PAGE_SHIFT
);
388 /* Values close to RLIM_INFINITY can overflow. */
394 else if (gap
> MAX_GAP
)
397 return PAGE_ALIGN(STACK_TOP
- gap
- rnd
);
400 void arch_pick_mmap_layout(struct mm_struct
*mm
, struct rlimit
*rlim_stack
)
402 unsigned long random_factor
= 0UL;
404 if (current
->flags
& PF_RANDOMIZE
)
405 random_factor
= arch_mmap_rnd();
407 if (mmap_is_legacy(rlim_stack
)) {
408 mm
->mmap_base
= TASK_UNMAPPED_BASE
+ random_factor
;
409 mm
->get_unmapped_area
= arch_get_unmapped_area
;
411 mm
->mmap_base
= mmap_base(random_factor
, rlim_stack
);
412 mm
->get_unmapped_area
= arch_get_unmapped_area_topdown
;
415 #elif defined(CONFIG_MMU) && !defined(HAVE_ARCH_PICK_MMAP_LAYOUT)
416 void arch_pick_mmap_layout(struct mm_struct
*mm
, struct rlimit
*rlim_stack
)
418 mm
->mmap_base
= TASK_UNMAPPED_BASE
;
419 mm
->get_unmapped_area
= arch_get_unmapped_area
;
424 * __account_locked_vm - account locked pages to an mm's locked_vm
425 * @mm: mm to account against
426 * @pages: number of pages to account
427 * @inc: %true if @pages should be considered positive, %false if not
428 * @task: task used to check RLIMIT_MEMLOCK
429 * @bypass_rlim: %true if checking RLIMIT_MEMLOCK should be skipped
431 * Assumes @task and @mm are valid (i.e. at least one reference on each), and
432 * that mmap_sem is held as writer.
436 * * -ENOMEM if RLIMIT_MEMLOCK would be exceeded.
438 int __account_locked_vm(struct mm_struct
*mm
, unsigned long pages
, bool inc
,
439 struct task_struct
*task
, bool bypass_rlim
)
441 unsigned long locked_vm
, limit
;
444 lockdep_assert_held_write(&mm
->mmap_sem
);
446 locked_vm
= mm
->locked_vm
;
449 limit
= task_rlimit(task
, RLIMIT_MEMLOCK
) >> PAGE_SHIFT
;
450 if (locked_vm
+ pages
> limit
)
454 mm
->locked_vm
= locked_vm
+ pages
;
456 WARN_ON_ONCE(pages
> locked_vm
);
457 mm
->locked_vm
= locked_vm
- pages
;
460 pr_debug("%s: [%d] caller %ps %c%lu %lu/%lu%s\n", __func__
, task
->pid
,
461 (void *)_RET_IP_
, (inc
) ? '+' : '-', pages
<< PAGE_SHIFT
,
462 locked_vm
<< PAGE_SHIFT
, task_rlimit(task
, RLIMIT_MEMLOCK
),
463 ret
? " - exceeded" : "");
467 EXPORT_SYMBOL_GPL(__account_locked_vm
);
470 * account_locked_vm - account locked pages to an mm's locked_vm
471 * @mm: mm to account against, may be NULL
472 * @pages: number of pages to account
473 * @inc: %true if @pages should be considered positive, %false if not
475 * Assumes a non-NULL @mm is valid (i.e. at least one reference on it).
478 * * 0 on success, or if mm is NULL
479 * * -ENOMEM if RLIMIT_MEMLOCK would be exceeded.
481 int account_locked_vm(struct mm_struct
*mm
, unsigned long pages
, bool inc
)
485 if (pages
== 0 || !mm
)
488 down_write(&mm
->mmap_sem
);
489 ret
= __account_locked_vm(mm
, pages
, inc
, current
,
490 capable(CAP_IPC_LOCK
));
491 up_write(&mm
->mmap_sem
);
495 EXPORT_SYMBOL_GPL(account_locked_vm
);
497 unsigned long vm_mmap_pgoff(struct file
*file
, unsigned long addr
,
498 unsigned long len
, unsigned long prot
,
499 unsigned long flag
, unsigned long pgoff
)
502 struct mm_struct
*mm
= current
->mm
;
503 unsigned long populate
;
506 ret
= security_mmap_file(file
, prot
, flag
);
508 if (down_write_killable(&mm
->mmap_sem
))
510 ret
= do_mmap_pgoff(file
, addr
, len
, prot
, flag
, pgoff
,
512 up_write(&mm
->mmap_sem
);
513 userfaultfd_unmap_complete(mm
, &uf
);
515 mm_populate(ret
, populate
);
520 unsigned long vm_mmap(struct file
*file
, unsigned long addr
,
521 unsigned long len
, unsigned long prot
,
522 unsigned long flag
, unsigned long offset
)
524 if (unlikely(offset
+ PAGE_ALIGN(len
) < offset
))
526 if (unlikely(offset_in_page(offset
)))
529 return vm_mmap_pgoff(file
, addr
, len
, prot
, flag
, offset
>> PAGE_SHIFT
);
531 EXPORT_SYMBOL(vm_mmap
);
534 * kvmalloc_node - attempt to allocate physically contiguous memory, but upon
535 * failure, fall back to non-contiguous (vmalloc) allocation.
536 * @size: size of the request.
537 * @flags: gfp mask for the allocation - must be compatible (superset) with GFP_KERNEL.
538 * @node: numa node to allocate from
540 * Uses kmalloc to get the memory but if the allocation fails then falls back
541 * to the vmalloc allocator. Use kvfree for freeing the memory.
543 * Reclaim modifiers - __GFP_NORETRY and __GFP_NOFAIL are not supported.
544 * __GFP_RETRY_MAYFAIL is supported, and it should be used only if kmalloc is
545 * preferable to the vmalloc fallback, due to visible performance drawbacks.
547 * Please note that any use of gfp flags outside of GFP_KERNEL is careful to not
548 * fall back to vmalloc.
550 * Return: pointer to the allocated memory of %NULL in case of failure
552 void *kvmalloc_node(size_t size
, gfp_t flags
, int node
)
554 gfp_t kmalloc_flags
= flags
;
558 * vmalloc uses GFP_KERNEL for some internal allocations (e.g page tables)
559 * so the given set of flags has to be compatible.
561 if ((flags
& GFP_KERNEL
) != GFP_KERNEL
)
562 return kmalloc_node(size
, flags
, node
);
565 * We want to attempt a large physically contiguous block first because
566 * it is less likely to fragment multiple larger blocks and therefore
567 * contribute to a long term fragmentation less than vmalloc fallback.
568 * However make sure that larger requests are not too disruptive - no
569 * OOM killer and no allocation failure warnings as we have a fallback.
571 if (size
> PAGE_SIZE
) {
572 kmalloc_flags
|= __GFP_NOWARN
;
574 if (!(kmalloc_flags
& __GFP_RETRY_MAYFAIL
))
575 kmalloc_flags
|= __GFP_NORETRY
;
578 ret
= kmalloc_node(size
, kmalloc_flags
, node
);
581 * It doesn't really make sense to fallback to vmalloc for sub page
584 if (ret
|| size
<= PAGE_SIZE
)
587 return __vmalloc_node_flags_caller(size
, node
, flags
,
588 __builtin_return_address(0));
590 EXPORT_SYMBOL(kvmalloc_node
);
593 * kvfree() - Free memory.
594 * @addr: Pointer to allocated memory.
596 * kvfree frees memory allocated by any of vmalloc(), kmalloc() or kvmalloc().
597 * It is slightly more efficient to use kfree() or vfree() if you are certain
598 * that you know which one to use.
600 * Context: Either preemptible task context or not-NMI interrupt.
602 void kvfree(const void *addr
)
604 if (is_vmalloc_addr(addr
))
609 EXPORT_SYMBOL(kvfree
);
611 static inline void *__page_rmapping(struct page
*page
)
613 unsigned long mapping
;
615 mapping
= (unsigned long)page
->mapping
;
616 mapping
&= ~PAGE_MAPPING_FLAGS
;
618 return (void *)mapping
;
621 /* Neutral page->mapping pointer to address_space or anon_vma or other */
622 void *page_rmapping(struct page
*page
)
624 page
= compound_head(page
);
625 return __page_rmapping(page
);
629 * Return true if this page is mapped into pagetables.
630 * For compound page it returns true if any subpage of compound page is mapped.
632 bool page_mapped(struct page
*page
)
636 if (likely(!PageCompound(page
)))
637 return atomic_read(&page
->_mapcount
) >= 0;
638 page
= compound_head(page
);
639 if (atomic_read(compound_mapcount_ptr(page
)) >= 0)
643 for (i
= 0; i
< compound_nr(page
); i
++) {
644 if (atomic_read(&page
[i
]._mapcount
) >= 0)
649 EXPORT_SYMBOL(page_mapped
);
651 struct anon_vma
*page_anon_vma(struct page
*page
)
653 unsigned long mapping
;
655 page
= compound_head(page
);
656 mapping
= (unsigned long)page
->mapping
;
657 if ((mapping
& PAGE_MAPPING_FLAGS
) != PAGE_MAPPING_ANON
)
659 return __page_rmapping(page
);
662 struct address_space
*page_mapping(struct page
*page
)
664 struct address_space
*mapping
;
666 page
= compound_head(page
);
668 /* This happens if someone calls flush_dcache_page on slab page */
669 if (unlikely(PageSlab(page
)))
672 if (unlikely(PageSwapCache(page
))) {
675 entry
.val
= page_private(page
);
676 return swap_address_space(entry
);
679 mapping
= page
->mapping
;
680 if ((unsigned long)mapping
& PAGE_MAPPING_ANON
)
683 return (void *)((unsigned long)mapping
& ~PAGE_MAPPING_FLAGS
);
685 EXPORT_SYMBOL(page_mapping
);
688 * For file cache pages, return the address_space, otherwise return NULL
690 struct address_space
*page_mapping_file(struct page
*page
)
692 if (unlikely(PageSwapCache(page
)))
694 return page_mapping(page
);
697 /* Slow path of page_mapcount() for compound pages */
698 int __page_mapcount(struct page
*page
)
702 ret
= atomic_read(&page
->_mapcount
) + 1;
704 * For file THP page->_mapcount contains total number of mapping
705 * of the page: no need to look into compound_mapcount.
707 if (!PageAnon(page
) && !PageHuge(page
))
709 page
= compound_head(page
);
710 ret
+= atomic_read(compound_mapcount_ptr(page
)) + 1;
711 if (PageDoubleMap(page
))
715 EXPORT_SYMBOL_GPL(__page_mapcount
);
717 int sysctl_overcommit_memory __read_mostly
= OVERCOMMIT_GUESS
;
718 int sysctl_overcommit_ratio __read_mostly
= 50;
719 unsigned long sysctl_overcommit_kbytes __read_mostly
;
720 int sysctl_max_map_count __read_mostly
= DEFAULT_MAX_MAP_COUNT
;
721 unsigned long sysctl_user_reserve_kbytes __read_mostly
= 1UL << 17; /* 128MB */
722 unsigned long sysctl_admin_reserve_kbytes __read_mostly
= 1UL << 13; /* 8MB */
724 int overcommit_ratio_handler(struct ctl_table
*table
, int write
,
725 void __user
*buffer
, size_t *lenp
,
730 ret
= proc_dointvec(table
, write
, buffer
, lenp
, ppos
);
731 if (ret
== 0 && write
)
732 sysctl_overcommit_kbytes
= 0;
736 int overcommit_kbytes_handler(struct ctl_table
*table
, int write
,
737 void __user
*buffer
, size_t *lenp
,
742 ret
= proc_doulongvec_minmax(table
, write
, buffer
, lenp
, ppos
);
743 if (ret
== 0 && write
)
744 sysctl_overcommit_ratio
= 0;
749 * Committed memory limit enforced when OVERCOMMIT_NEVER policy is used
751 unsigned long vm_commit_limit(void)
753 unsigned long allowed
;
755 if (sysctl_overcommit_kbytes
)
756 allowed
= sysctl_overcommit_kbytes
>> (PAGE_SHIFT
- 10);
758 allowed
= ((totalram_pages() - hugetlb_total_pages())
759 * sysctl_overcommit_ratio
/ 100);
760 allowed
+= total_swap_pages
;
766 * Make sure vm_committed_as in one cacheline and not cacheline shared with
767 * other variables. It can be updated by several CPUs frequently.
769 struct percpu_counter vm_committed_as ____cacheline_aligned_in_smp
;
772 * The global memory commitment made in the system can be a metric
773 * that can be used to drive ballooning decisions when Linux is hosted
774 * as a guest. On Hyper-V, the host implements a policy engine for dynamically
775 * balancing memory across competing virtual machines that are hosted.
776 * Several metrics drive this policy engine including the guest reported
779 unsigned long vm_memory_committed(void)
781 return percpu_counter_read_positive(&vm_committed_as
);
783 EXPORT_SYMBOL_GPL(vm_memory_committed
);
786 * Check that a process has enough memory to allocate a new virtual
787 * mapping. 0 means there is enough memory for the allocation to
788 * succeed and -ENOMEM implies there is not.
790 * We currently support three overcommit policies, which are set via the
791 * vm.overcommit_memory sysctl. See Documentation/vm/overcommit-accounting.rst
793 * Strict overcommit modes added 2002 Feb 26 by Alan Cox.
794 * Additional code 2002 Jul 20 by Robert Love.
796 * cap_sys_admin is 1 if the process has admin privileges, 0 otherwise.
798 * Note this is a helper function intended to be used by LSMs which
799 * wish to use this logic.
801 int __vm_enough_memory(struct mm_struct
*mm
, long pages
, int cap_sys_admin
)
805 VM_WARN_ONCE(percpu_counter_read(&vm_committed_as
) <
806 -(s64
)vm_committed_as_batch
* num_online_cpus(),
807 "memory commitment underflow");
809 vm_acct_memory(pages
);
812 * Sometimes we want to use more memory than we have
814 if (sysctl_overcommit_memory
== OVERCOMMIT_ALWAYS
)
817 if (sysctl_overcommit_memory
== OVERCOMMIT_GUESS
) {
818 if (pages
> totalram_pages() + total_swap_pages
)
823 allowed
= vm_commit_limit();
825 * Reserve some for root
828 allowed
-= sysctl_admin_reserve_kbytes
>> (PAGE_SHIFT
- 10);
831 * Don't let a single process grow so big a user can't recover
834 long reserve
= sysctl_user_reserve_kbytes
>> (PAGE_SHIFT
- 10);
836 allowed
-= min_t(long, mm
->total_vm
/ 32, reserve
);
839 if (percpu_counter_read_positive(&vm_committed_as
) < allowed
)
842 vm_unacct_memory(pages
);
848 * get_cmdline() - copy the cmdline value to a buffer.
849 * @task: the task whose cmdline value to copy.
850 * @buffer: the buffer to copy to.
851 * @buflen: the length of the buffer. Larger cmdline values are truncated
854 * Return: the size of the cmdline field copied. Note that the copy does
855 * not guarantee an ending NULL byte.
857 int get_cmdline(struct task_struct
*task
, char *buffer
, int buflen
)
861 struct mm_struct
*mm
= get_task_mm(task
);
862 unsigned long arg_start
, arg_end
, env_start
, env_end
;
866 goto out_mm
; /* Shh! No looking before we're done */
868 spin_lock(&mm
->arg_lock
);
869 arg_start
= mm
->arg_start
;
870 arg_end
= mm
->arg_end
;
871 env_start
= mm
->env_start
;
872 env_end
= mm
->env_end
;
873 spin_unlock(&mm
->arg_lock
);
875 len
= arg_end
- arg_start
;
880 res
= access_process_vm(task
, arg_start
, buffer
, len
, FOLL_FORCE
);
883 * If the nul at the end of args has been overwritten, then
884 * assume application is using setproctitle(3).
886 if (res
> 0 && buffer
[res
-1] != '\0' && len
< buflen
) {
887 len
= strnlen(buffer
, res
);
891 len
= env_end
- env_start
;
892 if (len
> buflen
- res
)
894 res
+= access_process_vm(task
, env_start
,
897 res
= strnlen(buffer
, res
);
906 int memcmp_pages(struct page
*page1
, struct page
*page2
)
911 addr1
= kmap_atomic(page1
);
912 addr2
= kmap_atomic(page2
);
913 ret
= memcmp(addr1
, addr2
, PAGE_SIZE
);
914 kunmap_atomic(addr2
);
915 kunmap_atomic(addr1
);