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