mm/util.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 #include <linux/mm.h>
   3 #include <linux/slab.h>
   4 #include <linux/string.h>
   5 #include <linux/compiler.h>
   6 #include <linux/export.h>
   7 #include <linux/err.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/random.h>
  21
  22 #include <linux/uaccess.h>
  23
  24 #include "internal.h"
  25
  26 /**
  27  * kfree_const - conditionally free memory
  28  * @x: pointer to the memory
  29  *
  30  * Function calls kfree only if @x is not in .rodata section.
  31  */
  32 void kfree_const(const void *x)
  33 {
  34         if (!is_kernel_rodata((unsigned long)x))
  35                 kfree(x);
  36 }
  37 EXPORT_SYMBOL(kfree_const);
  38
  39 /**
  40  * kstrdup - allocate space for and copy an existing string
  41  * @s: the string to duplicate
  42  * @gfp: the GFP mask used in the kmalloc() call when allocating memory
  43  *
  44  * Return: newly allocated copy of @s or %NULL in case of error
  45  */
  46 char *kstrdup(const char *s, gfp_t gfp)
  47 {
  48         size_t len;
  49         char *buf;
  50
  51         if (!s)
  52                 return NULL;
  53
  54         len = strlen(s) + 1;
  55         buf = kmalloc_track_caller(len, gfp);
  56         if (buf)
  57                 memcpy(buf, s, len);
  58         return buf;
  59 }
  60 EXPORT_SYMBOL(kstrdup);
  61
  62 /**
  63  * kstrdup_const - conditionally duplicate an existing const string
  64  * @s: the string to duplicate
  65  * @gfp: the GFP mask used in the kmalloc() call when allocating memory
  66  *
  67  * Note: Strings allocated by kstrdup_const should be freed by kfree_const.
  68  *
  69  * Return: source string if it is in .rodata section otherwise
  70  * fallback to kstrdup.
  71  */
  72 const char *kstrdup_const(const char *s, gfp_t gfp)
  73 {
  74         if (is_kernel_rodata((unsigned long)s))
  75                 return s;
  76
  77         return kstrdup(s, gfp);
  78 }
  79 EXPORT_SYMBOL(kstrdup_const);
  80
  81 /**
  82  * kstrndup - allocate space for and copy an existing string
  83  * @s: the string to duplicate
  84  * @max: read at most @max chars from @s
  85  * @gfp: the GFP mask used in the kmalloc() call when allocating memory
  86  *
  87  * Note: Use kmemdup_nul() instead if the size is known exactly.
  88  *
  89  * Return: newly allocated copy of @s or %NULL in case of error
  90  */
  91 char *kstrndup(const char *s, size_t max, gfp_t gfp)
  92 {
  93         size_t len;
  94         char *buf;
  95
  96         if (!s)
  97                 return NULL;
  98
  99         len = strnlen(s, max);
 100         buf = kmalloc_track_caller(len+1, gfp);
 101         if (buf) {
 102                 memcpy(buf, s, len);
 103                 buf[len] = '\0';
 104         }
 105         return buf;
 106 }
 107 EXPORT_SYMBOL(kstrndup);
 108
 109 /**
 110  * kmemdup - duplicate region of memory
 111  *
 112  * @src: memory region to duplicate
 113  * @len: memory region length
 114  * @gfp: GFP mask to use
 115  *
 116  * Return: newly allocated copy of @src or %NULL in case of error
 117  */
 118 void *kmemdup(const void *src, size_t len, gfp_t gfp)
 119 {
 120         void *p;
 121
 122         p = kmalloc_track_caller(len, gfp);
 123         if (p)
 124                 memcpy(p, src, len);
 125         return p;
 126 }
 127 EXPORT_SYMBOL(kmemdup);
 128
 129 /**
 130  * kmemdup_nul - Create a NUL-terminated string from unterminated data
 131  * @s: The data to stringify
 132  * @len: The size of the data
 133  * @gfp: the GFP mask used in the kmalloc() call when allocating memory
 134  *
 135  * Return: newly allocated copy of @s with NUL-termination or %NULL in
 136  * case of error
 137  */
 138 char *kmemdup_nul(const char *s, size_t len, gfp_t gfp)
 139 {
 140         char *buf;
 141
 142         if (!s)
 143                 return NULL;
 144
 145         buf = kmalloc_track_caller(len + 1, gfp);
 146         if (buf) {
 147                 memcpy(buf, s, len);
 148                 buf[len] = '\0';
 149         }
 150         return buf;
 151 }
 152 EXPORT_SYMBOL(kmemdup_nul);
 153
 154 /**
 155  * memdup_user - duplicate memory region from user space
 156  *
 157  * @src: source address in user space
 158  * @len: number of bytes to copy
 159  *
 160  * Return: an ERR_PTR() on failure.  Result is physically
 161  * contiguous, to be freed by kfree().
 162  */
 163 void *memdup_user(const void __user *src, size_t len)
 164 {
 165         void *p;
 166
 167         p = kmalloc_track_caller(len, GFP_USER | __GFP_NOWARN);
 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  * vmemdup_user - duplicate memory region from user space
 182  *
 183  * @src: source address in user space
 184  * @len: number of bytes to copy
 185  *
 186  * Return: an ERR_PTR() on failure.  Result may be not
 187  * physically contiguous.  Use kvfree() to free.
 188  */
 189 void *vmemdup_user(const void __user *src, size_t len)
 190 {
 191         void *p;
 192
 193         p = kvmalloc(len, GFP_USER);
 194         if (!p)
 195                 return ERR_PTR(-ENOMEM);
 196
 197         if (copy_from_user(p, src, len)) {
 198                 kvfree(p);
 199                 return ERR_PTR(-EFAULT);
 200         }
 201
 202         return p;
 203 }
 204 EXPORT_SYMBOL(vmemdup_user);
 205
 206 /**
 207  * strndup_user - duplicate an existing string from user space
 208  * @s: The string to duplicate
 209  * @n: Maximum number of bytes to copy, including the trailing NUL.
 210  *
 211  * Return: newly allocated copy of @s or an ERR_PTR() in case of error
 212  */
 213 char *strndup_user(const char __user *s, long n)
 214 {
 215         char *p;
 216         long length;
 217
 218         length = strnlen_user(s, n);
 219
 220         if (!length)
 221                 return ERR_PTR(-EFAULT);
 222
 223         if (length > n)
 224                 return ERR_PTR(-EINVAL);
 225
 226         p = memdup_user(s, length);
 227
 228         if (IS_ERR(p))
 229                 return p;
 230
 231         p[length - 1] = '\0';
 232
 233         return p;
 234 }
 235 EXPORT_SYMBOL(strndup_user);
 236
 237 /**
 238  * memdup_user_nul - duplicate memory region from user space and NUL-terminate
 239  *
 240  * @src: source address in user space
 241  * @len: number of bytes to copy
 242  *
 243  * Return: an ERR_PTR() on failure.
 244  */
 245 void *memdup_user_nul(const void __user *src, size_t len)
 246 {
 247         char *p;
 248
 249         /*
 250          * Always use GFP_KERNEL, since copy_from_user() can sleep and
 251          * cause pagefault, which makes it pointless to use GFP_NOFS
 252          * or GFP_ATOMIC.
 253          */
 254         p = kmalloc_track_caller(len + 1, GFP_KERNEL);
 255         if (!p)
 256                 return ERR_PTR(-ENOMEM);
 257
 258         if (copy_from_user(p, src, len)) {
 259                 kfree(p);
 260                 return ERR_PTR(-EFAULT);
 261         }
 262         p[len] = '\0';
 263
 264         return p;
 265 }
 266 EXPORT_SYMBOL(memdup_user_nul);
 267
 268 void __vma_link_list(struct mm_struct *mm, struct vm_area_struct *vma,
 269                 struct vm_area_struct *prev, struct rb_node *rb_parent)
 270 {
 271         struct vm_area_struct *next;
 272
 273         vma->vm_prev = prev;
 274         if (prev) {
 275                 next = prev->vm_next;
 276                 prev->vm_next = vma;
 277         } else {
 278                 mm->mmap = vma;
 279                 if (rb_parent)
 280                         next = rb_entry(rb_parent,
 281                                         struct vm_area_struct, vm_rb);
 282                 else
 283                         next = NULL;
 284         }
 285         vma->vm_next = next;
 286         if (next)
 287                 next->vm_prev = vma;
 288 }
 289
 290 /* Check if the vma is being used as a stack by this task */
 291 int vma_is_stack_for_current(struct vm_area_struct *vma)
 292 {
 293         struct task_struct * __maybe_unused t = current;
 294
 295         return (vma->vm_start <= KSTK_ESP(t) && vma->vm_end >= KSTK_ESP(t));
 296 }
 297
 298 #ifndef STACK_RND_MASK
 299 #define STACK_RND_MASK (0x7ff >> (PAGE_SHIFT - 12))     /* 8MB of VA */
 300 #endif
 301
 302 unsigned long randomize_stack_top(unsigned long stack_top)
 303 {
 304         unsigned long random_variable = 0;
 305
 306         if (current->flags & PF_RANDOMIZE) {
 307                 random_variable = get_random_long();
 308                 random_variable &= STACK_RND_MASK;
 309                 random_variable <<= PAGE_SHIFT;
 310         }
 311 #ifdef CONFIG_STACK_GROWSUP
 312         return PAGE_ALIGN(stack_top) + random_variable;
 313 #else
 314         return PAGE_ALIGN(stack_top) - random_variable;
 315 #endif
 316 }
 317
 318 #if defined(CONFIG_MMU) && !defined(HAVE_ARCH_PICK_MMAP_LAYOUT)
 319 void arch_pick_mmap_layout(struct mm_struct *mm, struct rlimit *rlim_stack)
 320 {
 321         mm->mmap_base = TASK_UNMAPPED_BASE;
 322         mm->get_unmapped_area = arch_get_unmapped_area;
 323 }
 324 #endif
 325
 326 /**
 327  * __account_locked_vm - account locked pages to an mm's locked_vm
 328  * @mm:          mm to account against
 329  * @pages:       number of pages to account
 330  * @inc:         %true if @pages should be considered positive, %false if not
 331  * @task:        task used to check RLIMIT_MEMLOCK
 332  * @bypass_rlim: %true if checking RLIMIT_MEMLOCK should be skipped
 333  *
 334  * Assumes @task and @mm are valid (i.e. at least one reference on each), and
 335  * that mmap_sem is held as writer.
 336  *
 337  * Return:
 338  * * 0       on success
 339  * * -ENOMEM if RLIMIT_MEMLOCK would be exceeded.
 340  */
 341 int __account_locked_vm(struct mm_struct *mm, unsigned long pages, bool inc,
 342                         struct task_struct *task, bool bypass_rlim)
 343 {
 344         unsigned long locked_vm, limit;
 345         int ret = 0;
 346
 347         lockdep_assert_held_write(&mm->mmap_sem);
 348
 349         locked_vm = mm->locked_vm;
 350         if (inc) {
 351                 if (!bypass_rlim) {
 352                         limit = task_rlimit(task, RLIMIT_MEMLOCK) >> PAGE_SHIFT;
 353                         if (locked_vm + pages > limit)
 354                                 ret = -ENOMEM;
 355                 }
 356                 if (!ret)
 357                         mm->locked_vm = locked_vm + pages;
 358         } else {
 359                 WARN_ON_ONCE(pages > locked_vm);
 360                 mm->locked_vm = locked_vm - pages;
 361         }
 362
 363         pr_debug("%s: [%d] caller %ps %c%lu %lu/%lu%s\n", __func__, task->pid,
 364                  (void *)_RET_IP_, (inc) ? '+' : '-', pages << PAGE_SHIFT,
 365                  locked_vm << PAGE_SHIFT, task_rlimit(task, RLIMIT_MEMLOCK),
 366                  ret ? " - exceeded" : "");
 367
 368         return ret;
 369 }
 370 EXPORT_SYMBOL_GPL(__account_locked_vm);
 371
 372 /**
 373  * account_locked_vm - account locked pages to an mm's locked_vm
 374  * @mm:          mm to account against, may be NULL
 375  * @pages:       number of pages to account
 376  * @inc:         %true if @pages should be considered positive, %false if not
 377  *
 378  * Assumes a non-NULL @mm is valid (i.e. at least one reference on it).
 379  *
 380  * Return:
 381  * * 0       on success, or if mm is NULL
 382  * * -ENOMEM if RLIMIT_MEMLOCK would be exceeded.
 383  */
 384 int account_locked_vm(struct mm_struct *mm, unsigned long pages, bool inc)
 385 {
 386         int ret;
 387
 388         if (pages == 0 || !mm)
 389                 return 0;
 390
 391         down_write(&mm->mmap_sem);
 392         ret = __account_locked_vm(mm, pages, inc, current,
 393                                   capable(CAP_IPC_LOCK));
 394         up_write(&mm->mmap_sem);
 395
 396         return ret;
 397 }
 398 EXPORT_SYMBOL_GPL(account_locked_vm);
 399
 400 unsigned long vm_mmap_pgoff(struct file *file, unsigned long addr,
 401         unsigned long len, unsigned long prot,
 402         unsigned long flag, unsigned long pgoff)
 403 {
 404         unsigned long ret;
 405         struct mm_struct *mm = current->mm;
 406         unsigned long populate;
 407         LIST_HEAD(uf);
 408
 409         ret = security_mmap_file(file, prot, flag);
 410         if (!ret) {
 411                 if (down_write_killable(&mm->mmap_sem))
 412                         return -EINTR;
 413                 ret = do_mmap_pgoff(file, addr, len, prot, flag, pgoff,
 414                                     &populate, &uf);
 415                 up_write(&mm->mmap_sem);
 416                 userfaultfd_unmap_complete(mm, &uf);
 417                 if (populate)
 418                         mm_populate(ret, populate);
 419         }
 420         return ret;
 421 }
 422
 423 unsigned long vm_mmap(struct file *file, unsigned long addr,
 424         unsigned long len, unsigned long prot,
 425         unsigned long flag, unsigned long offset)
 426 {
 427         if (unlikely(offset + PAGE_ALIGN(len) < offset))
 428                 return -EINVAL;
 429         if (unlikely(offset_in_page(offset)))
 430                 return -EINVAL;
 431
 432         return vm_mmap_pgoff(file, addr, len, prot, flag, offset >> PAGE_SHIFT);
 433 }
 434 EXPORT_SYMBOL(vm_mmap);
 435
 436 /**
 437  * kvmalloc_node - attempt to allocate physically contiguous memory, but upon
 438  * failure, fall back to non-contiguous (vmalloc) allocation.
 439  * @size: size of the request.
 440  * @flags: gfp mask for the allocation - must be compatible (superset) with GFP_KERNEL.
 441  * @node: numa node to allocate from
 442  *
 443  * Uses kmalloc to get the memory but if the allocation fails then falls back
 444  * to the vmalloc allocator. Use kvfree for freeing the memory.
 445  *
 446  * Reclaim modifiers - __GFP_NORETRY and __GFP_NOFAIL are not supported.
 447  * __GFP_RETRY_MAYFAIL is supported, and it should be used only if kmalloc is
 448  * preferable to the vmalloc fallback, due to visible performance drawbacks.
 449  *
 450  * Please note that any use of gfp flags outside of GFP_KERNEL is careful to not
 451  * fall back to vmalloc.
 452  *
 453  * Return: pointer to the allocated memory of %NULL in case of failure
 454  */
 455 void *kvmalloc_node(size_t size, gfp_t flags, int node)
 456 {
 457         gfp_t kmalloc_flags = flags;
 458         void *ret;
 459
 460         /*
 461          * vmalloc uses GFP_KERNEL for some internal allocations (e.g page tables)
 462          * so the given set of flags has to be compatible.
 463          */
 464         if ((flags & GFP_KERNEL) != GFP_KERNEL)
 465                 return kmalloc_node(size, flags, node);
 466
 467         /*
 468          * We want to attempt a large physically contiguous block first because
 469          * it is less likely to fragment multiple larger blocks and therefore
 470          * contribute to a long term fragmentation less than vmalloc fallback.
 471          * However make sure that larger requests are not too disruptive - no
 472          * OOM killer and no allocation failure warnings as we have a fallback.
 473          */
 474         if (size > PAGE_SIZE) {
 475                 kmalloc_flags |= __GFP_NOWARN;
 476
 477                 if (!(kmalloc_flags & __GFP_RETRY_MAYFAIL))
 478                         kmalloc_flags |= __GFP_NORETRY;
 479         }
 480
 481         ret = kmalloc_node(size, kmalloc_flags, node);
 482
 483         /*
 484          * It doesn't really make sense to fallback to vmalloc for sub page
 485          * requests
 486          */
 487         if (ret || size <= PAGE_SIZE)
 488                 return ret;
 489
 490         return __vmalloc_node_flags_caller(size, node, flags,
 491                         __builtin_return_address(0));
 492 }
 493 EXPORT_SYMBOL(kvmalloc_node);
 494
 495 /**
 496  * kvfree() - Free memory.
 497  * @addr: Pointer to allocated memory.
 498  *
 499  * kvfree frees memory allocated by any of vmalloc(), kmalloc() or kvmalloc().
 500  * It is slightly more efficient to use kfree() or vfree() if you are certain
 501  * that you know which one to use.
 502  *
 503  * Context: Either preemptible task context or not-NMI interrupt.
 504  */
 505 void kvfree(const void *addr)
 506 {
 507         if (is_vmalloc_addr(addr))
 508                 vfree(addr);
 509         else
 510                 kfree(addr);
 511 }
 512 EXPORT_SYMBOL(kvfree);
 513
 514 static inline void *__page_rmapping(struct page *page)
 515 {
 516         unsigned long mapping;
 517
 518         mapping = (unsigned long)page->mapping;
 519         mapping &= ~PAGE_MAPPING_FLAGS;
 520
 521         return (void *)mapping;
 522 }
 523
 524 /* Neutral page->mapping pointer to address_space or anon_vma or other */
 525 void *page_rmapping(struct page *page)
 526 {
 527         page = compound_head(page);
 528         return __page_rmapping(page);
 529 }
 530
 531 /*
 532  * Return true if this page is mapped into pagetables.
 533  * For compound page it returns true if any subpage of compound page is mapped.
 534  */
 535 bool page_mapped(struct page *page)
 536 {
 537         int i;
 538
 539         if (likely(!PageCompound(page)))
 540                 return atomic_read(&page->_mapcount) >= 0;
 541         page = compound_head(page);
 542         if (atomic_read(compound_mapcount_ptr(page)) >= 0)
 543                 return true;
 544         if (PageHuge(page))
 545                 return false;
 546         for (i = 0; i < compound_nr(page); i++) {
 547                 if (atomic_read(&page[i]._mapcount) >= 0)
 548                         return true;
 549         }
 550         return false;
 551 }
 552 EXPORT_SYMBOL(page_mapped);
 553
 554 struct anon_vma *page_anon_vma(struct page *page)
 555 {
 556         unsigned long mapping;
 557
 558         page = compound_head(page);
 559         mapping = (unsigned long)page->mapping;
 560         if ((mapping & PAGE_MAPPING_FLAGS) != PAGE_MAPPING_ANON)
 561                 return NULL;
 562         return __page_rmapping(page);
 563 }
 564
 565 struct address_space *page_mapping(struct page *page)
 566 {
 567         struct address_space *mapping;
 568
 569         page = compound_head(page);
 570
 571         /* This happens if someone calls flush_dcache_page on slab page */
 572         if (unlikely(PageSlab(page)))
 573                 return NULL;
 574
 575         if (unlikely(PageSwapCache(page))) {
 576                 swp_entry_t entry;
 577
 578                 entry.val = page_private(page);
 579                 return swap_address_space(entry);
 580         }
 581
 582         mapping = page->mapping;
 583         if ((unsigned long)mapping & PAGE_MAPPING_ANON)
 584                 return NULL;
 585
 586         return (void *)((unsigned long)mapping & ~PAGE_MAPPING_FLAGS);
 587 }
 588 EXPORT_SYMBOL(page_mapping);
 589
 590 /*
 591  * For file cache pages, return the address_space, otherwise return NULL
 592  */
 593 struct address_space *page_mapping_file(struct page *page)
 594 {
 595         if (unlikely(PageSwapCache(page)))
 596                 return NULL;
 597         return page_mapping(page);
 598 }
 599
 600 /* Slow path of page_mapcount() for compound pages */
 601 int __page_mapcount(struct page *page)
 602 {
 603         int ret;
 604
 605         ret = atomic_read(&page->_mapcount) + 1;
 606         /*
 607          * For file THP page->_mapcount contains total number of mapping
 608          * of the page: no need to look into compound_mapcount.
 609          */
 610         if (!PageAnon(page) && !PageHuge(page))
 611                 return ret;
 612         page = compound_head(page);
 613         ret += atomic_read(compound_mapcount_ptr(page)) + 1;
 614         if (PageDoubleMap(page))
 615                 ret--;
 616         return ret;
 617 }
 618 EXPORT_SYMBOL_GPL(__page_mapcount);
 619
 620 int sysctl_overcommit_memory __read_mostly = OVERCOMMIT_GUESS;
 621 int sysctl_overcommit_ratio __read_mostly = 50;
 622 unsigned long sysctl_overcommit_kbytes __read_mostly;
 623 int sysctl_max_map_count __read_mostly = DEFAULT_MAX_MAP_COUNT;
 624 unsigned long sysctl_user_reserve_kbytes __read_mostly = 1UL << 17; /* 128MB */
 625 unsigned long sysctl_admin_reserve_kbytes __read_mostly = 1UL << 13; /* 8MB */
 626
 627 int overcommit_ratio_handler(struct ctl_table *table, int write,
 628                              void __user *buffer, size_t *lenp,
 629                              loff_t *ppos)
 630 {
 631         int ret;
 632
 633         ret = proc_dointvec(table, write, buffer, lenp, ppos);
 634         if (ret == 0 && write)
 635                 sysctl_overcommit_kbytes = 0;
 636         return ret;
 637 }
 638
 639 int overcommit_kbytes_handler(struct ctl_table *table, int write,
 640                              void __user *buffer, size_t *lenp,
 641                              loff_t *ppos)
 642 {
 643         int ret;
 644
 645         ret = proc_doulongvec_minmax(table, write, buffer, lenp, ppos);
 646         if (ret == 0 && write)
 647                 sysctl_overcommit_ratio = 0;
 648         return ret;
 649 }
 650
 651 /*
 652  * Committed memory limit enforced when OVERCOMMIT_NEVER policy is used
 653  */
 654 unsigned long vm_commit_limit(void)
 655 {
 656         unsigned long allowed;
 657
 658         if (sysctl_overcommit_kbytes)
 659                 allowed = sysctl_overcommit_kbytes >> (PAGE_SHIFT - 10);
 660         else
 661                 allowed = ((totalram_pages() - hugetlb_total_pages())
 662                            * sysctl_overcommit_ratio / 100);
 663         allowed += total_swap_pages;
 664
 665         return allowed;
 666 }
 667
 668 /*
 669  * Make sure vm_committed_as in one cacheline and not cacheline shared with
 670  * other variables. It can be updated by several CPUs frequently.
 671  */
 672 struct percpu_counter vm_committed_as ____cacheline_aligned_in_smp;
 673
 674 /*
 675  * The global memory commitment made in the system can be a metric
 676  * that can be used to drive ballooning decisions when Linux is hosted
 677  * as a guest. On Hyper-V, the host implements a policy engine for dynamically
 678  * balancing memory across competing virtual machines that are hosted.
 679  * Several metrics drive this policy engine including the guest reported
 680  * memory commitment.
 681  */
 682 unsigned long vm_memory_committed(void)
 683 {
 684         return percpu_counter_read_positive(&vm_committed_as);
 685 }
 686 EXPORT_SYMBOL_GPL(vm_memory_committed);
 687
 688 /*
 689  * Check that a process has enough memory to allocate a new virtual
 690  * mapping. 0 means there is enough memory for the allocation to
 691  * succeed and -ENOMEM implies there is not.
 692  *
 693  * We currently support three overcommit policies, which are set via the
 694  * vm.overcommit_memory sysctl.  See Documentation/vm/overcommit-accounting.rst
 695  *
 696  * Strict overcommit modes added 2002 Feb 26 by Alan Cox.
 697  * Additional code 2002 Jul 20 by Robert Love.
 698  *
 699  * cap_sys_admin is 1 if the process has admin privileges, 0 otherwise.
 700  *
 701  * Note this is a helper function intended to be used by LSMs which
 702  * wish to use this logic.
 703  */
 704 int __vm_enough_memory(struct mm_struct *mm, long pages, int cap_sys_admin)
 705 {
 706         long allowed;
 707
 708         VM_WARN_ONCE(percpu_counter_read(&vm_committed_as) <
 709                         -(s64)vm_committed_as_batch * num_online_cpus(),
 710                         "memory commitment underflow");
 711
 712         vm_acct_memory(pages);
 713
 714         /*
 715          * Sometimes we want to use more memory than we have
 716          */
 717         if (sysctl_overcommit_memory == OVERCOMMIT_ALWAYS)
 718                 return 0;
 719
 720         if (sysctl_overcommit_memory == OVERCOMMIT_GUESS) {
 721                 if (pages > totalram_pages() + total_swap_pages)
 722                         goto error;
 723                 return 0;
 724         }
 725
 726         allowed = vm_commit_limit();
 727         /*
 728          * Reserve some for root
 729          */
 730         if (!cap_sys_admin)
 731                 allowed -= sysctl_admin_reserve_kbytes >> (PAGE_SHIFT - 10);
 732
 733         /*
 734          * Don't let a single process grow so big a user can't recover
 735          */
 736         if (mm) {
 737                 long reserve = sysctl_user_reserve_kbytes >> (PAGE_SHIFT - 10);
 738
 739                 allowed -= min_t(long, mm->total_vm / 32, reserve);
 740         }
 741
 742         if (percpu_counter_read_positive(&vm_committed_as) < allowed)
 743                 return 0;
 744 error:
 745         vm_unacct_memory(pages);
 746
 747         return -ENOMEM;
 748 }
 749
 750 /**
 751  * get_cmdline() - copy the cmdline value to a buffer.
 752  * @task:     the task whose cmdline value to copy.
 753  * @buffer:   the buffer to copy to.
 754  * @buflen:   the length of the buffer. Larger cmdline values are truncated
 755  *            to this length.
 756  *
 757  * Return: the size of the cmdline field copied. Note that the copy does
 758  * not guarantee an ending NULL byte.
 759  */
 760 int get_cmdline(struct task_struct *task, char *buffer, int buflen)
 761 {
 762         int res = 0;
 763         unsigned int len;
 764         struct mm_struct *mm = get_task_mm(task);
 765         unsigned long arg_start, arg_end, env_start, env_end;
 766         if (!mm)
 767                 goto out;
 768         if (!mm->arg_end)
 769                 goto out_mm;    /* Shh! No looking before we're done */
 770
 771         spin_lock(&mm->arg_lock);
 772         arg_start = mm->arg_start;
 773         arg_end = mm->arg_end;
 774         env_start = mm->env_start;
 775         env_end = mm->env_end;
 776         spin_unlock(&mm->arg_lock);
 777
 778         len = arg_end - arg_start;
 779
 780         if (len > buflen)
 781                 len = buflen;
 782
 783         res = access_process_vm(task, arg_start, buffer, len, FOLL_FORCE);
 784
 785         /*
 786          * If the nul at the end of args has been overwritten, then
 787          * assume application is using setproctitle(3).
 788          */
 789         if (res > 0 && buffer[res-1] != '\0' && len < buflen) {
 790                 len = strnlen(buffer, res);
 791                 if (len < res) {
 792                         res = len;
 793                 } else {
 794                         len = env_end - env_start;
 795                         if (len > buflen - res)
 796                                 len = buflen - res;
 797                         res += access_process_vm(task, env_start,
 798                                                  buffer+res, len,
 799                                                  FOLL_FORCE);
 800                         res = strnlen(buffer, res);
 801                 }
 802         }
 803 out_mm:
 804         mmput(mm);
 805 out:
 806         return res;
 807 }
 808
 809 int memcmp_pages(struct page *page1, struct page *page2)
 810 {
 811         char *addr1, *addr2;
 812         int ret;
 813
 814         addr1 = kmap_atomic(page1);
 815         addr2 = kmap_atomic(page2);
 816         ret = memcmp(addr1, addr2, PAGE_SIZE);
 817         kunmap_atomic(addr2);
 818         kunmap_atomic(addr1);
 819         return ret;
 820 }