1 /* SPDX-License-Identifier: GPL-2.0 */ 2 #ifndef _LINUX_MM_H 3 #define _LINUX_MM_H 4 5 #include <linux/errno.h> 6 7 #ifdef __KERNEL__ 8 9 #include <linux/mmdebug.h> 10 #include <linux/gfp.h> 11 #include <linux/bug.h> 12 #include <linux/list.h> 13 #include <linux/mmzone.h> 14 #include <linux/rbtree.h> 15 #include <linux/atomic.h> 16 #include <linux/debug_locks.h> 17 #include <linux/mm_types.h> 18 #include <linux/range.h> 19 #include <linux/pfn.h> 20 #include <linux/percpu-refcount.h> 21 #include <linux/bit_spinlock.h> 22 #include <linux/shrinker.h> 23 #include <linux/resource.h> 24 #include <linux/page_ext.h> 25 #include <linux/err.h> 26 #include <linux/page_ref.h> 27 #include <linux/memremap.h> 28 #include <linux/overflow.h> 29 #include <linux/sizes.h> 30 31 struct mempolicy; 32 struct anon_vma; 33 struct anon_vma_chain; 34 struct file_ra_state; 35 struct user_struct; 36 struct writeback_control; 37 struct bdi_writeback; 38 39 void init_mm_internals(void); 40 41 #ifndef CONFIG_NEED_MULTIPLE_NODES /* Don't use mapnrs, do it properly */ 42 extern unsigned long max_mapnr; 43 44 static inline void set_max_mapnr(unsigned long limit) 45 { 46 max_mapnr = limit; 47 } 48 #else 49 static inline void set_max_mapnr(unsigned long limit) { } 50 #endif 51 52 extern atomic_long_t _totalram_pages; 53 static inline unsigned long totalram_pages(void) 54 { 55 return (unsigned long)atomic_long_read(&_totalram_pages); 56 } 57 58 static inline void totalram_pages_inc(void) 59 { 60 atomic_long_inc(&_totalram_pages); 61 } 62 63 static inline void totalram_pages_dec(void) 64 { 65 atomic_long_dec(&_totalram_pages); 66 } 67 68 static inline void totalram_pages_add(long count) 69 { 70 atomic_long_add(count, &_totalram_pages); 71 } 72 73 static inline void totalram_pages_set(long val) 74 { 75 atomic_long_set(&_totalram_pages, val); 76 } 77 78 extern void * high_memory; 79 extern int page_cluster; 80 81 #ifdef CONFIG_SYSCTL 82 extern int sysctl_legacy_va_layout; 83 #else 84 #define sysctl_legacy_va_layout 0 85 #endif 86 87 #ifdef CONFIG_HAVE_ARCH_MMAP_RND_BITS 88 extern const int mmap_rnd_bits_min; 89 extern const int mmap_rnd_bits_max; 90 extern int mmap_rnd_bits __read_mostly; 91 #endif 92 #ifdef CONFIG_HAVE_ARCH_MMAP_RND_COMPAT_BITS 93 extern const int mmap_rnd_compat_bits_min; 94 extern const int mmap_rnd_compat_bits_max; 95 extern int mmap_rnd_compat_bits __read_mostly; 96 #endif 97 98 #include <asm/page.h> 99 #include <asm/pgtable.h> 100 #include <asm/processor.h> 101 102 #ifndef __pa_symbol 103 #define __pa_symbol(x) __pa(RELOC_HIDE((unsigned long)(x), 0)) 104 #endif 105 106 #ifndef page_to_virt 107 #define page_to_virt(x) __va(PFN_PHYS(page_to_pfn(x))) 108 #endif 109 110 #ifndef lm_alias 111 #define lm_alias(x) __va(__pa_symbol(x)) 112 #endif 113 114 /* 115 * To prevent common memory management code establishing 116 * a zero page mapping on a read fault. 117 * This macro should be defined within <asm/pgtable.h>. 118 * s390 does this to prevent multiplexing of hardware bits 119 * related to the physical page in case of virtualization. 120 */ 121 #ifndef mm_forbids_zeropage 122 #define mm_forbids_zeropage(X) (0) 123 #endif 124 125 /* 126 * On some architectures it is expensive to call memset() for small sizes. 127 * Those architectures should provide their own implementation of "struct page" 128 * zeroing by defining this macro in <asm/pgtable.h>. 129 */ 130 #ifndef mm_zero_struct_page 131 #define mm_zero_struct_page(pp) ((void)memset((pp), 0, sizeof(struct page))) 132 #endif 133 134 /* 135 * Default maximum number of active map areas, this limits the number of vmas 136 * per mm struct. Users can overwrite this number by sysctl but there is a 137 * problem. 138 * 139 * When a program's coredump is generated as ELF format, a section is created 140 * per a vma. In ELF, the number of sections is represented in unsigned short. 141 * This means the number of sections should be smaller than 65535 at coredump. 142 * Because the kernel adds some informative sections to a image of program at 143 * generating coredump, we need some margin. The number of extra sections is 144 * 1-3 now and depends on arch. We use "5" as safe margin, here. 145 * 146 * ELF extended numbering allows more than 65535 sections, so 16-bit bound is 147 * not a hard limit any more. Although some userspace tools can be surprised by 148 * that. 149 */ 150 #define MAPCOUNT_ELF_CORE_MARGIN (5) 151 #define DEFAULT_MAX_MAP_COUNT (USHRT_MAX - MAPCOUNT_ELF_CORE_MARGIN) 152 153 extern int sysctl_max_map_count; 154 155 extern unsigned long sysctl_user_reserve_kbytes; 156 extern unsigned long sysctl_admin_reserve_kbytes; 157 158 extern int sysctl_overcommit_memory; 159 extern int sysctl_overcommit_ratio; 160 extern unsigned long sysctl_overcommit_kbytes; 161 162 extern int overcommit_ratio_handler(struct ctl_table *, int, void __user *, 163 size_t *, loff_t *); 164 extern int overcommit_kbytes_handler(struct ctl_table *, int, void __user *, 165 size_t *, loff_t *); 166 167 #define nth_page(page,n) pfn_to_page(page_to_pfn((page)) + (n)) 168 169 /* to align the pointer to the (next) page boundary */ 170 #define PAGE_ALIGN(addr) ALIGN(addr, PAGE_SIZE) 171 172 /* test whether an address (unsigned long or pointer) is aligned to PAGE_SIZE */ 173 #define PAGE_ALIGNED(addr) IS_ALIGNED((unsigned long)(addr), PAGE_SIZE) 174 175 #define lru_to_page(head) (list_entry((head)->prev, struct page, lru)) 176 177 /* 178 * Linux kernel virtual memory manager primitives. 179 * The idea being to have a "virtual" mm in the same way 180 * we have a virtual fs - giving a cleaner interface to the 181 * mm details, and allowing different kinds of memory mappings 182 * (from shared memory to executable loading to arbitrary 183 * mmap() functions). 184 */ 185 186 struct vm_area_struct *vm_area_alloc(struct mm_struct *); 187 struct vm_area_struct *vm_area_dup(struct vm_area_struct *); 188 void vm_area_free(struct vm_area_struct *); 189 190 #ifndef CONFIG_MMU 191 extern struct rb_root nommu_region_tree; 192 extern struct rw_semaphore nommu_region_sem; 193 194 extern unsigned int kobjsize(const void *objp); 195 #endif 196 197 /* 198 * vm_flags in vm_area_struct, see mm_types.h. 199 * When changing, update also include/trace/events/mmflags.h 200 */ 201 #define VM_NONE 0x00000000 202 203 #define VM_READ 0x00000001 /* currently active flags */ 204 #define VM_WRITE 0x00000002 205 #define VM_EXEC 0x00000004 206 #define VM_SHARED 0x00000008 207 208 /* mprotect() hardcodes VM_MAYREAD >> 4 == VM_READ, and so for r/w/x bits. */ 209 #define VM_MAYREAD 0x00000010 /* limits for mprotect() etc */ 210 #define VM_MAYWRITE 0x00000020 211 #define VM_MAYEXEC 0x00000040 212 #define VM_MAYSHARE 0x00000080 213 214 #define VM_GROWSDOWN 0x00000100 /* general info on the segment */ 215 #define VM_UFFD_MISSING 0x00000200 /* missing pages tracking */ 216 #define VM_PFNMAP 0x00000400 /* Page-ranges managed without "struct page", just pure PFN */ 217 #define VM_DENYWRITE 0x00000800 /* ETXTBSY on write attempts.. */ 218 #define VM_UFFD_WP 0x00001000 /* wrprotect pages tracking */ 219 220 #define VM_LOCKED 0x00002000 221 #define VM_IO 0x00004000 /* Memory mapped I/O or similar */ 222 223 /* Used by sys_madvise() */ 224 #define VM_SEQ_READ 0x00008000 /* App will access data sequentially */ 225 #define VM_RAND_READ 0x00010000 /* App will not benefit from clustered reads */ 226 227 #define VM_DONTCOPY 0x00020000 /* Do not copy this vma on fork */ 228 #define VM_DONTEXPAND 0x00040000 /* Cannot expand with mremap() */ 229 #define VM_LOCKONFAULT 0x00080000 /* Lock the pages covered when they are faulted in */ 230 #define VM_ACCOUNT 0x00100000 /* Is a VM accounted object */ 231 #define VM_NORESERVE 0x00200000 /* should the VM suppress accounting */ 232 #define VM_HUGETLB 0x00400000 /* Huge TLB Page VM */ 233 #define VM_SYNC 0x00800000 /* Synchronous page faults */ 234 #define VM_ARCH_1 0x01000000 /* Architecture-specific flag */ 235 #define VM_WIPEONFORK 0x02000000 /* Wipe VMA contents in child. */ 236 #define VM_DONTDUMP 0x04000000 /* Do not include in the core dump */ 237 238 #ifdef CONFIG_MEM_SOFT_DIRTY 239 # define VM_SOFTDIRTY 0x08000000 /* Not soft dirty clean area */ 240 #else 241 # define VM_SOFTDIRTY 0 242 #endif 243 244 #define VM_MIXEDMAP 0x10000000 /* Can contain "struct page" and pure PFN pages */ 245 #define VM_HUGEPAGE 0x20000000 /* MADV_HUGEPAGE marked this vma */ 246 #define VM_NOHUGEPAGE 0x40000000 /* MADV_NOHUGEPAGE marked this vma */ 247 #define VM_MERGEABLE 0x80000000 /* KSM may merge identical pages */ 248 249 #ifdef CONFIG_ARCH_USES_HIGH_VMA_FLAGS 250 #define VM_HIGH_ARCH_BIT_0 32 /* bit only usable on 64-bit architectures */ 251 #define VM_HIGH_ARCH_BIT_1 33 /* bit only usable on 64-bit architectures */ 252 #define VM_HIGH_ARCH_BIT_2 34 /* bit only usable on 64-bit architectures */ 253 #define VM_HIGH_ARCH_BIT_3 35 /* bit only usable on 64-bit architectures */ 254 #define VM_HIGH_ARCH_BIT_4 36 /* bit only usable on 64-bit architectures */ 255 #define VM_HIGH_ARCH_0 BIT(VM_HIGH_ARCH_BIT_0) 256 #define VM_HIGH_ARCH_1 BIT(VM_HIGH_ARCH_BIT_1) 257 #define VM_HIGH_ARCH_2 BIT(VM_HIGH_ARCH_BIT_2) 258 #define VM_HIGH_ARCH_3 BIT(VM_HIGH_ARCH_BIT_3) 259 #define VM_HIGH_ARCH_4 BIT(VM_HIGH_ARCH_BIT_4) 260 #endif /* CONFIG_ARCH_USES_HIGH_VMA_FLAGS */ 261 262 #ifdef CONFIG_ARCH_HAS_PKEYS 263 # define VM_PKEY_SHIFT VM_HIGH_ARCH_BIT_0 264 # define VM_PKEY_BIT0 VM_HIGH_ARCH_0 /* A protection key is a 4-bit value */ 265 # define VM_PKEY_BIT1 VM_HIGH_ARCH_1 /* on x86 and 5-bit value on ppc64 */ 266 # define VM_PKEY_BIT2 VM_HIGH_ARCH_2 267 # define VM_PKEY_BIT3 VM_HIGH_ARCH_3 268 #ifdef CONFIG_PPC 269 # define VM_PKEY_BIT4 VM_HIGH_ARCH_4 270 #else 271 # define VM_PKEY_BIT4 0 272 #endif 273 #endif /* CONFIG_ARCH_HAS_PKEYS */ 274 275 #if defined(CONFIG_X86) 276 # define VM_PAT VM_ARCH_1 /* PAT reserves whole VMA at once (x86) */ 277 #elif defined(CONFIG_PPC) 278 # define VM_SAO VM_ARCH_1 /* Strong Access Ordering (powerpc) */ 279 #elif defined(CONFIG_PARISC) 280 # define VM_GROWSUP VM_ARCH_1 281 #elif defined(CONFIG_IA64) 282 # define VM_GROWSUP VM_ARCH_1 283 #elif defined(CONFIG_SPARC64) 284 # define VM_SPARC_ADI VM_ARCH_1 /* Uses ADI tag for access control */ 285 # define VM_ARCH_CLEAR VM_SPARC_ADI 286 #elif !defined(CONFIG_MMU) 287 # define VM_MAPPED_COPY VM_ARCH_1 /* T if mapped copy of data (nommu mmap) */ 288 #endif 289 290 #if defined(CONFIG_X86_INTEL_MPX) 291 /* MPX specific bounds table or bounds directory */ 292 # define VM_MPX VM_HIGH_ARCH_4 293 #else 294 # define VM_MPX VM_NONE 295 #endif 296 297 #ifndef VM_GROWSUP 298 # define VM_GROWSUP VM_NONE 299 #endif 300 301 /* Bits set in the VMA until the stack is in its final location */ 302 #define VM_STACK_INCOMPLETE_SETUP (VM_RAND_READ | VM_SEQ_READ) 303 304 #ifndef VM_STACK_DEFAULT_FLAGS /* arch can override this */ 305 #define VM_STACK_DEFAULT_FLAGS VM_DATA_DEFAULT_FLAGS 306 #endif 307 308 #ifdef CONFIG_STACK_GROWSUP 309 #define VM_STACK VM_GROWSUP 310 #else 311 #define VM_STACK VM_GROWSDOWN 312 #endif 313 314 #define VM_STACK_FLAGS (VM_STACK | VM_STACK_DEFAULT_FLAGS | VM_ACCOUNT) 315 316 /* 317 * Special vmas that are non-mergable, non-mlock()able. 318 * Note: mm/huge_memory.c VM_NO_THP depends on this definition. 319 */ 320 #define VM_SPECIAL (VM_IO | VM_DONTEXPAND | VM_PFNMAP | VM_MIXEDMAP) 321 322 /* This mask defines which mm->def_flags a process can inherit its parent */ 323 #define VM_INIT_DEF_MASK VM_NOHUGEPAGE 324 325 /* This mask is used to clear all the VMA flags used by mlock */ 326 #define VM_LOCKED_CLEAR_MASK (~(VM_LOCKED | VM_LOCKONFAULT)) 327 328 /* Arch-specific flags to clear when updating VM flags on protection change */ 329 #ifndef VM_ARCH_CLEAR 330 # define VM_ARCH_CLEAR VM_NONE 331 #endif 332 #define VM_FLAGS_CLEAR (ARCH_VM_PKEY_FLAGS | VM_ARCH_CLEAR) 333 334 /* 335 * mapping from the currently active vm_flags protection bits (the 336 * low four bits) to a page protection mask.. 337 */ 338 extern pgprot_t protection_map[16]; 339 340 #define FAULT_FLAG_WRITE 0x01 /* Fault was a write access */ 341 #define FAULT_FLAG_MKWRITE 0x02 /* Fault was mkwrite of existing pte */ 342 #define FAULT_FLAG_ALLOW_RETRY 0x04 /* Retry fault if blocking */ 343 #define FAULT_FLAG_RETRY_NOWAIT 0x08 /* Don't drop mmap_sem and wait when retrying */ 344 #define FAULT_FLAG_KILLABLE 0x10 /* The fault task is in SIGKILL killable region */ 345 #define FAULT_FLAG_TRIED 0x20 /* Second try */ 346 #define FAULT_FLAG_USER 0x40 /* The fault originated in userspace */ 347 #define FAULT_FLAG_REMOTE 0x80 /* faulting for non current tsk/mm */ 348 #define FAULT_FLAG_INSTRUCTION 0x100 /* The fault was during an instruction fetch */ 349 350 #define FAULT_FLAG_TRACE \ 351 { FAULT_FLAG_WRITE, "WRITE" }, \ 352 { FAULT_FLAG_MKWRITE, "MKWRITE" }, \ 353 { FAULT_FLAG_ALLOW_RETRY, "ALLOW_RETRY" }, \ 354 { FAULT_FLAG_RETRY_NOWAIT, "RETRY_NOWAIT" }, \ 355 { FAULT_FLAG_KILLABLE, "KILLABLE" }, \ 356 { FAULT_FLAG_TRIED, "TRIED" }, \ 357 { FAULT_FLAG_USER, "USER" }, \ 358 { FAULT_FLAG_REMOTE, "REMOTE" }, \ 359 { FAULT_FLAG_INSTRUCTION, "INSTRUCTION" } 360 361 /* 362 * vm_fault is filled by the the pagefault handler and passed to the vma's 363 * ->fault function. The vma's ->fault is responsible for returning a bitmask 364 * of VM_FAULT_xxx flags that give details about how the fault was handled. 365 * 366 * MM layer fills up gfp_mask for page allocations but fault handler might 367 * alter it if its implementation requires a different allocation context. 368 * 369 * pgoff should be used in favour of virtual_address, if possible. 370 */ 371 struct vm_fault { 372 struct vm_area_struct *vma; /* Target VMA */ 373 unsigned int flags; /* FAULT_FLAG_xxx flags */ 374 gfp_t gfp_mask; /* gfp mask to be used for allocations */ 375 pgoff_t pgoff; /* Logical page offset based on vma */ 376 unsigned long address; /* Faulting virtual address */ 377 pmd_t *pmd; /* Pointer to pmd entry matching 378 * the 'address' */ 379 pud_t *pud; /* Pointer to pud entry matching 380 * the 'address' 381 */ 382 pte_t orig_pte; /* Value of PTE at the time of fault */ 383 384 struct page *cow_page; /* Page handler may use for COW fault */ 385 struct mem_cgroup *memcg; /* Cgroup cow_page belongs to */ 386 struct page *page; /* ->fault handlers should return a 387 * page here, unless VM_FAULT_NOPAGE 388 * is set (which is also implied by 389 * VM_FAULT_ERROR). 390 */ 391 /* These three entries are valid only while holding ptl lock */ 392 pte_t *pte; /* Pointer to pte entry matching 393 * the 'address'. NULL if the page 394 * table hasn't been allocated. 395 */ 396 spinlock_t *ptl; /* Page table lock. 397 * Protects pte page table if 'pte' 398 * is not NULL, otherwise pmd. 399 */ 400 pgtable_t prealloc_pte; /* Pre-allocated pte page table. 401 * vm_ops->map_pages() calls 402 * alloc_set_pte() from atomic context. 403 * do_fault_around() pre-allocates 404 * page table to avoid allocation from 405 * atomic context. 406 */ 407 }; 408 409 /* page entry size for vm->huge_fault() */ 410 enum page_entry_size { 411 PE_SIZE_PTE = 0, 412 PE_SIZE_PMD, 413 PE_SIZE_PUD, 414 }; 415 416 /* 417 * These are the virtual MM functions - opening of an area, closing and 418 * unmapping it (needed to keep files on disk up-to-date etc), pointer 419 * to the functions called when a no-page or a wp-page exception occurs. 420 */ 421 struct vm_operations_struct { 422 void (*open)(struct vm_area_struct * area); 423 void (*close)(struct vm_area_struct * area); 424 int (*split)(struct vm_area_struct * area, unsigned long addr); 425 int (*mremap)(struct vm_area_struct * area); 426 vm_fault_t (*fault)(struct vm_fault *vmf); 427 vm_fault_t (*huge_fault)(struct vm_fault *vmf, 428 enum page_entry_size pe_size); 429 void (*map_pages)(struct vm_fault *vmf, 430 pgoff_t start_pgoff, pgoff_t end_pgoff); 431 unsigned long (*pagesize)(struct vm_area_struct * area); 432 433 /* notification that a previously read-only page is about to become 434 * writable, if an error is returned it will cause a SIGBUS */ 435 vm_fault_t (*page_mkwrite)(struct vm_fault *vmf); 436 437 /* same as page_mkwrite when using VM_PFNMAP|VM_MIXEDMAP */ 438 vm_fault_t (*pfn_mkwrite)(struct vm_fault *vmf); 439 440 /* called by access_process_vm when get_user_pages() fails, typically 441 * for use by special VMAs that can switch between memory and hardware 442 */ 443 int (*access)(struct vm_area_struct *vma, unsigned long addr, 444 void *buf, int len, int write); 445 446 /* Called by the /proc/PID/maps code to ask the vma whether it 447 * has a special name. Returning non-NULL will also cause this 448 * vma to be dumped unconditionally. */ 449 const char *(*name)(struct vm_area_struct *vma); 450 451 #ifdef CONFIG_NUMA 452 /* 453 * set_policy() op must add a reference to any non-NULL @new mempolicy 454 * to hold the policy upon return. Caller should pass NULL @new to 455 * remove a policy and fall back to surrounding context--i.e. do not 456 * install a MPOL_DEFAULT policy, nor the task or system default 457 * mempolicy. 458 */ 459 int (*set_policy)(struct vm_area_struct *vma, struct mempolicy *new); 460 461 /* 462 * get_policy() op must add reference [mpol_get()] to any policy at 463 * (vma,addr) marked as MPOL_SHARED. The shared policy infrastructure 464 * in mm/mempolicy.c will do this automatically. 465 * get_policy() must NOT add a ref if the policy at (vma,addr) is not 466 * marked as MPOL_SHARED. vma policies are protected by the mmap_sem. 467 * If no [shared/vma] mempolicy exists at the addr, get_policy() op 468 * must return NULL--i.e., do not "fallback" to task or system default 469 * policy. 470 */ 471 struct mempolicy *(*get_policy)(struct vm_area_struct *vma, 472 unsigned long addr); 473 #endif 474 /* 475 * Called by vm_normal_page() for special PTEs to find the 476 * page for @addr. This is useful if the default behavior 477 * (using pte_page()) would not find the correct page. 478 */ 479 struct page *(*find_special_page)(struct vm_area_struct *vma, 480 unsigned long addr); 481 }; 482 483 static inline void vma_init(struct vm_area_struct *vma, struct mm_struct *mm) 484 { 485 static const struct vm_operations_struct dummy_vm_ops = {}; 486 487 memset(vma, 0, sizeof(*vma)); 488 vma->vm_mm = mm; 489 vma->vm_ops = &dummy_vm_ops; 490 INIT_LIST_HEAD(&vma->anon_vma_chain); 491 } 492 493 static inline void vma_set_anonymous(struct vm_area_struct *vma) 494 { 495 vma->vm_ops = NULL; 496 } 497 498 /* flush_tlb_range() takes a vma, not a mm, and can care about flags */ 499 #define TLB_FLUSH_VMA(mm,flags) { .vm_mm = (mm), .vm_flags = (flags) } 500 501 struct mmu_gather; 502 struct inode; 503 504 #define page_private(page) ((page)->private) 505 #define set_page_private(page, v) ((page)->private = (v)) 506 507 #if !defined(__HAVE_ARCH_PTE_DEVMAP) || !defined(CONFIG_TRANSPARENT_HUGEPAGE) 508 static inline int pmd_devmap(pmd_t pmd) 509 { 510 return 0; 511 } 512 static inline int pud_devmap(pud_t pud) 513 { 514 return 0; 515 } 516 static inline int pgd_devmap(pgd_t pgd) 517 { 518 return 0; 519 } 520 #endif 521 522 /* 523 * FIXME: take this include out, include page-flags.h in 524 * files which need it (119 of them) 525 */ 526 #include <linux/page-flags.h> 527 #include <linux/huge_mm.h> 528 529 /* 530 * Methods to modify the page usage count. 531 * 532 * What counts for a page usage: 533 * - cache mapping (page->mapping) 534 * - private data (page->private) 535 * - page mapped in a task's page tables, each mapping 536 * is counted separately 537 * 538 * Also, many kernel routines increase the page count before a critical 539 * routine so they can be sure the page doesn't go away from under them. 540 */ 541 542 /* 543 * Drop a ref, return true if the refcount fell to zero (the page has no users) 544 */ 545 static inline int put_page_testzero(struct page *page) 546 { 547 VM_BUG_ON_PAGE(page_ref_count(page) == 0, page); 548 return page_ref_dec_and_test(page); 549 } 550 551 /* 552 * Try to grab a ref unless the page has a refcount of zero, return false if 553 * that is the case. 554 * This can be called when MMU is off so it must not access 555 * any of the virtual mappings. 556 */ 557 static inline int get_page_unless_zero(struct page *page) 558 { 559 return page_ref_add_unless(page, 1, 0); 560 } 561 562 extern int page_is_ram(unsigned long pfn); 563 564 enum { 565 REGION_INTERSECTS, 566 REGION_DISJOINT, 567 REGION_MIXED, 568 }; 569 570 int region_intersects(resource_size_t offset, size_t size, unsigned long flags, 571 unsigned long desc); 572 573 /* Support for virtually mapped pages */ 574 struct page *vmalloc_to_page(const void *addr); 575 unsigned long vmalloc_to_pfn(const void *addr); 576 577 /* 578 * Determine if an address is within the vmalloc range 579 * 580 * On nommu, vmalloc/vfree wrap through kmalloc/kfree directly, so there 581 * is no special casing required. 582 */ 583 static inline bool is_vmalloc_addr(const void *x) 584 { 585 #ifdef CONFIG_MMU 586 unsigned long addr = (unsigned long)x; 587 588 return addr >= VMALLOC_START && addr < VMALLOC_END; 589 #else 590 return false; 591 #endif 592 } 593 #ifdef CONFIG_MMU 594 extern int is_vmalloc_or_module_addr(const void *x); 595 #else 596 static inline int is_vmalloc_or_module_addr(const void *x) 597 { 598 return 0; 599 } 600 #endif 601 602 extern void *kvmalloc_node(size_t size, gfp_t flags, int node); 603 static inline void *kvmalloc(size_t size, gfp_t flags) 604 { 605 return kvmalloc_node(size, flags, NUMA_NO_NODE); 606 } 607 static inline void *kvzalloc_node(size_t size, gfp_t flags, int node) 608 { 609 return kvmalloc_node(size, flags | __GFP_ZERO, node); 610 } 611 static inline void *kvzalloc(size_t size, gfp_t flags) 612 { 613 return kvmalloc(size, flags | __GFP_ZERO); 614 } 615 616 static inline void *kvmalloc_array(size_t n, size_t size, gfp_t flags) 617 { 618 size_t bytes; 619 620 if (unlikely(check_mul_overflow(n, size, &bytes))) 621 return NULL; 622 623 return kvmalloc(bytes, flags); 624 } 625 626 static inline void *kvcalloc(size_t n, size_t size, gfp_t flags) 627 { 628 return kvmalloc_array(n, size, flags | __GFP_ZERO); 629 } 630 631 extern void kvfree(const void *addr); 632 633 static inline atomic_t *compound_mapcount_ptr(struct page *page) 634 { 635 return &page[1].compound_mapcount; 636 } 637 638 static inline int compound_mapcount(struct page *page) 639 { 640 VM_BUG_ON_PAGE(!PageCompound(page), page); 641 page = compound_head(page); 642 return atomic_read(compound_mapcount_ptr(page)) + 1; 643 } 644 645 /* 646 * The atomic page->_mapcount, starts from -1: so that transitions 647 * both from it and to it can be tracked, using atomic_inc_and_test 648 * and atomic_add_negative(-1). 649 */ 650 static inline void page_mapcount_reset(struct page *page) 651 { 652 atomic_set(&(page)->_mapcount, -1); 653 } 654 655 int __page_mapcount(struct page *page); 656 657 static inline int page_mapcount(struct page *page) 658 { 659 VM_BUG_ON_PAGE(PageSlab(page), page); 660 661 if (unlikely(PageCompound(page))) 662 return __page_mapcount(page); 663 return atomic_read(&page->_mapcount) + 1; 664 } 665 666 #ifdef CONFIG_TRANSPARENT_HUGEPAGE 667 int total_mapcount(struct page *page); 668 int page_trans_huge_mapcount(struct page *page, int *total_mapcount); 669 #else 670 static inline int total_mapcount(struct page *page) 671 { 672 return page_mapcount(page); 673 } 674 static inline int page_trans_huge_mapcount(struct page *page, 675 int *total_mapcount) 676 { 677 int mapcount = page_mapcount(page); 678 if (total_mapcount) 679 *total_mapcount = mapcount; 680 return mapcount; 681 } 682 #endif 683 684 static inline struct page *virt_to_head_page(const void *x) 685 { 686 struct page *page = virt_to_page(x); 687 688 return compound_head(page); 689 } 690 691 void __put_page(struct page *page); 692 693 void put_pages_list(struct list_head *pages); 694 695 void split_page(struct page *page, unsigned int order); 696 697 /* 698 * Compound pages have a destructor function. Provide a 699 * prototype for that function and accessor functions. 700 * These are _only_ valid on the head of a compound page. 701 */ 702 typedef void compound_page_dtor(struct page *); 703 704 /* Keep the enum in sync with compound_page_dtors array in mm/page_alloc.c */ 705 enum compound_dtor_id { 706 NULL_COMPOUND_DTOR, 707 COMPOUND_PAGE_DTOR, 708 #ifdef CONFIG_HUGETLB_PAGE 709 HUGETLB_PAGE_DTOR, 710 #endif 711 #ifdef CONFIG_TRANSPARENT_HUGEPAGE 712 TRANSHUGE_PAGE_DTOR, 713 #endif 714 NR_COMPOUND_DTORS, 715 }; 716 extern compound_page_dtor * const compound_page_dtors[]; 717 718 static inline void set_compound_page_dtor(struct page *page, 719 enum compound_dtor_id compound_dtor) 720 { 721 VM_BUG_ON_PAGE(compound_dtor >= NR_COMPOUND_DTORS, page); 722 page[1].compound_dtor = compound_dtor; 723 } 724 725 static inline compound_page_dtor *get_compound_page_dtor(struct page *page) 726 { 727 VM_BUG_ON_PAGE(page[1].compound_dtor >= NR_COMPOUND_DTORS, page); 728 return compound_page_dtors[page[1].compound_dtor]; 729 } 730 731 static inline unsigned int compound_order(struct page *page) 732 { 733 if (!PageHead(page)) 734 return 0; 735 return page[1].compound_order; 736 } 737 738 static inline void set_compound_order(struct page *page, unsigned int order) 739 { 740 page[1].compound_order = order; 741 } 742 743 void free_compound_page(struct page *page); 744 745 #ifdef CONFIG_MMU 746 /* 747 * Do pte_mkwrite, but only if the vma says VM_WRITE. We do this when 748 * servicing faults for write access. In the normal case, do always want 749 * pte_mkwrite. But get_user_pages can cause write faults for mappings 750 * that do not have writing enabled, when used by access_process_vm. 751 */ 752 static inline pte_t maybe_mkwrite(pte_t pte, struct vm_area_struct *vma) 753 { 754 if (likely(vma->vm_flags & VM_WRITE)) 755 pte = pte_mkwrite(pte); 756 return pte; 757 } 758 759 vm_fault_t alloc_set_pte(struct vm_fault *vmf, struct mem_cgroup *memcg, 760 struct page *page); 761 vm_fault_t finish_fault(struct vm_fault *vmf); 762 vm_fault_t finish_mkwrite_fault(struct vm_fault *vmf); 763 #endif 764 765 /* 766 * Multiple processes may "see" the same page. E.g. for untouched 767 * mappings of /dev/null, all processes see the same page full of 768 * zeroes, and text pages of executables and shared libraries have 769 * only one copy in memory, at most, normally. 770 * 771 * For the non-reserved pages, page_count(page) denotes a reference count. 772 * page_count() == 0 means the page is free. page->lru is then used for 773 * freelist management in the buddy allocator. 774 * page_count() > 0 means the page has been allocated. 775 * 776 * Pages are allocated by the slab allocator in order to provide memory 777 * to kmalloc and kmem_cache_alloc. In this case, the management of the 778 * page, and the fields in 'struct page' are the responsibility of mm/slab.c 779 * unless a particular usage is carefully commented. (the responsibility of 780 * freeing the kmalloc memory is the caller's, of course). 781 * 782 * A page may be used by anyone else who does a __get_free_page(). 783 * In this case, page_count still tracks the references, and should only 784 * be used through the normal accessor functions. The top bits of page->flags 785 * and page->virtual store page management information, but all other fields 786 * are unused and could be used privately, carefully. The management of this 787 * page is the responsibility of the one who allocated it, and those who have 788 * subsequently been given references to it. 789 * 790 * The other pages (we may call them "pagecache pages") are completely 791 * managed by the Linux memory manager: I/O, buffers, swapping etc. 792 * The following discussion applies only to them. 793 * 794 * A pagecache page contains an opaque `private' member, which belongs to the 795 * page's address_space. Usually, this is the address of a circular list of 796 * the page's disk buffers. PG_private must be set to tell the VM to call 797 * into the filesystem to release these pages. 798 * 799 * A page may belong to an inode's memory mapping. In this case, page->mapping 800 * is the pointer to the inode, and page->index is the file offset of the page, 801 * in units of PAGE_SIZE. 802 * 803 * If pagecache pages are not associated with an inode, they are said to be 804 * anonymous pages. These may become associated with the swapcache, and in that 805 * case PG_swapcache is set, and page->private is an offset into the swapcache. 806 * 807 * In either case (swapcache or inode backed), the pagecache itself holds one 808 * reference to the page. Setting PG_private should also increment the 809 * refcount. The each user mapping also has a reference to the page. 810 * 811 * The pagecache pages are stored in a per-mapping radix tree, which is 812 * rooted at mapping->i_pages, and indexed by offset. 813 * Where 2.4 and early 2.6 kernels kept dirty/clean pages in per-address_space 814 * lists, we instead now tag pages as dirty/writeback in the radix tree. 815 * 816 * All pagecache pages may be subject to I/O: 817 * - inode pages may need to be read from disk, 818 * - inode pages which have been modified and are MAP_SHARED may need 819 * to be written back to the inode on disk, 820 * - anonymous pages (including MAP_PRIVATE file mappings) which have been 821 * modified may need to be swapped out to swap space and (later) to be read 822 * back into memory. 823 */ 824 825 /* 826 * The zone field is never updated after free_area_init_core() 827 * sets it, so none of the operations on it need to be atomic. 828 */ 829 830 /* Page flags: | [SECTION] | [NODE] | ZONE | [LAST_CPUPID] | ... | FLAGS | */ 831 #define SECTIONS_PGOFF ((sizeof(unsigned long)*8) - SECTIONS_WIDTH) 832 #define NODES_PGOFF (SECTIONS_PGOFF - NODES_WIDTH) 833 #define ZONES_PGOFF (NODES_PGOFF - ZONES_WIDTH) 834 #define LAST_CPUPID_PGOFF (ZONES_PGOFF - LAST_CPUPID_WIDTH) 835 #define KASAN_TAG_PGOFF (LAST_CPUPID_PGOFF - KASAN_TAG_WIDTH) 836 837 /* 838 * Define the bit shifts to access each section. For non-existent 839 * sections we define the shift as 0; that plus a 0 mask ensures 840 * the compiler will optimise away reference to them. 841 */ 842 #define SECTIONS_PGSHIFT (SECTIONS_PGOFF * (SECTIONS_WIDTH != 0)) 843 #define NODES_PGSHIFT (NODES_PGOFF * (NODES_WIDTH != 0)) 844 #define ZONES_PGSHIFT (ZONES_PGOFF * (ZONES_WIDTH != 0)) 845 #define LAST_CPUPID_PGSHIFT (LAST_CPUPID_PGOFF * (LAST_CPUPID_WIDTH != 0)) 846 #define KASAN_TAG_PGSHIFT (KASAN_TAG_PGOFF * (KASAN_TAG_WIDTH != 0)) 847 848 /* NODE:ZONE or SECTION:ZONE is used to ID a zone for the buddy allocator */ 849 #ifdef NODE_NOT_IN_PAGE_FLAGS 850 #define ZONEID_SHIFT (SECTIONS_SHIFT + ZONES_SHIFT) 851 #define ZONEID_PGOFF ((SECTIONS_PGOFF < ZONES_PGOFF)? \ 852 SECTIONS_PGOFF : ZONES_PGOFF) 853 #else 854 #define ZONEID_SHIFT (NODES_SHIFT + ZONES_SHIFT) 855 #define ZONEID_PGOFF ((NODES_PGOFF < ZONES_PGOFF)? \ 856 NODES_PGOFF : ZONES_PGOFF) 857 #endif 858 859 #define ZONEID_PGSHIFT (ZONEID_PGOFF * (ZONEID_SHIFT != 0)) 860 861 #if SECTIONS_WIDTH+NODES_WIDTH+ZONES_WIDTH > BITS_PER_LONG - NR_PAGEFLAGS 862 #error SECTIONS_WIDTH+NODES_WIDTH+ZONES_WIDTH > BITS_PER_LONG - NR_PAGEFLAGS 863 #endif 864 865 #define ZONES_MASK ((1UL << ZONES_WIDTH) - 1) 866 #define NODES_MASK ((1UL << NODES_WIDTH) - 1) 867 #define SECTIONS_MASK ((1UL << SECTIONS_WIDTH) - 1) 868 #define LAST_CPUPID_MASK ((1UL << LAST_CPUPID_SHIFT) - 1) 869 #define KASAN_TAG_MASK ((1UL << KASAN_TAG_WIDTH) - 1) 870 #define ZONEID_MASK ((1UL << ZONEID_SHIFT) - 1) 871 872 static inline enum zone_type page_zonenum(const struct page *page) 873 { 874 return (page->flags >> ZONES_PGSHIFT) & ZONES_MASK; 875 } 876 877 #ifdef CONFIG_ZONE_DEVICE 878 static inline bool is_zone_device_page(const struct page *page) 879 { 880 return page_zonenum(page) == ZONE_DEVICE; 881 } 882 extern void memmap_init_zone_device(struct zone *, unsigned long, 883 unsigned long, struct dev_pagemap *); 884 #else 885 static inline bool is_zone_device_page(const struct page *page) 886 { 887 return false; 888 } 889 #endif 890 891 #ifdef CONFIG_DEV_PAGEMAP_OPS 892 void dev_pagemap_get_ops(void); 893 void dev_pagemap_put_ops(void); 894 void __put_devmap_managed_page(struct page *page); 895 DECLARE_STATIC_KEY_FALSE(devmap_managed_key); 896 static inline bool put_devmap_managed_page(struct page *page) 897 { 898 if (!static_branch_unlikely(&devmap_managed_key)) 899 return false; 900 if (!is_zone_device_page(page)) 901 return false; 902 switch (page->pgmap->type) { 903 case MEMORY_DEVICE_PRIVATE: 904 case MEMORY_DEVICE_PUBLIC: 905 case MEMORY_DEVICE_FS_DAX: 906 __put_devmap_managed_page(page); 907 return true; 908 default: 909 break; 910 } 911 return false; 912 } 913 914 static inline bool is_device_private_page(const struct page *page) 915 { 916 return is_zone_device_page(page) && 917 page->pgmap->type == MEMORY_DEVICE_PRIVATE; 918 } 919 920 static inline bool is_device_public_page(const struct page *page) 921 { 922 return is_zone_device_page(page) && 923 page->pgmap->type == MEMORY_DEVICE_PUBLIC; 924 } 925 926 #ifdef CONFIG_PCI_P2PDMA 927 static inline bool is_pci_p2pdma_page(const struct page *page) 928 { 929 return is_zone_device_page(page) && 930 page->pgmap->type == MEMORY_DEVICE_PCI_P2PDMA; 931 } 932 #else /* CONFIG_PCI_P2PDMA */ 933 static inline bool is_pci_p2pdma_page(const struct page *page) 934 { 935 return false; 936 } 937 #endif /* CONFIG_PCI_P2PDMA */ 938 939 #else /* CONFIG_DEV_PAGEMAP_OPS */ 940 static inline void dev_pagemap_get_ops(void) 941 { 942 } 943 944 static inline void dev_pagemap_put_ops(void) 945 { 946 } 947 948 static inline bool put_devmap_managed_page(struct page *page) 949 { 950 return false; 951 } 952 953 static inline bool is_device_private_page(const struct page *page) 954 { 955 return false; 956 } 957 958 static inline bool is_device_public_page(const struct page *page) 959 { 960 return false; 961 } 962 963 static inline bool is_pci_p2pdma_page(const struct page *page) 964 { 965 return false; 966 } 967 #endif /* CONFIG_DEV_PAGEMAP_OPS */ 968 969 static inline void get_page(struct page *page) 970 { 971 page = compound_head(page); 972 /* 973 * Getting a normal page or the head of a compound page 974 * requires to already have an elevated page->_refcount. 975 */ 976 VM_BUG_ON_PAGE(page_ref_count(page) <= 0, page); 977 page_ref_inc(page); 978 } 979 980 static inline void put_page(struct page *page) 981 { 982 page = compound_head(page); 983 984 /* 985 * For devmap managed pages we need to catch refcount transition from 986 * 2 to 1, when refcount reach one it means the page is free and we 987 * need to inform the device driver through callback. See 988 * include/linux/memremap.h and HMM for details. 989 */ 990 if (put_devmap_managed_page(page)) 991 return; 992 993 if (put_page_testzero(page)) 994 __put_page(page); 995 } 996 997 #if defined(CONFIG_SPARSEMEM) && !defined(CONFIG_SPARSEMEM_VMEMMAP) 998 #define SECTION_IN_PAGE_FLAGS 999 #endif 1000 1001 /* 1002 * The identification function is mainly used by the buddy allocator for 1003 * determining if two pages could be buddies. We are not really identifying 1004 * the zone since we could be using the section number id if we do not have 1005 * node id available in page flags. 1006 * We only guarantee that it will return the same value for two combinable 1007 * pages in a zone. 1008 */ 1009 static inline int page_zone_id(struct page *page) 1010 { 1011 return (page->flags >> ZONEID_PGSHIFT) & ZONEID_MASK; 1012 } 1013 1014 #ifdef NODE_NOT_IN_PAGE_FLAGS 1015 extern int page_to_nid(const struct page *page); 1016 #else 1017 static inline int page_to_nid(const struct page *page) 1018 { 1019 struct page *p = (struct page *)page; 1020 1021 return (PF_POISONED_CHECK(p)->flags >> NODES_PGSHIFT) & NODES_MASK; 1022 } 1023 #endif 1024 1025 #ifdef CONFIG_NUMA_BALANCING 1026 static inline int cpu_pid_to_cpupid(int cpu, int pid) 1027 { 1028 return ((cpu & LAST__CPU_MASK) << LAST__PID_SHIFT) | (pid & LAST__PID_MASK); 1029 } 1030 1031 static inline int cpupid_to_pid(int cpupid) 1032 { 1033 return cpupid & LAST__PID_MASK; 1034 } 1035 1036 static inline int cpupid_to_cpu(int cpupid) 1037 { 1038 return (cpupid >> LAST__PID_SHIFT) & LAST__CPU_MASK; 1039 } 1040 1041 static inline int cpupid_to_nid(int cpupid) 1042 { 1043 return cpu_to_node(cpupid_to_cpu(cpupid)); 1044 } 1045 1046 static inline bool cpupid_pid_unset(int cpupid) 1047 { 1048 return cpupid_to_pid(cpupid) == (-1 & LAST__PID_MASK); 1049 } 1050 1051 static inline bool cpupid_cpu_unset(int cpupid) 1052 { 1053 return cpupid_to_cpu(cpupid) == (-1 & LAST__CPU_MASK); 1054 } 1055 1056 static inline bool __cpupid_match_pid(pid_t task_pid, int cpupid) 1057 { 1058 return (task_pid & LAST__PID_MASK) == cpupid_to_pid(cpupid); 1059 } 1060 1061 #define cpupid_match_pid(task, cpupid) __cpupid_match_pid(task->pid, cpupid) 1062 #ifdef LAST_CPUPID_NOT_IN_PAGE_FLAGS 1063 static inline int page_cpupid_xchg_last(struct page *page, int cpupid) 1064 { 1065 return xchg(&page->_last_cpupid, cpupid & LAST_CPUPID_MASK); 1066 } 1067 1068 static inline int page_cpupid_last(struct page *page) 1069 { 1070 return page->_last_cpupid; 1071 } 1072 static inline void page_cpupid_reset_last(struct page *page) 1073 { 1074 page->_last_cpupid = -1 & LAST_CPUPID_MASK; 1075 } 1076 #else 1077 static inline int page_cpupid_last(struct page *page) 1078 { 1079 return (page->flags >> LAST_CPUPID_PGSHIFT) & LAST_CPUPID_MASK; 1080 } 1081 1082 extern int page_cpupid_xchg_last(struct page *page, int cpupid); 1083 1084 static inline void page_cpupid_reset_last(struct page *page) 1085 { 1086 page->flags |= LAST_CPUPID_MASK << LAST_CPUPID_PGSHIFT; 1087 } 1088 #endif /* LAST_CPUPID_NOT_IN_PAGE_FLAGS */ 1089 #else /* !CONFIG_NUMA_BALANCING */ 1090 static inline int page_cpupid_xchg_last(struct page *page, int cpupid) 1091 { 1092 return page_to_nid(page); /* XXX */ 1093 } 1094 1095 static inline int page_cpupid_last(struct page *page) 1096 { 1097 return page_to_nid(page); /* XXX */ 1098 } 1099 1100 static inline int cpupid_to_nid(int cpupid) 1101 { 1102 return -1; 1103 } 1104 1105 static inline int cpupid_to_pid(int cpupid) 1106 { 1107 return -1; 1108 } 1109 1110 static inline int cpupid_to_cpu(int cpupid) 1111 { 1112 return -1; 1113 } 1114 1115 static inline int cpu_pid_to_cpupid(int nid, int pid) 1116 { 1117 return -1; 1118 } 1119 1120 static inline bool cpupid_pid_unset(int cpupid) 1121 { 1122 return 1; 1123 } 1124 1125 static inline void page_cpupid_reset_last(struct page *page) 1126 { 1127 } 1128 1129 static inline bool cpupid_match_pid(struct task_struct *task, int cpupid) 1130 { 1131 return false; 1132 } 1133 #endif /* CONFIG_NUMA_BALANCING */ 1134 1135 #ifdef CONFIG_KASAN_SW_TAGS 1136 static inline u8 page_kasan_tag(const struct page *page) 1137 { 1138 return (page->flags >> KASAN_TAG_PGSHIFT) & KASAN_TAG_MASK; 1139 } 1140 1141 static inline void page_kasan_tag_set(struct page *page, u8 tag) 1142 { 1143 page->flags &= ~(KASAN_TAG_MASK << KASAN_TAG_PGSHIFT); 1144 page->flags |= (tag & KASAN_TAG_MASK) << KASAN_TAG_PGSHIFT; 1145 } 1146 1147 static inline void page_kasan_tag_reset(struct page *page) 1148 { 1149 page_kasan_tag_set(page, 0xff); 1150 } 1151 #else 1152 static inline u8 page_kasan_tag(const struct page *page) 1153 { 1154 return 0xff; 1155 } 1156 1157 static inline void page_kasan_tag_set(struct page *page, u8 tag) { } 1158 static inline void page_kasan_tag_reset(struct page *page) { } 1159 #endif 1160 1161 static inline struct zone *page_zone(const struct page *page) 1162 { 1163 return &NODE_DATA(page_to_nid(page))->node_zones[page_zonenum(page)]; 1164 } 1165 1166 static inline pg_data_t *page_pgdat(const struct page *page) 1167 { 1168 return NODE_DATA(page_to_nid(page)); 1169 } 1170 1171 #ifdef SECTION_IN_PAGE_FLAGS 1172 static inline void set_page_section(struct page *page, unsigned long section) 1173 { 1174 page->flags &= ~(SECTIONS_MASK << SECTIONS_PGSHIFT); 1175 page->flags |= (section & SECTIONS_MASK) << SECTIONS_PGSHIFT; 1176 } 1177 1178 static inline unsigned long page_to_section(const struct page *page) 1179 { 1180 return (page->flags >> SECTIONS_PGSHIFT) & SECTIONS_MASK; 1181 } 1182 #endif 1183 1184 static inline void set_page_zone(struct page *page, enum zone_type zone) 1185 { 1186 page->flags &= ~(ZONES_MASK << ZONES_PGSHIFT); 1187 page->flags |= (zone & ZONES_MASK) << ZONES_PGSHIFT; 1188 } 1189 1190 static inline void set_page_node(struct page *page, unsigned long node) 1191 { 1192 page->flags &= ~(NODES_MASK << NODES_PGSHIFT); 1193 page->flags |= (node & NODES_MASK) << NODES_PGSHIFT; 1194 } 1195 1196 static inline void set_page_links(struct page *page, enum zone_type zone, 1197 unsigned long node, unsigned long pfn) 1198 { 1199 set_page_zone(page, zone); 1200 set_page_node(page, node); 1201 #ifdef SECTION_IN_PAGE_FLAGS 1202 set_page_section(page, pfn_to_section_nr(pfn)); 1203 #endif 1204 } 1205 1206 #ifdef CONFIG_MEMCG 1207 static inline struct mem_cgroup *page_memcg(struct page *page) 1208 { 1209 return page->mem_cgroup; 1210 } 1211 static inline struct mem_cgroup *page_memcg_rcu(struct page *page) 1212 { 1213 WARN_ON_ONCE(!rcu_read_lock_held()); 1214 return READ_ONCE(page->mem_cgroup); 1215 } 1216 #else 1217 static inline struct mem_cgroup *page_memcg(struct page *page) 1218 { 1219 return NULL; 1220 } 1221 static inline struct mem_cgroup *page_memcg_rcu(struct page *page) 1222 { 1223 WARN_ON_ONCE(!rcu_read_lock_held()); 1224 return NULL; 1225 } 1226 #endif 1227 1228 /* 1229 * Some inline functions in vmstat.h depend on page_zone() 1230 */ 1231 #include <linux/vmstat.h> 1232 1233 static __always_inline void *lowmem_page_address(const struct page *page) 1234 { 1235 return page_to_virt(page); 1236 } 1237 1238 #if defined(CONFIG_HIGHMEM) && !defined(WANT_PAGE_VIRTUAL) 1239 #define HASHED_PAGE_VIRTUAL 1240 #endif 1241 1242 #if defined(WANT_PAGE_VIRTUAL) 1243 static inline void *page_address(const struct page *page) 1244 { 1245 return page->virtual; 1246 } 1247 static inline void set_page_address(struct page *page, void *address) 1248 { 1249 page->virtual = address; 1250 } 1251 #define page_address_init() do { } while(0) 1252 #endif 1253 1254 #if defined(HASHED_PAGE_VIRTUAL) 1255 void *page_address(const struct page *page); 1256 void set_page_address(struct page *page, void *virtual); 1257 void page_address_init(void); 1258 #endif 1259 1260 #if !defined(HASHED_PAGE_VIRTUAL) && !defined(WANT_PAGE_VIRTUAL) 1261 #define page_address(page) lowmem_page_address(page) 1262 #define set_page_address(page, address) do { } while(0) 1263 #define page_address_init() do { } while(0) 1264 #endif 1265 1266 extern void *page_rmapping(struct page *page); 1267 extern struct anon_vma *page_anon_vma(struct page *page); 1268 extern struct address_space *page_mapping(struct page *page); 1269 1270 extern struct address_space *__page_file_mapping(struct page *); 1271 1272 static inline 1273 struct address_space *page_file_mapping(struct page *page) 1274 { 1275 if (unlikely(PageSwapCache(page))) 1276 return __page_file_mapping(page); 1277 1278 return page->mapping; 1279 } 1280 1281 extern pgoff_t __page_file_index(struct page *page); 1282 1283 /* 1284 * Return the pagecache index of the passed page. Regular pagecache pages 1285 * use ->index whereas swapcache pages use swp_offset(->private) 1286 */ 1287 static inline pgoff_t page_index(struct page *page) 1288 { 1289 if (unlikely(PageSwapCache(page))) 1290 return __page_file_index(page); 1291 return page->index; 1292 } 1293 1294 bool page_mapped(struct page *page); 1295 struct address_space *page_mapping(struct page *page); 1296 struct address_space *page_mapping_file(struct page *page); 1297 1298 /* 1299 * Return true only if the page has been allocated with 1300 * ALLOC_NO_WATERMARKS and the low watermark was not 1301 * met implying that the system is under some pressure. 1302 */ 1303 static inline bool page_is_pfmemalloc(struct page *page) 1304 { 1305 /* 1306 * Page index cannot be this large so this must be 1307 * a pfmemalloc page. 1308 */ 1309 return page->index == -1UL; 1310 } 1311 1312 /* 1313 * Only to be called by the page allocator on a freshly allocated 1314 * page. 1315 */ 1316 static inline void set_page_pfmemalloc(struct page *page) 1317 { 1318 page->index = -1UL; 1319 } 1320 1321 static inline void clear_page_pfmemalloc(struct page *page) 1322 { 1323 page->index = 0; 1324 } 1325 1326 /* 1327 * Can be called by the pagefault handler when it gets a VM_FAULT_OOM. 1328 */ 1329 extern void pagefault_out_of_memory(void); 1330 1331 #define offset_in_page(p) ((unsigned long)(p) & ~PAGE_MASK) 1332 1333 /* 1334 * Flags passed to show_mem() and show_free_areas() to suppress output in 1335 * various contexts. 1336 */ 1337 #define SHOW_MEM_FILTER_NODES (0x0001u) /* disallowed nodes */ 1338 1339 extern void show_free_areas(unsigned int flags, nodemask_t *nodemask); 1340 1341 extern bool can_do_mlock(void); 1342 extern int user_shm_lock(size_t, struct user_struct *); 1343 extern void user_shm_unlock(size_t, struct user_struct *); 1344 1345 /* 1346 * Parameter block passed down to zap_pte_range in exceptional cases. 1347 */ 1348 struct zap_details { 1349 struct address_space *check_mapping; /* Check page->mapping if set */ 1350 pgoff_t first_index; /* Lowest page->index to unmap */ 1351 pgoff_t last_index; /* Highest page->index to unmap */ 1352 }; 1353 1354 struct page *_vm_normal_page(struct vm_area_struct *vma, unsigned long addr, 1355 pte_t pte, bool with_public_device); 1356 #define vm_normal_page(vma, addr, pte) _vm_normal_page(vma, addr, pte, false) 1357 1358 struct page *vm_normal_page_pmd(struct vm_area_struct *vma, unsigned long addr, 1359 pmd_t pmd); 1360 1361 void zap_vma_ptes(struct vm_area_struct *vma, unsigned long address, 1362 unsigned long size); 1363 void zap_page_range(struct vm_area_struct *vma, unsigned long address, 1364 unsigned long size); 1365 void unmap_vmas(struct mmu_gather *tlb, struct vm_area_struct *start_vma, 1366 unsigned long start, unsigned long end); 1367 1368 /** 1369 * mm_walk - callbacks for walk_page_range 1370 * @pud_entry: if set, called for each non-empty PUD (2nd-level) entry 1371 * this handler should only handle pud_trans_huge() puds. 1372 * the pmd_entry or pte_entry callbacks will be used for 1373 * regular PUDs. 1374 * @pmd_entry: if set, called for each non-empty PMD (3rd-level) entry 1375 * this handler is required to be able to handle 1376 * pmd_trans_huge() pmds. They may simply choose to 1377 * split_huge_page() instead of handling it explicitly. 1378 * @pte_entry: if set, called for each non-empty PTE (4th-level) entry 1379 * @pte_hole: if set, called for each hole at all levels 1380 * @hugetlb_entry: if set, called for each hugetlb entry 1381 * @test_walk: caller specific callback function to determine whether 1382 * we walk over the current vma or not. Returning 0 1383 * value means "do page table walk over the current vma," 1384 * and a negative one means "abort current page table walk 1385 * right now." 1 means "skip the current vma." 1386 * @mm: mm_struct representing the target process of page table walk 1387 * @vma: vma currently walked (NULL if walking outside vmas) 1388 * @private: private data for callbacks' usage 1389 * 1390 * (see the comment on walk_page_range() for more details) 1391 */ 1392 struct mm_walk { 1393 int (*pud_entry)(pud_t *pud, unsigned long addr, 1394 unsigned long next, struct mm_walk *walk); 1395 int (*pmd_entry)(pmd_t *pmd, unsigned long addr, 1396 unsigned long next, struct mm_walk *walk); 1397 int (*pte_entry)(pte_t *pte, unsigned long addr, 1398 unsigned long next, struct mm_walk *walk); 1399 int (*pte_hole)(unsigned long addr, unsigned long next, 1400 struct mm_walk *walk); 1401 int (*hugetlb_entry)(pte_t *pte, unsigned long hmask, 1402 unsigned long addr, unsigned long next, 1403 struct mm_walk *walk); 1404 int (*test_walk)(unsigned long addr, unsigned long next, 1405 struct mm_walk *walk); 1406 struct mm_struct *mm; 1407 struct vm_area_struct *vma; 1408 void *private; 1409 }; 1410 1411 struct mmu_notifier_range; 1412 1413 int walk_page_range(unsigned long addr, unsigned long end, 1414 struct mm_walk *walk); 1415 int walk_page_vma(struct vm_area_struct *vma, struct mm_walk *walk); 1416 void free_pgd_range(struct mmu_gather *tlb, unsigned long addr, 1417 unsigned long end, unsigned long floor, unsigned long ceiling); 1418 int copy_page_range(struct mm_struct *dst, struct mm_struct *src, 1419 struct vm_area_struct *vma); 1420 int follow_pte_pmd(struct mm_struct *mm, unsigned long address, 1421 struct mmu_notifier_range *range, 1422 pte_t **ptepp, pmd_t **pmdpp, spinlock_t **ptlp); 1423 int follow_pfn(struct vm_area_struct *vma, unsigned long address, 1424 unsigned long *pfn); 1425 int follow_phys(struct vm_area_struct *vma, unsigned long address, 1426 unsigned int flags, unsigned long *prot, resource_size_t *phys); 1427 int generic_access_phys(struct vm_area_struct *vma, unsigned long addr, 1428 void *buf, int len, int write); 1429 1430 extern void truncate_pagecache(struct inode *inode, loff_t new); 1431 extern void truncate_setsize(struct inode *inode, loff_t newsize); 1432 void pagecache_isize_extended(struct inode *inode, loff_t from, loff_t to); 1433 void truncate_pagecache_range(struct inode *inode, loff_t offset, loff_t end); 1434 int truncate_inode_page(struct address_space *mapping, struct page *page); 1435 int generic_error_remove_page(struct address_space *mapping, struct page *page); 1436 int invalidate_inode_page(struct page *page); 1437 1438 #ifdef CONFIG_MMU 1439 extern vm_fault_t handle_mm_fault(struct vm_area_struct *vma, 1440 unsigned long address, unsigned int flags); 1441 extern int fixup_user_fault(struct task_struct *tsk, struct mm_struct *mm, 1442 unsigned long address, unsigned int fault_flags, 1443 bool *unlocked); 1444 void unmap_mapping_pages(struct address_space *mapping, 1445 pgoff_t start, pgoff_t nr, bool even_cows); 1446 void unmap_mapping_range(struct address_space *mapping, 1447 loff_t const holebegin, loff_t const holelen, int even_cows); 1448 #else 1449 static inline vm_fault_t handle_mm_fault(struct vm_area_struct *vma, 1450 unsigned long address, unsigned int flags) 1451 { 1452 /* should never happen if there's no MMU */ 1453 BUG(); 1454 return VM_FAULT_SIGBUS; 1455 } 1456 static inline int fixup_user_fault(struct task_struct *tsk, 1457 struct mm_struct *mm, unsigned long address, 1458 unsigned int fault_flags, bool *unlocked) 1459 { 1460 /* should never happen if there's no MMU */ 1461 BUG(); 1462 return -EFAULT; 1463 } 1464 static inline void unmap_mapping_pages(struct address_space *mapping, 1465 pgoff_t start, pgoff_t nr, bool even_cows) { } 1466 static inline void unmap_mapping_range(struct address_space *mapping, 1467 loff_t const holebegin, loff_t const holelen, int even_cows) { } 1468 #endif 1469 1470 static inline void unmap_shared_mapping_range(struct address_space *mapping, 1471 loff_t const holebegin, loff_t const holelen) 1472 { 1473 unmap_mapping_range(mapping, holebegin, holelen, 0); 1474 } 1475 1476 extern int access_process_vm(struct task_struct *tsk, unsigned long addr, 1477 void *buf, int len, unsigned int gup_flags); 1478 extern int access_remote_vm(struct mm_struct *mm, unsigned long addr, 1479 void *buf, int len, unsigned int gup_flags); 1480 extern int __access_remote_vm(struct task_struct *tsk, struct mm_struct *mm, 1481 unsigned long addr, void *buf, int len, unsigned int gup_flags); 1482 1483 long get_user_pages_remote(struct task_struct *tsk, struct mm_struct *mm, 1484 unsigned long start, unsigned long nr_pages, 1485 unsigned int gup_flags, struct page **pages, 1486 struct vm_area_struct **vmas, int *locked); 1487 long get_user_pages(unsigned long start, unsigned long nr_pages, 1488 unsigned int gup_flags, struct page **pages, 1489 struct vm_area_struct **vmas); 1490 long get_user_pages_locked(unsigned long start, unsigned long nr_pages, 1491 unsigned int gup_flags, struct page **pages, int *locked); 1492 long get_user_pages_unlocked(unsigned long start, unsigned long nr_pages, 1493 struct page **pages, unsigned int gup_flags); 1494 1495 #if defined(CONFIG_FS_DAX) || defined(CONFIG_CMA) 1496 long get_user_pages_longterm(unsigned long start, unsigned long nr_pages, 1497 unsigned int gup_flags, struct page **pages, 1498 struct vm_area_struct **vmas); 1499 #else 1500 static inline long get_user_pages_longterm(unsigned long start, 1501 unsigned long nr_pages, unsigned int gup_flags, 1502 struct page **pages, struct vm_area_struct **vmas) 1503 { 1504 return get_user_pages(start, nr_pages, gup_flags, pages, vmas); 1505 } 1506 #endif /* CONFIG_FS_DAX */ 1507 1508 int get_user_pages_fast(unsigned long start, int nr_pages, int write, 1509 struct page **pages); 1510 1511 /* Container for pinned pfns / pages */ 1512 struct frame_vector { 1513 unsigned int nr_allocated; /* Number of frames we have space for */ 1514 unsigned int nr_frames; /* Number of frames stored in ptrs array */ 1515 bool got_ref; /* Did we pin pages by getting page ref? */ 1516 bool is_pfns; /* Does array contain pages or pfns? */ 1517 void *ptrs[0]; /* Array of pinned pfns / pages. Use 1518 * pfns_vector_pages() or pfns_vector_pfns() 1519 * for access */ 1520 }; 1521 1522 struct frame_vector *frame_vector_create(unsigned int nr_frames); 1523 void frame_vector_destroy(struct frame_vector *vec); 1524 int get_vaddr_frames(unsigned long start, unsigned int nr_pfns, 1525 unsigned int gup_flags, struct frame_vector *vec); 1526 void put_vaddr_frames(struct frame_vector *vec); 1527 int frame_vector_to_pages(struct frame_vector *vec); 1528 void frame_vector_to_pfns(struct frame_vector *vec); 1529 1530 static inline unsigned int frame_vector_count(struct frame_vector *vec) 1531 { 1532 return vec->nr_frames; 1533 } 1534 1535 static inline struct page **frame_vector_pages(struct frame_vector *vec) 1536 { 1537 if (vec->is_pfns) { 1538 int err = frame_vector_to_pages(vec); 1539 1540 if (err) 1541 return ERR_PTR(err); 1542 } 1543 return (struct page **)(vec->ptrs); 1544 } 1545 1546 static inline unsigned long *frame_vector_pfns(struct frame_vector *vec) 1547 { 1548 if (!vec->is_pfns) 1549 frame_vector_to_pfns(vec); 1550 return (unsigned long *)(vec->ptrs); 1551 } 1552 1553 struct kvec; 1554 int get_kernel_pages(const struct kvec *iov, int nr_pages, int write, 1555 struct page **pages); 1556 int get_kernel_page(unsigned long start, int write, struct page **pages); 1557 struct page *get_dump_page(unsigned long addr); 1558 1559 extern int try_to_release_page(struct page * page, gfp_t gfp_mask); 1560 extern void do_invalidatepage(struct page *page, unsigned int offset, 1561 unsigned int length); 1562 1563 void __set_page_dirty(struct page *, struct address_space *, int warn); 1564 int __set_page_dirty_nobuffers(struct page *page); 1565 int __set_page_dirty_no_writeback(struct page *page); 1566 int redirty_page_for_writepage(struct writeback_control *wbc, 1567 struct page *page); 1568 void account_page_dirtied(struct page *page, struct address_space *mapping); 1569 void account_page_cleaned(struct page *page, struct address_space *mapping, 1570 struct bdi_writeback *wb); 1571 int set_page_dirty(struct page *page); 1572 int set_page_dirty_lock(struct page *page); 1573 void __cancel_dirty_page(struct page *page); 1574 static inline void cancel_dirty_page(struct page *page) 1575 { 1576 /* Avoid atomic ops, locking, etc. when not actually needed. */ 1577 if (PageDirty(page)) 1578 __cancel_dirty_page(page); 1579 } 1580 int clear_page_dirty_for_io(struct page *page); 1581 1582 int get_cmdline(struct task_struct *task, char *buffer, int buflen); 1583 1584 static inline bool vma_is_anonymous(struct vm_area_struct *vma) 1585 { 1586 return !vma->vm_ops; 1587 } 1588 1589 #ifdef CONFIG_SHMEM 1590 /* 1591 * The vma_is_shmem is not inline because it is used only by slow 1592 * paths in userfault. 1593 */ 1594 bool vma_is_shmem(struct vm_area_struct *vma); 1595 #else 1596 static inline bool vma_is_shmem(struct vm_area_struct *vma) { return false; } 1597 #endif 1598 1599 int vma_is_stack_for_current(struct vm_area_struct *vma); 1600 1601 extern unsigned long move_page_tables(struct vm_area_struct *vma, 1602 unsigned long old_addr, struct vm_area_struct *new_vma, 1603 unsigned long new_addr, unsigned long len, 1604 bool need_rmap_locks); 1605 extern unsigned long change_protection(struct vm_area_struct *vma, unsigned long start, 1606 unsigned long end, pgprot_t newprot, 1607 int dirty_accountable, int prot_numa); 1608 extern int mprotect_fixup(struct vm_area_struct *vma, 1609 struct vm_area_struct **pprev, unsigned long start, 1610 unsigned long end, unsigned long newflags); 1611 1612 /* 1613 * doesn't attempt to fault and will return short. 1614 */ 1615 int __get_user_pages_fast(unsigned long start, int nr_pages, int write, 1616 struct page **pages); 1617 /* 1618 * per-process(per-mm_struct) statistics. 1619 */ 1620 static inline unsigned long get_mm_counter(struct mm_struct *mm, int member) 1621 { 1622 long val = atomic_long_read(&mm->rss_stat.count[member]); 1623 1624 #ifdef SPLIT_RSS_COUNTING 1625 /* 1626 * counter is updated in asynchronous manner and may go to minus. 1627 * But it's never be expected number for users. 1628 */ 1629 if (val < 0) 1630 val = 0; 1631 #endif 1632 return (unsigned long)val; 1633 } 1634 1635 static inline void add_mm_counter(struct mm_struct *mm, int member, long value) 1636 { 1637 atomic_long_add(value, &mm->rss_stat.count[member]); 1638 } 1639 1640 static inline void inc_mm_counter(struct mm_struct *mm, int member) 1641 { 1642 atomic_long_inc(&mm->rss_stat.count[member]); 1643 } 1644 1645 static inline void dec_mm_counter(struct mm_struct *mm, int member) 1646 { 1647 atomic_long_dec(&mm->rss_stat.count[member]); 1648 } 1649 1650 /* Optimized variant when page is already known not to be PageAnon */ 1651 static inline int mm_counter_file(struct page *page) 1652 { 1653 if (PageSwapBacked(page)) 1654 return MM_SHMEMPAGES; 1655 return MM_FILEPAGES; 1656 } 1657 1658 static inline int mm_counter(struct page *page) 1659 { 1660 if (PageAnon(page)) 1661 return MM_ANONPAGES; 1662 return mm_counter_file(page); 1663 } 1664 1665 static inline unsigned long get_mm_rss(struct mm_struct *mm) 1666 { 1667 return get_mm_counter(mm, MM_FILEPAGES) + 1668 get_mm_counter(mm, MM_ANONPAGES) + 1669 get_mm_counter(mm, MM_SHMEMPAGES); 1670 } 1671 1672 static inline unsigned long get_mm_hiwater_rss(struct mm_struct *mm) 1673 { 1674 return max(mm->hiwater_rss, get_mm_rss(mm)); 1675 } 1676 1677 static inline unsigned long get_mm_hiwater_vm(struct mm_struct *mm) 1678 { 1679 return max(mm->hiwater_vm, mm->total_vm); 1680 } 1681 1682 static inline void update_hiwater_rss(struct mm_struct *mm) 1683 { 1684 unsigned long _rss = get_mm_rss(mm); 1685 1686 if ((mm)->hiwater_rss < _rss) 1687 (mm)->hiwater_rss = _rss; 1688 } 1689 1690 static inline void update_hiwater_vm(struct mm_struct *mm) 1691 { 1692 if (mm->hiwater_vm < mm->total_vm) 1693 mm->hiwater_vm = mm->total_vm; 1694 } 1695 1696 static inline void reset_mm_hiwater_rss(struct mm_struct *mm) 1697 { 1698 mm->hiwater_rss = get_mm_rss(mm); 1699 } 1700 1701 static inline void setmax_mm_hiwater_rss(unsigned long *maxrss, 1702 struct mm_struct *mm) 1703 { 1704 unsigned long hiwater_rss = get_mm_hiwater_rss(mm); 1705 1706 if (*maxrss < hiwater_rss) 1707 *maxrss = hiwater_rss; 1708 } 1709 1710 #if defined(SPLIT_RSS_COUNTING) 1711 void sync_mm_rss(struct mm_struct *mm); 1712 #else 1713 static inline void sync_mm_rss(struct mm_struct *mm) 1714 { 1715 } 1716 #endif 1717 1718 #ifndef __HAVE_ARCH_PTE_DEVMAP 1719 static inline int pte_devmap(pte_t pte) 1720 { 1721 return 0; 1722 } 1723 #endif 1724 1725 int vma_wants_writenotify(struct vm_area_struct *vma, pgprot_t vm_page_prot); 1726 1727 extern pte_t *__get_locked_pte(struct mm_struct *mm, unsigned long addr, 1728 spinlock_t **ptl); 1729 static inline pte_t *get_locked_pte(struct mm_struct *mm, unsigned long addr, 1730 spinlock_t **ptl) 1731 { 1732 pte_t *ptep; 1733 __cond_lock(*ptl, ptep = __get_locked_pte(mm, addr, ptl)); 1734 return ptep; 1735 } 1736 1737 #ifdef __PAGETABLE_P4D_FOLDED 1738 static inline int __p4d_alloc(struct mm_struct *mm, pgd_t *pgd, 1739 unsigned long address) 1740 { 1741 return 0; 1742 } 1743 #else 1744 int __p4d_alloc(struct mm_struct *mm, pgd_t *pgd, unsigned long address); 1745 #endif 1746 1747 #if defined(__PAGETABLE_PUD_FOLDED) || !defined(CONFIG_MMU) 1748 static inline int __pud_alloc(struct mm_struct *mm, p4d_t *p4d, 1749 unsigned long address) 1750 { 1751 return 0; 1752 } 1753 static inline void mm_inc_nr_puds(struct mm_struct *mm) {} 1754 static inline void mm_dec_nr_puds(struct mm_struct *mm) {} 1755 1756 #else 1757 int __pud_alloc(struct mm_struct *mm, p4d_t *p4d, unsigned long address); 1758 1759 static inline void mm_inc_nr_puds(struct mm_struct *mm) 1760 { 1761 if (mm_pud_folded(mm)) 1762 return; 1763 atomic_long_add(PTRS_PER_PUD * sizeof(pud_t), &mm->pgtables_bytes); 1764 } 1765 1766 static inline void mm_dec_nr_puds(struct mm_struct *mm) 1767 { 1768 if (mm_pud_folded(mm)) 1769 return; 1770 atomic_long_sub(PTRS_PER_PUD * sizeof(pud_t), &mm->pgtables_bytes); 1771 } 1772 #endif 1773 1774 #if defined(__PAGETABLE_PMD_FOLDED) || !defined(CONFIG_MMU) 1775 static inline int __pmd_alloc(struct mm_struct *mm, pud_t *pud, 1776 unsigned long address) 1777 { 1778 return 0; 1779 } 1780 1781 static inline void mm_inc_nr_pmds(struct mm_struct *mm) {} 1782 static inline void mm_dec_nr_pmds(struct mm_struct *mm) {} 1783 1784 #else 1785 int __pmd_alloc(struct mm_struct *mm, pud_t *pud, unsigned long address); 1786 1787 static inline void mm_inc_nr_pmds(struct mm_struct *mm) 1788 { 1789 if (mm_pmd_folded(mm)) 1790 return; 1791 atomic_long_add(PTRS_PER_PMD * sizeof(pmd_t), &mm->pgtables_bytes); 1792 } 1793 1794 static inline void mm_dec_nr_pmds(struct mm_struct *mm) 1795 { 1796 if (mm_pmd_folded(mm)) 1797 return; 1798 atomic_long_sub(PTRS_PER_PMD * sizeof(pmd_t), &mm->pgtables_bytes); 1799 } 1800 #endif 1801 1802 #ifdef CONFIG_MMU 1803 static inline void mm_pgtables_bytes_init(struct mm_struct *mm) 1804 { 1805 atomic_long_set(&mm->pgtables_bytes, 0); 1806 } 1807 1808 static inline unsigned long mm_pgtables_bytes(const struct mm_struct *mm) 1809 { 1810 return atomic_long_read(&mm->pgtables_bytes); 1811 } 1812 1813 static inline void mm_inc_nr_ptes(struct mm_struct *mm) 1814 { 1815 atomic_long_add(PTRS_PER_PTE * sizeof(pte_t), &mm->pgtables_bytes); 1816 } 1817 1818 static inline void mm_dec_nr_ptes(struct mm_struct *mm) 1819 { 1820 atomic_long_sub(PTRS_PER_PTE * sizeof(pte_t), &mm->pgtables_bytes); 1821 } 1822 #else 1823 1824 static inline void mm_pgtables_bytes_init(struct mm_struct *mm) {} 1825 static inline unsigned long mm_pgtables_bytes(const struct mm_struct *mm) 1826 { 1827 return 0; 1828 } 1829 1830 static inline void mm_inc_nr_ptes(struct mm_struct *mm) {} 1831 static inline void mm_dec_nr_ptes(struct mm_struct *mm) {} 1832 #endif 1833 1834 int __pte_alloc(struct mm_struct *mm, pmd_t *pmd); 1835 int __pte_alloc_kernel(pmd_t *pmd); 1836 1837 /* 1838 * The following ifdef needed to get the 4level-fixup.h header to work. 1839 * Remove it when 4level-fixup.h has been removed. 1840 */ 1841 #if defined(CONFIG_MMU) && !defined(__ARCH_HAS_4LEVEL_HACK) 1842 1843 #ifndef __ARCH_HAS_5LEVEL_HACK 1844 static inline p4d_t *p4d_alloc(struct mm_struct *mm, pgd_t *pgd, 1845 unsigned long address) 1846 { 1847 return (unlikely(pgd_none(*pgd)) && __p4d_alloc(mm, pgd, address)) ? 1848 NULL : p4d_offset(pgd, address); 1849 } 1850 1851 static inline pud_t *pud_alloc(struct mm_struct *mm, p4d_t *p4d, 1852 unsigned long address) 1853 { 1854 return (unlikely(p4d_none(*p4d)) && __pud_alloc(mm, p4d, address)) ? 1855 NULL : pud_offset(p4d, address); 1856 } 1857 #endif /* !__ARCH_HAS_5LEVEL_HACK */ 1858 1859 static inline pmd_t *pmd_alloc(struct mm_struct *mm, pud_t *pud, unsigned long address) 1860 { 1861 return (unlikely(pud_none(*pud)) && __pmd_alloc(mm, pud, address))? 1862 NULL: pmd_offset(pud, address); 1863 } 1864 #endif /* CONFIG_MMU && !__ARCH_HAS_4LEVEL_HACK */ 1865 1866 #if USE_SPLIT_PTE_PTLOCKS 1867 #if ALLOC_SPLIT_PTLOCKS 1868 void __init ptlock_cache_init(void); 1869 extern bool ptlock_alloc(struct page *page); 1870 extern void ptlock_free(struct page *page); 1871 1872 static inline spinlock_t *ptlock_ptr(struct page *page) 1873 { 1874 return page->ptl; 1875 } 1876 #else /* ALLOC_SPLIT_PTLOCKS */ 1877 static inline void ptlock_cache_init(void) 1878 { 1879 } 1880 1881 static inline bool ptlock_alloc(struct page *page) 1882 { 1883 return true; 1884 } 1885 1886 static inline void ptlock_free(struct page *page) 1887 { 1888 } 1889 1890 static inline spinlock_t *ptlock_ptr(struct page *page) 1891 { 1892 return &page->ptl; 1893 } 1894 #endif /* ALLOC_SPLIT_PTLOCKS */ 1895 1896 static inline spinlock_t *pte_lockptr(struct mm_struct *mm, pmd_t *pmd) 1897 { 1898 return ptlock_ptr(pmd_page(*pmd)); 1899 } 1900 1901 static inline bool ptlock_init(struct page *page) 1902 { 1903 /* 1904 * prep_new_page() initialize page->private (and therefore page->ptl) 1905 * with 0. Make sure nobody took it in use in between. 1906 * 1907 * It can happen if arch try to use slab for page table allocation: 1908 * slab code uses page->slab_cache, which share storage with page->ptl. 1909 */ 1910 VM_BUG_ON_PAGE(*(unsigned long *)&page->ptl, page); 1911 if (!ptlock_alloc(page)) 1912 return false; 1913 spin_lock_init(ptlock_ptr(page)); 1914 return true; 1915 } 1916 1917 #else /* !USE_SPLIT_PTE_PTLOCKS */ 1918 /* 1919 * We use mm->page_table_lock to guard all pagetable pages of the mm. 1920 */ 1921 static inline spinlock_t *pte_lockptr(struct mm_struct *mm, pmd_t *pmd) 1922 { 1923 return &mm->page_table_lock; 1924 } 1925 static inline void ptlock_cache_init(void) {} 1926 static inline bool ptlock_init(struct page *page) { return true; } 1927 static inline void ptlock_free(struct page *page) {} 1928 #endif /* USE_SPLIT_PTE_PTLOCKS */ 1929 1930 static inline void pgtable_init(void) 1931 { 1932 ptlock_cache_init(); 1933 pgtable_cache_init(); 1934 } 1935 1936 static inline bool pgtable_page_ctor(struct page *page) 1937 { 1938 if (!ptlock_init(page)) 1939 return false; 1940 __SetPageTable(page); 1941 inc_zone_page_state(page, NR_PAGETABLE); 1942 return true; 1943 } 1944 1945 static inline void pgtable_page_dtor(struct page *page) 1946 { 1947 ptlock_free(page); 1948 __ClearPageTable(page); 1949 dec_zone_page_state(page, NR_PAGETABLE); 1950 } 1951 1952 #define pte_offset_map_lock(mm, pmd, address, ptlp) \ 1953 ({ \ 1954 spinlock_t *__ptl = pte_lockptr(mm, pmd); \ 1955 pte_t *__pte = pte_offset_map(pmd, address); \ 1956 *(ptlp) = __ptl; \ 1957 spin_lock(__ptl); \ 1958 __pte; \ 1959 }) 1960 1961 #define pte_unmap_unlock(pte, ptl) do { \ 1962 spin_unlock(ptl); \ 1963 pte_unmap(pte); \ 1964 } while (0) 1965 1966 #define pte_alloc(mm, pmd) (unlikely(pmd_none(*(pmd))) && __pte_alloc(mm, pmd)) 1967 1968 #define pte_alloc_map(mm, pmd, address) \ 1969 (pte_alloc(mm, pmd) ? NULL : pte_offset_map(pmd, address)) 1970 1971 #define pte_alloc_map_lock(mm, pmd, address, ptlp) \ 1972 (pte_alloc(mm, pmd) ? \ 1973 NULL : pte_offset_map_lock(mm, pmd, address, ptlp)) 1974 1975 #define pte_alloc_kernel(pmd, address) \ 1976 ((unlikely(pmd_none(*(pmd))) && __pte_alloc_kernel(pmd))? \ 1977 NULL: pte_offset_kernel(pmd, address)) 1978 1979 #if USE_SPLIT_PMD_PTLOCKS 1980 1981 static struct page *pmd_to_page(pmd_t *pmd) 1982 { 1983 unsigned long mask = ~(PTRS_PER_PMD * sizeof(pmd_t) - 1); 1984 return virt_to_page((void *)((unsigned long) pmd & mask)); 1985 } 1986 1987 static inline spinlock_t *pmd_lockptr(struct mm_struct *mm, pmd_t *pmd) 1988 { 1989 return ptlock_ptr(pmd_to_page(pmd)); 1990 } 1991 1992 static inline bool pgtable_pmd_page_ctor(struct page *page) 1993 { 1994 #ifdef CONFIG_TRANSPARENT_HUGEPAGE 1995 page->pmd_huge_pte = NULL; 1996 #endif 1997 return ptlock_init(page); 1998 } 1999 2000 static inline void pgtable_pmd_page_dtor(struct page *page) 2001 { 2002 #ifdef CONFIG_TRANSPARENT_HUGEPAGE 2003 VM_BUG_ON_PAGE(page->pmd_huge_pte, page); 2004 #endif 2005 ptlock_free(page); 2006 } 2007 2008 #define pmd_huge_pte(mm, pmd) (pmd_to_page(pmd)->pmd_huge_pte) 2009 2010 #else 2011 2012 static inline spinlock_t *pmd_lockptr(struct mm_struct *mm, pmd_t *pmd) 2013 { 2014 return &mm->page_table_lock; 2015 } 2016 2017 static inline bool pgtable_pmd_page_ctor(struct page *page) { return true; } 2018 static inline void pgtable_pmd_page_dtor(struct page *page) {} 2019 2020 #define pmd_huge_pte(mm, pmd) ((mm)->pmd_huge_pte) 2021 2022 #endif 2023 2024 static inline spinlock_t *pmd_lock(struct mm_struct *mm, pmd_t *pmd) 2025 { 2026 spinlock_t *ptl = pmd_lockptr(mm, pmd); 2027 spin_lock(ptl); 2028 return ptl; 2029 } 2030 2031 /* 2032 * No scalability reason to split PUD locks yet, but follow the same pattern 2033 * as the PMD locks to make it easier if we decide to. The VM should not be 2034 * considered ready to switch to split PUD locks yet; there may be places 2035 * which need to be converted from page_table_lock. 2036 */ 2037 static inline spinlock_t *pud_lockptr(struct mm_struct *mm, pud_t *pud) 2038 { 2039 return &mm->page_table_lock; 2040 } 2041 2042 static inline spinlock_t *pud_lock(struct mm_struct *mm, pud_t *pud) 2043 { 2044 spinlock_t *ptl = pud_lockptr(mm, pud); 2045 2046 spin_lock(ptl); 2047 return ptl; 2048 } 2049 2050 extern void __init pagecache_init(void); 2051 extern void free_area_init(unsigned long * zones_size); 2052 extern void __init free_area_init_node(int nid, unsigned long * zones_size, 2053 unsigned long zone_start_pfn, unsigned long *zholes_size); 2054 extern void free_initmem(void); 2055 2056 /* 2057 * Free reserved pages within range [PAGE_ALIGN(start), end & PAGE_MASK) 2058 * into the buddy system. The freed pages will be poisoned with pattern 2059 * "poison" if it's within range [0, UCHAR_MAX]. 2060 * Return pages freed into the buddy system. 2061 */ 2062 extern unsigned long free_reserved_area(void *start, void *end, 2063 int poison, const char *s); 2064 2065 #ifdef CONFIG_HIGHMEM 2066 /* 2067 * Free a highmem page into the buddy system, adjusting totalhigh_pages 2068 * and totalram_pages. 2069 */ 2070 extern void free_highmem_page(struct page *page); 2071 #endif 2072 2073 extern void adjust_managed_page_count(struct page *page, long count); 2074 extern void mem_init_print_info(const char *str); 2075 2076 extern void reserve_bootmem_region(phys_addr_t start, phys_addr_t end); 2077 2078 /* Free the reserved page into the buddy system, so it gets managed. */ 2079 static inline void __free_reserved_page(struct page *page) 2080 { 2081 ClearPageReserved(page); 2082 init_page_count(page); 2083 __free_page(page); 2084 } 2085 2086 static inline void free_reserved_page(struct page *page) 2087 { 2088 __free_reserved_page(page); 2089 adjust_managed_page_count(page, 1); 2090 } 2091 2092 static inline void mark_page_reserved(struct page *page) 2093 { 2094 SetPageReserved(page); 2095 adjust_managed_page_count(page, -1); 2096 } 2097 2098 /* 2099 * Default method to free all the __init memory into the buddy system. 2100 * The freed pages will be poisoned with pattern "poison" if it's within 2101 * range [0, UCHAR_MAX]. 2102 * Return pages freed into the buddy system. 2103 */ 2104 static inline unsigned long free_initmem_default(int poison) 2105 { 2106 extern char __init_begin[], __init_end[]; 2107 2108 return free_reserved_area(&__init_begin, &__init_end, 2109 poison, "unused kernel"); 2110 } 2111 2112 static inline unsigned long get_num_physpages(void) 2113 { 2114 int nid; 2115 unsigned long phys_pages = 0; 2116 2117 for_each_online_node(nid) 2118 phys_pages += node_present_pages(nid); 2119 2120 return phys_pages; 2121 } 2122 2123 #ifdef CONFIG_HAVE_MEMBLOCK_NODE_MAP 2124 /* 2125 * With CONFIG_HAVE_MEMBLOCK_NODE_MAP set, an architecture may initialise its 2126 * zones, allocate the backing mem_map and account for memory holes in a more 2127 * architecture independent manner. This is a substitute for creating the 2128 * zone_sizes[] and zholes_size[] arrays and passing them to 2129 * free_area_init_node() 2130 * 2131 * An architecture is expected to register range of page frames backed by 2132 * physical memory with memblock_add[_node]() before calling 2133 * free_area_init_nodes() passing in the PFN each zone ends at. At a basic 2134 * usage, an architecture is expected to do something like 2135 * 2136 * unsigned long max_zone_pfns[MAX_NR_ZONES] = {max_dma, max_normal_pfn, 2137 * max_highmem_pfn}; 2138 * for_each_valid_physical_page_range() 2139 * memblock_add_node(base, size, nid) 2140 * free_area_init_nodes(max_zone_pfns); 2141 * 2142 * free_bootmem_with_active_regions() calls free_bootmem_node() for each 2143 * registered physical page range. Similarly 2144 * sparse_memory_present_with_active_regions() calls memory_present() for 2145 * each range when SPARSEMEM is enabled. 2146 * 2147 * See mm/page_alloc.c for more information on each function exposed by 2148 * CONFIG_HAVE_MEMBLOCK_NODE_MAP. 2149 */ 2150 extern void free_area_init_nodes(unsigned long *max_zone_pfn); 2151 unsigned long node_map_pfn_alignment(void); 2152 unsigned long __absent_pages_in_range(int nid, unsigned long start_pfn, 2153 unsigned long end_pfn); 2154 extern unsigned long absent_pages_in_range(unsigned long start_pfn, 2155 unsigned long end_pfn); 2156 extern void get_pfn_range_for_nid(unsigned int nid, 2157 unsigned long *start_pfn, unsigned long *end_pfn); 2158 extern unsigned long find_min_pfn_with_active_regions(void); 2159 extern void free_bootmem_with_active_regions(int nid, 2160 unsigned long max_low_pfn); 2161 extern void sparse_memory_present_with_active_regions(int nid); 2162 2163 #endif /* CONFIG_HAVE_MEMBLOCK_NODE_MAP */ 2164 2165 #if !defined(CONFIG_HAVE_MEMBLOCK_NODE_MAP) && \ 2166 !defined(CONFIG_HAVE_ARCH_EARLY_PFN_TO_NID) 2167 static inline int __early_pfn_to_nid(unsigned long pfn, 2168 struct mminit_pfnnid_cache *state) 2169 { 2170 return 0; 2171 } 2172 #else 2173 /* please see mm/page_alloc.c */ 2174 extern int __meminit early_pfn_to_nid(unsigned long pfn); 2175 /* there is a per-arch backend function. */ 2176 extern int __meminit __early_pfn_to_nid(unsigned long pfn, 2177 struct mminit_pfnnid_cache *state); 2178 #endif 2179 2180 #if !defined(CONFIG_FLAT_NODE_MEM_MAP) 2181 void zero_resv_unavail(void); 2182 #else 2183 static inline void zero_resv_unavail(void) {} 2184 #endif 2185 2186 extern void set_dma_reserve(unsigned long new_dma_reserve); 2187 extern void memmap_init_zone(unsigned long, int, unsigned long, unsigned long, 2188 enum memmap_context, struct vmem_altmap *); 2189 extern void setup_per_zone_wmarks(void); 2190 extern int __meminit init_per_zone_wmark_min(void); 2191 extern void mem_init(void); 2192 extern void __init mmap_init(void); 2193 extern void show_mem(unsigned int flags, nodemask_t *nodemask); 2194 extern long si_mem_available(void); 2195 extern void si_meminfo(struct sysinfo * val); 2196 extern void si_meminfo_node(struct sysinfo *val, int nid); 2197 #ifdef __HAVE_ARCH_RESERVED_KERNEL_PAGES 2198 extern unsigned long arch_reserved_kernel_pages(void); 2199 #endif 2200 2201 extern __printf(3, 4) 2202 void warn_alloc(gfp_t gfp_mask, nodemask_t *nodemask, const char *fmt, ...); 2203 2204 extern void setup_per_cpu_pageset(void); 2205 2206 extern void zone_pcp_update(struct zone *zone); 2207 extern void zone_pcp_reset(struct zone *zone); 2208 2209 /* page_alloc.c */ 2210 extern int min_free_kbytes; 2211 extern int watermark_boost_factor; 2212 extern int watermark_scale_factor; 2213 2214 /* nommu.c */ 2215 extern atomic_long_t mmap_pages_allocated; 2216 extern int nommu_shrink_inode_mappings(struct inode *, size_t, size_t); 2217 2218 /* interval_tree.c */ 2219 void vma_interval_tree_insert(struct vm_area_struct *node, 2220 struct rb_root_cached *root); 2221 void vma_interval_tree_insert_after(struct vm_area_struct *node, 2222 struct vm_area_struct *prev, 2223 struct rb_root_cached *root); 2224 void vma_interval_tree_remove(struct vm_area_struct *node, 2225 struct rb_root_cached *root); 2226 struct vm_area_struct *vma_interval_tree_iter_first(struct rb_root_cached *root, 2227 unsigned long start, unsigned long last); 2228 struct vm_area_struct *vma_interval_tree_iter_next(struct vm_area_struct *node, 2229 unsigned long start, unsigned long last); 2230 2231 #define vma_interval_tree_foreach(vma, root, start, last) \ 2232 for (vma = vma_interval_tree_iter_first(root, start, last); \ 2233 vma; vma = vma_interval_tree_iter_next(vma, start, last)) 2234 2235 void anon_vma_interval_tree_insert(struct anon_vma_chain *node, 2236 struct rb_root_cached *root); 2237 void anon_vma_interval_tree_remove(struct anon_vma_chain *node, 2238 struct rb_root_cached *root); 2239 struct anon_vma_chain * 2240 anon_vma_interval_tree_iter_first(struct rb_root_cached *root, 2241 unsigned long start, unsigned long last); 2242 struct anon_vma_chain *anon_vma_interval_tree_iter_next( 2243 struct anon_vma_chain *node, unsigned long start, unsigned long last); 2244 #ifdef CONFIG_DEBUG_VM_RB 2245 void anon_vma_interval_tree_verify(struct anon_vma_chain *node); 2246 #endif 2247 2248 #define anon_vma_interval_tree_foreach(avc, root, start, last) \ 2249 for (avc = anon_vma_interval_tree_iter_first(root, start, last); \ 2250 avc; avc = anon_vma_interval_tree_iter_next(avc, start, last)) 2251 2252 /* mmap.c */ 2253 extern int __vm_enough_memory(struct mm_struct *mm, long pages, int cap_sys_admin); 2254 extern int __vma_adjust(struct vm_area_struct *vma, unsigned long start, 2255 unsigned long end, pgoff_t pgoff, struct vm_area_struct *insert, 2256 struct vm_area_struct *expand); 2257 static inline int vma_adjust(struct vm_area_struct *vma, unsigned long start, 2258 unsigned long end, pgoff_t pgoff, struct vm_area_struct *insert) 2259 { 2260 return __vma_adjust(vma, start, end, pgoff, insert, NULL); 2261 } 2262 extern struct vm_area_struct *vma_merge(struct mm_struct *, 2263 struct vm_area_struct *prev, unsigned long addr, unsigned long end, 2264 unsigned long vm_flags, struct anon_vma *, struct file *, pgoff_t, 2265 struct mempolicy *, struct vm_userfaultfd_ctx); 2266 extern struct anon_vma *find_mergeable_anon_vma(struct vm_area_struct *); 2267 extern int __split_vma(struct mm_struct *, struct vm_area_struct *, 2268 unsigned long addr, int new_below); 2269 extern int split_vma(struct mm_struct *, struct vm_area_struct *, 2270 unsigned long addr, int new_below); 2271 extern int insert_vm_struct(struct mm_struct *, struct vm_area_struct *); 2272 extern void __vma_link_rb(struct mm_struct *, struct vm_area_struct *, 2273 struct rb_node **, struct rb_node *); 2274 extern void unlink_file_vma(struct vm_area_struct *); 2275 extern struct vm_area_struct *copy_vma(struct vm_area_struct **, 2276 unsigned long addr, unsigned long len, pgoff_t pgoff, 2277 bool *need_rmap_locks); 2278 extern void exit_mmap(struct mm_struct *); 2279 2280 static inline int check_data_rlimit(unsigned long rlim, 2281 unsigned long new, 2282 unsigned long start, 2283 unsigned long end_data, 2284 unsigned long start_data) 2285 { 2286 if (rlim < RLIM_INFINITY) { 2287 if (((new - start) + (end_data - start_data)) > rlim) 2288 return -ENOSPC; 2289 } 2290 2291 return 0; 2292 } 2293 2294 extern int mm_take_all_locks(struct mm_struct *mm); 2295 extern void mm_drop_all_locks(struct mm_struct *mm); 2296 2297 extern void set_mm_exe_file(struct mm_struct *mm, struct file *new_exe_file); 2298 extern struct file *get_mm_exe_file(struct mm_struct *mm); 2299 extern struct file *get_task_exe_file(struct task_struct *task); 2300 2301 extern bool may_expand_vm(struct mm_struct *, vm_flags_t, unsigned long npages); 2302 extern void vm_stat_account(struct mm_struct *, vm_flags_t, long npages); 2303 2304 extern bool vma_is_special_mapping(const struct vm_area_struct *vma, 2305 const struct vm_special_mapping *sm); 2306 extern struct vm_area_struct *_install_special_mapping(struct mm_struct *mm, 2307 unsigned long addr, unsigned long len, 2308 unsigned long flags, 2309 const struct vm_special_mapping *spec); 2310 /* This is an obsolete alternative to _install_special_mapping. */ 2311 extern int install_special_mapping(struct mm_struct *mm, 2312 unsigned long addr, unsigned long len, 2313 unsigned long flags, struct page **pages); 2314 2315 extern unsigned long get_unmapped_area(struct file *, unsigned long, unsigned long, unsigned long, unsigned long); 2316 2317 extern unsigned long mmap_region(struct file *file, unsigned long addr, 2318 unsigned long len, vm_flags_t vm_flags, unsigned long pgoff, 2319 struct list_head *uf); 2320 extern unsigned long do_mmap(struct file *file, unsigned long addr, 2321 unsigned long len, unsigned long prot, unsigned long flags, 2322 vm_flags_t vm_flags, unsigned long pgoff, unsigned long *populate, 2323 struct list_head *uf); 2324 extern int __do_munmap(struct mm_struct *, unsigned long, size_t, 2325 struct list_head *uf, bool downgrade); 2326 extern int do_munmap(struct mm_struct *, unsigned long, size_t, 2327 struct list_head *uf); 2328 2329 static inline unsigned long 2330 do_mmap_pgoff(struct file *file, unsigned long addr, 2331 unsigned long len, unsigned long prot, unsigned long flags, 2332 unsigned long pgoff, unsigned long *populate, 2333 struct list_head *uf) 2334 { 2335 return do_mmap(file, addr, len, prot, flags, 0, pgoff, populate, uf); 2336 } 2337 2338 #ifdef CONFIG_MMU 2339 extern int __mm_populate(unsigned long addr, unsigned long len, 2340 int ignore_errors); 2341 static inline void mm_populate(unsigned long addr, unsigned long len) 2342 { 2343 /* Ignore errors */ 2344 (void) __mm_populate(addr, len, 1); 2345 } 2346 #else 2347 static inline void mm_populate(unsigned long addr, unsigned long len) {} 2348 #endif 2349 2350 /* These take the mm semaphore themselves */ 2351 extern int __must_check vm_brk(unsigned long, unsigned long); 2352 extern int __must_check vm_brk_flags(unsigned long, unsigned long, unsigned long); 2353 extern int vm_munmap(unsigned long, size_t); 2354 extern unsigned long __must_check vm_mmap(struct file *, unsigned long, 2355 unsigned long, unsigned long, 2356 unsigned long, unsigned long); 2357 2358 struct vm_unmapped_area_info { 2359 #define VM_UNMAPPED_AREA_TOPDOWN 1 2360 unsigned long flags; 2361 unsigned long length; 2362 unsigned long low_limit; 2363 unsigned long high_limit; 2364 unsigned long align_mask; 2365 unsigned long align_offset; 2366 }; 2367 2368 extern unsigned long unmapped_area(struct vm_unmapped_area_info *info); 2369 extern unsigned long unmapped_area_topdown(struct vm_unmapped_area_info *info); 2370 2371 /* 2372 * Search for an unmapped address range. 2373 * 2374 * We are looking for a range that: 2375 * - does not intersect with any VMA; 2376 * - is contained within the [low_limit, high_limit) interval; 2377 * - is at least the desired size. 2378 * - satisfies (begin_addr & align_mask) == (align_offset & align_mask) 2379 */ 2380 static inline unsigned long 2381 vm_unmapped_area(struct vm_unmapped_area_info *info) 2382 { 2383 if (info->flags & VM_UNMAPPED_AREA_TOPDOWN) 2384 return unmapped_area_topdown(info); 2385 else 2386 return unmapped_area(info); 2387 } 2388 2389 /* truncate.c */ 2390 extern void truncate_inode_pages(struct address_space *, loff_t); 2391 extern void truncate_inode_pages_range(struct address_space *, 2392 loff_t lstart, loff_t lend); 2393 extern void truncate_inode_pages_final(struct address_space *); 2394 2395 /* generic vm_area_ops exported for stackable file systems */ 2396 extern vm_fault_t filemap_fault(struct vm_fault *vmf); 2397 extern void filemap_map_pages(struct vm_fault *vmf, 2398 pgoff_t start_pgoff, pgoff_t end_pgoff); 2399 extern vm_fault_t filemap_page_mkwrite(struct vm_fault *vmf); 2400 2401 /* mm/page-writeback.c */ 2402 int __must_check write_one_page(struct page *page); 2403 void task_dirty_inc(struct task_struct *tsk); 2404 2405 /* readahead.c */ 2406 #define VM_READAHEAD_PAGES (SZ_128K / PAGE_SIZE) 2407 2408 int force_page_cache_readahead(struct address_space *mapping, struct file *filp, 2409 pgoff_t offset, unsigned long nr_to_read); 2410 2411 void page_cache_sync_readahead(struct address_space *mapping, 2412 struct file_ra_state *ra, 2413 struct file *filp, 2414 pgoff_t offset, 2415 unsigned long size); 2416 2417 void page_cache_async_readahead(struct address_space *mapping, 2418 struct file_ra_state *ra, 2419 struct file *filp, 2420 struct page *pg, 2421 pgoff_t offset, 2422 unsigned long size); 2423 2424 extern unsigned long stack_guard_gap; 2425 /* Generic expand stack which grows the stack according to GROWS{UP,DOWN} */ 2426 extern int expand_stack(struct vm_area_struct *vma, unsigned long address); 2427 2428 /* CONFIG_STACK_GROWSUP still needs to to grow downwards at some places */ 2429 extern int expand_downwards(struct vm_area_struct *vma, 2430 unsigned long address); 2431 #if VM_GROWSUP 2432 extern int expand_upwards(struct vm_area_struct *vma, unsigned long address); 2433 #else 2434 #define expand_upwards(vma, address) (0) 2435 #endif 2436 2437 /* Look up the first VMA which satisfies addr < vm_end, NULL if none. */ 2438 extern struct vm_area_struct * find_vma(struct mm_struct * mm, unsigned long addr); 2439 extern struct vm_area_struct * find_vma_prev(struct mm_struct * mm, unsigned long addr, 2440 struct vm_area_struct **pprev); 2441 2442 /* Look up the first VMA which intersects the interval start_addr..end_addr-1, 2443 NULL if none. Assume start_addr < end_addr. */ 2444 static inline struct vm_area_struct * find_vma_intersection(struct mm_struct * mm, unsigned long start_addr, unsigned long end_addr) 2445 { 2446 struct vm_area_struct * vma = find_vma(mm,start_addr); 2447 2448 if (vma && end_addr <= vma->vm_start) 2449 vma = NULL; 2450 return vma; 2451 } 2452 2453 static inline unsigned long vm_start_gap(struct vm_area_struct *vma) 2454 { 2455 unsigned long vm_start = vma->vm_start; 2456 2457 if (vma->vm_flags & VM_GROWSDOWN) { 2458 vm_start -= stack_guard_gap; 2459 if (vm_start > vma->vm_start) 2460 vm_start = 0; 2461 } 2462 return vm_start; 2463 } 2464 2465 static inline unsigned long vm_end_gap(struct vm_area_struct *vma) 2466 { 2467 unsigned long vm_end = vma->vm_end; 2468 2469 if (vma->vm_flags & VM_GROWSUP) { 2470 vm_end += stack_guard_gap; 2471 if (vm_end < vma->vm_end) 2472 vm_end = -PAGE_SIZE; 2473 } 2474 return vm_end; 2475 } 2476 2477 static inline unsigned long vma_pages(struct vm_area_struct *vma) 2478 { 2479 return (vma->vm_end - vma->vm_start) >> PAGE_SHIFT; 2480 } 2481 2482 /* Look up the first VMA which exactly match the interval vm_start ... vm_end */ 2483 static inline struct vm_area_struct *find_exact_vma(struct mm_struct *mm, 2484 unsigned long vm_start, unsigned long vm_end) 2485 { 2486 struct vm_area_struct *vma = find_vma(mm, vm_start); 2487 2488 if (vma && (vma->vm_start != vm_start || vma->vm_end != vm_end)) 2489 vma = NULL; 2490 2491 return vma; 2492 } 2493 2494 static inline bool range_in_vma(struct vm_area_struct *vma, 2495 unsigned long start, unsigned long end) 2496 { 2497 return (vma && vma->vm_start <= start && end <= vma->vm_end); 2498 } 2499 2500 #ifdef CONFIG_MMU 2501 pgprot_t vm_get_page_prot(unsigned long vm_flags); 2502 void vma_set_page_prot(struct vm_area_struct *vma); 2503 #else 2504 static inline pgprot_t vm_get_page_prot(unsigned long vm_flags) 2505 { 2506 return __pgprot(0); 2507 } 2508 static inline void vma_set_page_prot(struct vm_area_struct *vma) 2509 { 2510 vma->vm_page_prot = vm_get_page_prot(vma->vm_flags); 2511 } 2512 #endif 2513 2514 #ifdef CONFIG_NUMA_BALANCING 2515 unsigned long change_prot_numa(struct vm_area_struct *vma, 2516 unsigned long start, unsigned long end); 2517 #endif 2518 2519 struct vm_area_struct *find_extend_vma(struct mm_struct *, unsigned long addr); 2520 int remap_pfn_range(struct vm_area_struct *, unsigned long addr, 2521 unsigned long pfn, unsigned long size, pgprot_t); 2522 int vm_insert_page(struct vm_area_struct *, unsigned long addr, struct page *); 2523 vm_fault_t vmf_insert_pfn(struct vm_area_struct *vma, unsigned long addr, 2524 unsigned long pfn); 2525 vm_fault_t vmf_insert_pfn_prot(struct vm_area_struct *vma, unsigned long addr, 2526 unsigned long pfn, pgprot_t pgprot); 2527 vm_fault_t vmf_insert_mixed(struct vm_area_struct *vma, unsigned long addr, 2528 pfn_t pfn); 2529 vm_fault_t vmf_insert_mixed_mkwrite(struct vm_area_struct *vma, 2530 unsigned long addr, pfn_t pfn); 2531 int vm_iomap_memory(struct vm_area_struct *vma, phys_addr_t start, unsigned long len); 2532 2533 static inline vm_fault_t vmf_insert_page(struct vm_area_struct *vma, 2534 unsigned long addr, struct page *page) 2535 { 2536 int err = vm_insert_page(vma, addr, page); 2537 2538 if (err == -ENOMEM) 2539 return VM_FAULT_OOM; 2540 if (err < 0 && err != -EBUSY) 2541 return VM_FAULT_SIGBUS; 2542 2543 return VM_FAULT_NOPAGE; 2544 } 2545 2546 static inline vm_fault_t vmf_error(int err) 2547 { 2548 if (err == -ENOMEM) 2549 return VM_FAULT_OOM; 2550 return VM_FAULT_SIGBUS; 2551 } 2552 2553 struct page *follow_page(struct vm_area_struct *vma, unsigned long address, 2554 unsigned int foll_flags); 2555 2556 #define FOLL_WRITE 0x01 /* check pte is writable */ 2557 #define FOLL_TOUCH 0x02 /* mark page accessed */ 2558 #define FOLL_GET 0x04 /* do get_page on page */ 2559 #define FOLL_DUMP 0x08 /* give error on hole if it would be zero */ 2560 #define FOLL_FORCE 0x10 /* get_user_pages read/write w/o permission */ 2561 #define FOLL_NOWAIT 0x20 /* if a disk transfer is needed, start the IO 2562 * and return without waiting upon it */ 2563 #define FOLL_POPULATE 0x40 /* fault in page */ 2564 #define FOLL_SPLIT 0x80 /* don't return transhuge pages, split them */ 2565 #define FOLL_HWPOISON 0x100 /* check page is hwpoisoned */ 2566 #define FOLL_NUMA 0x200 /* force NUMA hinting page fault */ 2567 #define FOLL_MIGRATION 0x400 /* wait for page to replace migration entry */ 2568 #define FOLL_TRIED 0x800 /* a retry, previous pass started an IO */ 2569 #define FOLL_MLOCK 0x1000 /* lock present pages */ 2570 #define FOLL_REMOTE 0x2000 /* we are working on non-current tsk/mm */ 2571 #define FOLL_COW 0x4000 /* internal GUP flag */ 2572 #define FOLL_ANON 0x8000 /* don't do file mappings */ 2573 2574 static inline int vm_fault_to_errno(vm_fault_t vm_fault, int foll_flags) 2575 { 2576 if (vm_fault & VM_FAULT_OOM) 2577 return -ENOMEM; 2578 if (vm_fault & (VM_FAULT_HWPOISON | VM_FAULT_HWPOISON_LARGE)) 2579 return (foll_flags & FOLL_HWPOISON) ? -EHWPOISON : -EFAULT; 2580 if (vm_fault & (VM_FAULT_SIGBUS | VM_FAULT_SIGSEGV)) 2581 return -EFAULT; 2582 return 0; 2583 } 2584 2585 typedef int (*pte_fn_t)(pte_t *pte, pgtable_t token, unsigned long addr, 2586 void *data); 2587 extern int apply_to_page_range(struct mm_struct *mm, unsigned long address, 2588 unsigned long size, pte_fn_t fn, void *data); 2589 2590 2591 #ifdef CONFIG_PAGE_POISONING 2592 extern bool page_poisoning_enabled(void); 2593 extern void kernel_poison_pages(struct page *page, int numpages, int enable); 2594 #else 2595 static inline bool page_poisoning_enabled(void) { return false; } 2596 static inline void kernel_poison_pages(struct page *page, int numpages, 2597 int enable) { } 2598 #endif 2599 2600 #ifdef CONFIG_DEBUG_PAGEALLOC 2601 extern bool _debug_pagealloc_enabled; 2602 extern void __kernel_map_pages(struct page *page, int numpages, int enable); 2603 2604 static inline bool debug_pagealloc_enabled(void) 2605 { 2606 return _debug_pagealloc_enabled; 2607 } 2608 2609 static inline void 2610 kernel_map_pages(struct page *page, int numpages, int enable) 2611 { 2612 if (!debug_pagealloc_enabled()) 2613 return; 2614 2615 __kernel_map_pages(page, numpages, enable); 2616 } 2617 #ifdef CONFIG_HIBERNATION 2618 extern bool kernel_page_present(struct page *page); 2619 #endif /* CONFIG_HIBERNATION */ 2620 #else /* CONFIG_DEBUG_PAGEALLOC */ 2621 static inline void 2622 kernel_map_pages(struct page *page, int numpages, int enable) {} 2623 #ifdef CONFIG_HIBERNATION 2624 static inline bool kernel_page_present(struct page *page) { return true; } 2625 #endif /* CONFIG_HIBERNATION */ 2626 static inline bool debug_pagealloc_enabled(void) 2627 { 2628 return false; 2629 } 2630 #endif /* CONFIG_DEBUG_PAGEALLOC */ 2631 2632 #ifdef __HAVE_ARCH_GATE_AREA 2633 extern struct vm_area_struct *get_gate_vma(struct mm_struct *mm); 2634 extern int in_gate_area_no_mm(unsigned long addr); 2635 extern int in_gate_area(struct mm_struct *mm, unsigned long addr); 2636 #else 2637 static inline struct vm_area_struct *get_gate_vma(struct mm_struct *mm) 2638 { 2639 return NULL; 2640 } 2641 static inline int in_gate_area_no_mm(unsigned long addr) { return 0; } 2642 static inline int in_gate_area(struct mm_struct *mm, unsigned long addr) 2643 { 2644 return 0; 2645 } 2646 #endif /* __HAVE_ARCH_GATE_AREA */ 2647 2648 extern bool process_shares_mm(struct task_struct *p, struct mm_struct *mm); 2649 2650 #ifdef CONFIG_SYSCTL 2651 extern int sysctl_drop_caches; 2652 int drop_caches_sysctl_handler(struct ctl_table *, int, 2653 void __user *, size_t *, loff_t *); 2654 #endif 2655 2656 void drop_slab(void); 2657 void drop_slab_node(int nid); 2658 2659 #ifndef CONFIG_MMU 2660 #define randomize_va_space 0 2661 #else 2662 extern int randomize_va_space; 2663 #endif 2664 2665 const char * arch_vma_name(struct vm_area_struct *vma); 2666 void print_vma_addr(char *prefix, unsigned long rip); 2667 2668 void *sparse_buffer_alloc(unsigned long size); 2669 struct page *sparse_mem_map_populate(unsigned long pnum, int nid, 2670 struct vmem_altmap *altmap); 2671 pgd_t *vmemmap_pgd_populate(unsigned long addr, int node); 2672 p4d_t *vmemmap_p4d_populate(pgd_t *pgd, unsigned long addr, int node); 2673 pud_t *vmemmap_pud_populate(p4d_t *p4d, unsigned long addr, int node); 2674 pmd_t *vmemmap_pmd_populate(pud_t *pud, unsigned long addr, int node); 2675 pte_t *vmemmap_pte_populate(pmd_t *pmd, unsigned long addr, int node); 2676 void *vmemmap_alloc_block(unsigned long size, int node); 2677 struct vmem_altmap; 2678 void *vmemmap_alloc_block_buf(unsigned long size, int node); 2679 void *altmap_alloc_block_buf(unsigned long size, struct vmem_altmap *altmap); 2680 void vmemmap_verify(pte_t *, int, unsigned long, unsigned long); 2681 int vmemmap_populate_basepages(unsigned long start, unsigned long end, 2682 int node); 2683 int vmemmap_populate(unsigned long start, unsigned long end, int node, 2684 struct vmem_altmap *altmap); 2685 void vmemmap_populate_print_last(void); 2686 #ifdef CONFIG_MEMORY_HOTPLUG 2687 void vmemmap_free(unsigned long start, unsigned long end, 2688 struct vmem_altmap *altmap); 2689 #endif 2690 void register_page_bootmem_memmap(unsigned long section_nr, struct page *map, 2691 unsigned long nr_pages); 2692 2693 enum mf_flags { 2694 MF_COUNT_INCREASED = 1 << 0, 2695 MF_ACTION_REQUIRED = 1 << 1, 2696 MF_MUST_KILL = 1 << 2, 2697 MF_SOFT_OFFLINE = 1 << 3, 2698 }; 2699 extern int memory_failure(unsigned long pfn, int flags); 2700 extern void memory_failure_queue(unsigned long pfn, int flags); 2701 extern int unpoison_memory(unsigned long pfn); 2702 extern int get_hwpoison_page(struct page *page); 2703 #define put_hwpoison_page(page) put_page(page) 2704 extern int sysctl_memory_failure_early_kill; 2705 extern int sysctl_memory_failure_recovery; 2706 extern void shake_page(struct page *p, int access); 2707 extern atomic_long_t num_poisoned_pages __read_mostly; 2708 extern int soft_offline_page(struct page *page, int flags); 2709 2710 2711 /* 2712 * Error handlers for various types of pages. 2713 */ 2714 enum mf_result { 2715 MF_IGNORED, /* Error: cannot be handled */ 2716 MF_FAILED, /* Error: handling failed */ 2717 MF_DELAYED, /* Will be handled later */ 2718 MF_RECOVERED, /* Successfully recovered */ 2719 }; 2720 2721 enum mf_action_page_type { 2722 MF_MSG_KERNEL, 2723 MF_MSG_KERNEL_HIGH_ORDER, 2724 MF_MSG_SLAB, 2725 MF_MSG_DIFFERENT_COMPOUND, 2726 MF_MSG_POISONED_HUGE, 2727 MF_MSG_HUGE, 2728 MF_MSG_FREE_HUGE, 2729 MF_MSG_NON_PMD_HUGE, 2730 MF_MSG_UNMAP_FAILED, 2731 MF_MSG_DIRTY_SWAPCACHE, 2732 MF_MSG_CLEAN_SWAPCACHE, 2733 MF_MSG_DIRTY_MLOCKED_LRU, 2734 MF_MSG_CLEAN_MLOCKED_LRU, 2735 MF_MSG_DIRTY_UNEVICTABLE_LRU, 2736 MF_MSG_CLEAN_UNEVICTABLE_LRU, 2737 MF_MSG_DIRTY_LRU, 2738 MF_MSG_CLEAN_LRU, 2739 MF_MSG_TRUNCATED_LRU, 2740 MF_MSG_BUDDY, 2741 MF_MSG_BUDDY_2ND, 2742 MF_MSG_DAX, 2743 MF_MSG_UNKNOWN, 2744 }; 2745 2746 #if defined(CONFIG_TRANSPARENT_HUGEPAGE) || defined(CONFIG_HUGETLBFS) 2747 extern void clear_huge_page(struct page *page, 2748 unsigned long addr_hint, 2749 unsigned int pages_per_huge_page); 2750 extern void copy_user_huge_page(struct page *dst, struct page *src, 2751 unsigned long addr_hint, 2752 struct vm_area_struct *vma, 2753 unsigned int pages_per_huge_page); 2754 extern long copy_huge_page_from_user(struct page *dst_page, 2755 const void __user *usr_src, 2756 unsigned int pages_per_huge_page, 2757 bool allow_pagefault); 2758 #endif /* CONFIG_TRANSPARENT_HUGEPAGE || CONFIG_HUGETLBFS */ 2759 2760 extern struct page_ext_operations debug_guardpage_ops; 2761 2762 #ifdef CONFIG_DEBUG_PAGEALLOC 2763 extern unsigned int _debug_guardpage_minorder; 2764 extern bool _debug_guardpage_enabled; 2765 2766 static inline unsigned int debug_guardpage_minorder(void) 2767 { 2768 return _debug_guardpage_minorder; 2769 } 2770 2771 static inline bool debug_guardpage_enabled(void) 2772 { 2773 return _debug_guardpage_enabled; 2774 } 2775 2776 static inline bool page_is_guard(struct page *page) 2777 { 2778 struct page_ext *page_ext; 2779 2780 if (!debug_guardpage_enabled()) 2781 return false; 2782 2783 page_ext = lookup_page_ext(page); 2784 if (unlikely(!page_ext)) 2785 return false; 2786 2787 return test_bit(PAGE_EXT_DEBUG_GUARD, &page_ext->flags); 2788 } 2789 #else 2790 static inline unsigned int debug_guardpage_minorder(void) { return 0; } 2791 static inline bool debug_guardpage_enabled(void) { return false; } 2792 static inline bool page_is_guard(struct page *page) { return false; } 2793 #endif /* CONFIG_DEBUG_PAGEALLOC */ 2794 2795 #if MAX_NUMNODES > 1 2796 void __init setup_nr_node_ids(void); 2797 #else 2798 static inline void setup_nr_node_ids(void) {} 2799 #endif 2800 2801 #endif /* __KERNEL__ */ 2802 #endif /* _LINUX_MM_H */ 2803