1 /* SPDX-License-Identifier: GPL-2.0 */ 2 #ifndef _LINUX_MM_H 3 #define _LINUX_MM_H 4 5 #include <linux/errno.h> 6 #include <linux/mmdebug.h> 7 #include <linux/gfp.h> 8 #include <linux/bug.h> 9 #include <linux/list.h> 10 #include <linux/mmzone.h> 11 #include <linux/rbtree.h> 12 #include <linux/atomic.h> 13 #include <linux/debug_locks.h> 14 #include <linux/mm_types.h> 15 #include <linux/mmap_lock.h> 16 #include <linux/range.h> 17 #include <linux/pfn.h> 18 #include <linux/percpu-refcount.h> 19 #include <linux/bit_spinlock.h> 20 #include <linux/shrinker.h> 21 #include <linux/resource.h> 22 #include <linux/page_ext.h> 23 #include <linux/err.h> 24 #include <linux/page-flags.h> 25 #include <linux/page_ref.h> 26 #include <linux/overflow.h> 27 #include <linux/sizes.h> 28 #include <linux/sched.h> 29 #include <linux/pgtable.h> 30 #include <linux/kasan.h> 31 #include <linux/memremap.h> 32 33 struct mempolicy; 34 struct anon_vma; 35 struct anon_vma_chain; 36 struct user_struct; 37 struct pt_regs; 38 39 extern int sysctl_page_lock_unfairness; 40 41 void init_mm_internals(void); 42 43 #ifndef CONFIG_NUMA /* Don't use mapnrs, do it properly */ 44 extern unsigned long max_mapnr; 45 46 static inline void set_max_mapnr(unsigned long limit) 47 { 48 max_mapnr = limit; 49 } 50 #else 51 static inline void set_max_mapnr(unsigned long limit) { } 52 #endif 53 54 extern atomic_long_t _totalram_pages; 55 static inline unsigned long totalram_pages(void) 56 { 57 return (unsigned long)atomic_long_read(&_totalram_pages); 58 } 59 60 static inline void totalram_pages_inc(void) 61 { 62 atomic_long_inc(&_totalram_pages); 63 } 64 65 static inline void totalram_pages_dec(void) 66 { 67 atomic_long_dec(&_totalram_pages); 68 } 69 70 static inline void totalram_pages_add(long count) 71 { 72 atomic_long_add(count, &_totalram_pages); 73 } 74 75 extern void * high_memory; 76 extern int page_cluster; 77 78 #ifdef CONFIG_SYSCTL 79 extern int sysctl_legacy_va_layout; 80 #else 81 #define sysctl_legacy_va_layout 0 82 #endif 83 84 #ifdef CONFIG_HAVE_ARCH_MMAP_RND_BITS 85 extern const int mmap_rnd_bits_min; 86 extern const int mmap_rnd_bits_max; 87 extern int mmap_rnd_bits __read_mostly; 88 #endif 89 #ifdef CONFIG_HAVE_ARCH_MMAP_RND_COMPAT_BITS 90 extern const int mmap_rnd_compat_bits_min; 91 extern const int mmap_rnd_compat_bits_max; 92 extern int mmap_rnd_compat_bits __read_mostly; 93 #endif 94 95 #include <asm/page.h> 96 #include <asm/processor.h> 97 98 /* 99 * Architectures that support memory tagging (assigning tags to memory regions, 100 * embedding these tags into addresses that point to these memory regions, and 101 * checking that the memory and the pointer tags match on memory accesses) 102 * redefine this macro to strip tags from pointers. 103 * It's defined as noop for architectures that don't support memory tagging. 104 */ 105 #ifndef untagged_addr 106 #define untagged_addr(addr) (addr) 107 #endif 108 109 #ifndef __pa_symbol 110 #define __pa_symbol(x) __pa(RELOC_HIDE((unsigned long)(x), 0)) 111 #endif 112 113 #ifndef page_to_virt 114 #define page_to_virt(x) __va(PFN_PHYS(page_to_pfn(x))) 115 #endif 116 117 #ifndef lm_alias 118 #define lm_alias(x) __va(__pa_symbol(x)) 119 #endif 120 121 /* 122 * To prevent common memory management code establishing 123 * a zero page mapping on a read fault. 124 * This macro should be defined within <asm/pgtable.h>. 125 * s390 does this to prevent multiplexing of hardware bits 126 * related to the physical page in case of virtualization. 127 */ 128 #ifndef mm_forbids_zeropage 129 #define mm_forbids_zeropage(X) (0) 130 #endif 131 132 /* 133 * On some architectures it is expensive to call memset() for small sizes. 134 * If an architecture decides to implement their own version of 135 * mm_zero_struct_page they should wrap the defines below in a #ifndef and 136 * define their own version of this macro in <asm/pgtable.h> 137 */ 138 #if BITS_PER_LONG == 64 139 /* This function must be updated when the size of struct page grows above 80 140 * or reduces below 56. The idea that compiler optimizes out switch() 141 * statement, and only leaves move/store instructions. Also the compiler can 142 * combine write statements if they are both assignments and can be reordered, 143 * this can result in several of the writes here being dropped. 144 */ 145 #define mm_zero_struct_page(pp) __mm_zero_struct_page(pp) 146 static inline void __mm_zero_struct_page(struct page *page) 147 { 148 unsigned long *_pp = (void *)page; 149 150 /* Check that struct page is either 56, 64, 72, or 80 bytes */ 151 BUILD_BUG_ON(sizeof(struct page) & 7); 152 BUILD_BUG_ON(sizeof(struct page) < 56); 153 BUILD_BUG_ON(sizeof(struct page) > 80); 154 155 switch (sizeof(struct page)) { 156 case 80: 157 _pp[9] = 0; 158 fallthrough; 159 case 72: 160 _pp[8] = 0; 161 fallthrough; 162 case 64: 163 _pp[7] = 0; 164 fallthrough; 165 case 56: 166 _pp[6] = 0; 167 _pp[5] = 0; 168 _pp[4] = 0; 169 _pp[3] = 0; 170 _pp[2] = 0; 171 _pp[1] = 0; 172 _pp[0] = 0; 173 } 174 } 175 #else 176 #define mm_zero_struct_page(pp) ((void)memset((pp), 0, sizeof(struct page))) 177 #endif 178 179 /* 180 * Default maximum number of active map areas, this limits the number of vmas 181 * per mm struct. Users can overwrite this number by sysctl but there is a 182 * problem. 183 * 184 * When a program's coredump is generated as ELF format, a section is created 185 * per a vma. In ELF, the number of sections is represented in unsigned short. 186 * This means the number of sections should be smaller than 65535 at coredump. 187 * Because the kernel adds some informative sections to a image of program at 188 * generating coredump, we need some margin. The number of extra sections is 189 * 1-3 now and depends on arch. We use "5" as safe margin, here. 190 * 191 * ELF extended numbering allows more than 65535 sections, so 16-bit bound is 192 * not a hard limit any more. Although some userspace tools can be surprised by 193 * that. 194 */ 195 #define MAPCOUNT_ELF_CORE_MARGIN (5) 196 #define DEFAULT_MAX_MAP_COUNT (USHRT_MAX - MAPCOUNT_ELF_CORE_MARGIN) 197 198 extern int sysctl_max_map_count; 199 200 extern unsigned long sysctl_user_reserve_kbytes; 201 extern unsigned long sysctl_admin_reserve_kbytes; 202 203 extern int sysctl_overcommit_memory; 204 extern int sysctl_overcommit_ratio; 205 extern unsigned long sysctl_overcommit_kbytes; 206 207 int overcommit_ratio_handler(struct ctl_table *, int, void *, size_t *, 208 loff_t *); 209 int overcommit_kbytes_handler(struct ctl_table *, int, void *, size_t *, 210 loff_t *); 211 int overcommit_policy_handler(struct ctl_table *, int, void *, size_t *, 212 loff_t *); 213 214 #if defined(CONFIG_SPARSEMEM) && !defined(CONFIG_SPARSEMEM_VMEMMAP) 215 #define nth_page(page,n) pfn_to_page(page_to_pfn((page)) + (n)) 216 #define folio_page_idx(folio, p) (page_to_pfn(p) - folio_pfn(folio)) 217 #else 218 #define nth_page(page,n) ((page) + (n)) 219 #define folio_page_idx(folio, p) ((p) - &(folio)->page) 220 #endif 221 222 /* to align the pointer to the (next) page boundary */ 223 #define PAGE_ALIGN(addr) ALIGN(addr, PAGE_SIZE) 224 225 /* to align the pointer to the (prev) page boundary */ 226 #define PAGE_ALIGN_DOWN(addr) ALIGN_DOWN(addr, PAGE_SIZE) 227 228 /* test whether an address (unsigned long or pointer) is aligned to PAGE_SIZE */ 229 #define PAGE_ALIGNED(addr) IS_ALIGNED((unsigned long)(addr), PAGE_SIZE) 230 231 #define lru_to_page(head) (list_entry((head)->prev, struct page, lru)) 232 static inline struct folio *lru_to_folio(struct list_head *head) 233 { 234 return list_entry((head)->prev, struct folio, lru); 235 } 236 237 void setup_initial_init_mm(void *start_code, void *end_code, 238 void *end_data, void *brk); 239 240 /* 241 * Linux kernel virtual memory manager primitives. 242 * The idea being to have a "virtual" mm in the same way 243 * we have a virtual fs - giving a cleaner interface to the 244 * mm details, and allowing different kinds of memory mappings 245 * (from shared memory to executable loading to arbitrary 246 * mmap() functions). 247 */ 248 249 struct vm_area_struct *vm_area_alloc(struct mm_struct *); 250 struct vm_area_struct *vm_area_dup(struct vm_area_struct *); 251 void vm_area_free(struct vm_area_struct *); 252 253 #ifndef CONFIG_MMU 254 extern struct rb_root nommu_region_tree; 255 extern struct rw_semaphore nommu_region_sem; 256 257 extern unsigned int kobjsize(const void *objp); 258 #endif 259 260 /* 261 * vm_flags in vm_area_struct, see mm_types.h. 262 * When changing, update also include/trace/events/mmflags.h 263 */ 264 #define VM_NONE 0x00000000 265 266 #define VM_READ 0x00000001 /* currently active flags */ 267 #define VM_WRITE 0x00000002 268 #define VM_EXEC 0x00000004 269 #define VM_SHARED 0x00000008 270 271 /* mprotect() hardcodes VM_MAYREAD >> 4 == VM_READ, and so for r/w/x bits. */ 272 #define VM_MAYREAD 0x00000010 /* limits for mprotect() etc */ 273 #define VM_MAYWRITE 0x00000020 274 #define VM_MAYEXEC 0x00000040 275 #define VM_MAYSHARE 0x00000080 276 277 #define VM_GROWSDOWN 0x00000100 /* general info on the segment */ 278 #define VM_UFFD_MISSING 0x00000200 /* missing pages tracking */ 279 #define VM_PFNMAP 0x00000400 /* Page-ranges managed without "struct page", just pure PFN */ 280 #define VM_UFFD_WP 0x00001000 /* wrprotect pages tracking */ 281 282 #define VM_LOCKED 0x00002000 283 #define VM_IO 0x00004000 /* Memory mapped I/O or similar */ 284 285 /* Used by sys_madvise() */ 286 #define VM_SEQ_READ 0x00008000 /* App will access data sequentially */ 287 #define VM_RAND_READ 0x00010000 /* App will not benefit from clustered reads */ 288 289 #define VM_DONTCOPY 0x00020000 /* Do not copy this vma on fork */ 290 #define VM_DONTEXPAND 0x00040000 /* Cannot expand with mremap() */ 291 #define VM_LOCKONFAULT 0x00080000 /* Lock the pages covered when they are faulted in */ 292 #define VM_ACCOUNT 0x00100000 /* Is a VM accounted object */ 293 #define VM_NORESERVE 0x00200000 /* should the VM suppress accounting */ 294 #define VM_HUGETLB 0x00400000 /* Huge TLB Page VM */ 295 #define VM_SYNC 0x00800000 /* Synchronous page faults */ 296 #define VM_ARCH_1 0x01000000 /* Architecture-specific flag */ 297 #define VM_WIPEONFORK 0x02000000 /* Wipe VMA contents in child. */ 298 #define VM_DONTDUMP 0x04000000 /* Do not include in the core dump */ 299 300 #ifdef CONFIG_MEM_SOFT_DIRTY 301 # define VM_SOFTDIRTY 0x08000000 /* Not soft dirty clean area */ 302 #else 303 # define VM_SOFTDIRTY 0 304 #endif 305 306 #define VM_MIXEDMAP 0x10000000 /* Can contain "struct page" and pure PFN pages */ 307 #define VM_HUGEPAGE 0x20000000 /* MADV_HUGEPAGE marked this vma */ 308 #define VM_NOHUGEPAGE 0x40000000 /* MADV_NOHUGEPAGE marked this vma */ 309 #define VM_MERGEABLE 0x80000000 /* KSM may merge identical pages */ 310 311 #ifdef CONFIG_ARCH_USES_HIGH_VMA_FLAGS 312 #define VM_HIGH_ARCH_BIT_0 32 /* bit only usable on 64-bit architectures */ 313 #define VM_HIGH_ARCH_BIT_1 33 /* bit only usable on 64-bit architectures */ 314 #define VM_HIGH_ARCH_BIT_2 34 /* bit only usable on 64-bit architectures */ 315 #define VM_HIGH_ARCH_BIT_3 35 /* bit only usable on 64-bit architectures */ 316 #define VM_HIGH_ARCH_BIT_4 36 /* bit only usable on 64-bit architectures */ 317 #define VM_HIGH_ARCH_0 BIT(VM_HIGH_ARCH_BIT_0) 318 #define VM_HIGH_ARCH_1 BIT(VM_HIGH_ARCH_BIT_1) 319 #define VM_HIGH_ARCH_2 BIT(VM_HIGH_ARCH_BIT_2) 320 #define VM_HIGH_ARCH_3 BIT(VM_HIGH_ARCH_BIT_3) 321 #define VM_HIGH_ARCH_4 BIT(VM_HIGH_ARCH_BIT_4) 322 #endif /* CONFIG_ARCH_USES_HIGH_VMA_FLAGS */ 323 324 #ifdef CONFIG_ARCH_HAS_PKEYS 325 # define VM_PKEY_SHIFT VM_HIGH_ARCH_BIT_0 326 # define VM_PKEY_BIT0 VM_HIGH_ARCH_0 /* A protection key is a 4-bit value */ 327 # define VM_PKEY_BIT1 VM_HIGH_ARCH_1 /* on x86 and 5-bit value on ppc64 */ 328 # define VM_PKEY_BIT2 VM_HIGH_ARCH_2 329 # define VM_PKEY_BIT3 VM_HIGH_ARCH_3 330 #ifdef CONFIG_PPC 331 # define VM_PKEY_BIT4 VM_HIGH_ARCH_4 332 #else 333 # define VM_PKEY_BIT4 0 334 #endif 335 #endif /* CONFIG_ARCH_HAS_PKEYS */ 336 337 #if defined(CONFIG_X86) 338 # define VM_PAT VM_ARCH_1 /* PAT reserves whole VMA at once (x86) */ 339 #elif defined(CONFIG_PPC) 340 # define VM_SAO VM_ARCH_1 /* Strong Access Ordering (powerpc) */ 341 #elif defined(CONFIG_PARISC) 342 # define VM_GROWSUP VM_ARCH_1 343 #elif defined(CONFIG_IA64) 344 # define VM_GROWSUP VM_ARCH_1 345 #elif defined(CONFIG_SPARC64) 346 # define VM_SPARC_ADI VM_ARCH_1 /* Uses ADI tag for access control */ 347 # define VM_ARCH_CLEAR VM_SPARC_ADI 348 #elif defined(CONFIG_ARM64) 349 # define VM_ARM64_BTI VM_ARCH_1 /* BTI guarded page, a.k.a. GP bit */ 350 # define VM_ARCH_CLEAR VM_ARM64_BTI 351 #elif !defined(CONFIG_MMU) 352 # define VM_MAPPED_COPY VM_ARCH_1 /* T if mapped copy of data (nommu mmap) */ 353 #endif 354 355 #if defined(CONFIG_ARM64_MTE) 356 # define VM_MTE VM_HIGH_ARCH_0 /* Use Tagged memory for access control */ 357 # define VM_MTE_ALLOWED VM_HIGH_ARCH_1 /* Tagged memory permitted */ 358 #else 359 # define VM_MTE VM_NONE 360 # define VM_MTE_ALLOWED VM_NONE 361 #endif 362 363 #ifndef VM_GROWSUP 364 # define VM_GROWSUP VM_NONE 365 #endif 366 367 #ifdef CONFIG_HAVE_ARCH_USERFAULTFD_MINOR 368 # define VM_UFFD_MINOR_BIT 37 369 # define VM_UFFD_MINOR BIT(VM_UFFD_MINOR_BIT) /* UFFD minor faults */ 370 #else /* !CONFIG_HAVE_ARCH_USERFAULTFD_MINOR */ 371 # define VM_UFFD_MINOR VM_NONE 372 #endif /* CONFIG_HAVE_ARCH_USERFAULTFD_MINOR */ 373 374 /* Bits set in the VMA until the stack is in its final location */ 375 #define VM_STACK_INCOMPLETE_SETUP (VM_RAND_READ | VM_SEQ_READ) 376 377 #define TASK_EXEC ((current->personality & READ_IMPLIES_EXEC) ? VM_EXEC : 0) 378 379 /* Common data flag combinations */ 380 #define VM_DATA_FLAGS_TSK_EXEC (VM_READ | VM_WRITE | TASK_EXEC | \ 381 VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC) 382 #define VM_DATA_FLAGS_NON_EXEC (VM_READ | VM_WRITE | VM_MAYREAD | \ 383 VM_MAYWRITE | VM_MAYEXEC) 384 #define VM_DATA_FLAGS_EXEC (VM_READ | VM_WRITE | VM_EXEC | \ 385 VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC) 386 387 #ifndef VM_DATA_DEFAULT_FLAGS /* arch can override this */ 388 #define VM_DATA_DEFAULT_FLAGS VM_DATA_FLAGS_EXEC 389 #endif 390 391 #ifndef VM_STACK_DEFAULT_FLAGS /* arch can override this */ 392 #define VM_STACK_DEFAULT_FLAGS VM_DATA_DEFAULT_FLAGS 393 #endif 394 395 #ifdef CONFIG_STACK_GROWSUP 396 #define VM_STACK VM_GROWSUP 397 #else 398 #define VM_STACK VM_GROWSDOWN 399 #endif 400 401 #define VM_STACK_FLAGS (VM_STACK | VM_STACK_DEFAULT_FLAGS | VM_ACCOUNT) 402 403 /* VMA basic access permission flags */ 404 #define VM_ACCESS_FLAGS (VM_READ | VM_WRITE | VM_EXEC) 405 406 407 /* 408 * Special vmas that are non-mergable, non-mlock()able. 409 */ 410 #define VM_SPECIAL (VM_IO | VM_DONTEXPAND | VM_PFNMAP | VM_MIXEDMAP) 411 412 /* This mask prevents VMA from being scanned with khugepaged */ 413 #define VM_NO_KHUGEPAGED (VM_SPECIAL | VM_HUGETLB) 414 415 /* This mask defines which mm->def_flags a process can inherit its parent */ 416 #define VM_INIT_DEF_MASK VM_NOHUGEPAGE 417 418 /* This mask is used to clear all the VMA flags used by mlock */ 419 #define VM_LOCKED_CLEAR_MASK (~(VM_LOCKED | VM_LOCKONFAULT)) 420 421 /* Arch-specific flags to clear when updating VM flags on protection change */ 422 #ifndef VM_ARCH_CLEAR 423 # define VM_ARCH_CLEAR VM_NONE 424 #endif 425 #define VM_FLAGS_CLEAR (ARCH_VM_PKEY_FLAGS | VM_ARCH_CLEAR) 426 427 /* 428 * mapping from the currently active vm_flags protection bits (the 429 * low four bits) to a page protection mask.. 430 */ 431 432 /* 433 * The default fault flags that should be used by most of the 434 * arch-specific page fault handlers. 435 */ 436 #define FAULT_FLAG_DEFAULT (FAULT_FLAG_ALLOW_RETRY | \ 437 FAULT_FLAG_KILLABLE | \ 438 FAULT_FLAG_INTERRUPTIBLE) 439 440 /** 441 * fault_flag_allow_retry_first - check ALLOW_RETRY the first time 442 * @flags: Fault flags. 443 * 444 * This is mostly used for places where we want to try to avoid taking 445 * the mmap_lock for too long a time when waiting for another condition 446 * to change, in which case we can try to be polite to release the 447 * mmap_lock in the first round to avoid potential starvation of other 448 * processes that would also want the mmap_lock. 449 * 450 * Return: true if the page fault allows retry and this is the first 451 * attempt of the fault handling; false otherwise. 452 */ 453 static inline bool fault_flag_allow_retry_first(enum fault_flag flags) 454 { 455 return (flags & FAULT_FLAG_ALLOW_RETRY) && 456 (!(flags & FAULT_FLAG_TRIED)); 457 } 458 459 #define FAULT_FLAG_TRACE \ 460 { FAULT_FLAG_WRITE, "WRITE" }, \ 461 { FAULT_FLAG_MKWRITE, "MKWRITE" }, \ 462 { FAULT_FLAG_ALLOW_RETRY, "ALLOW_RETRY" }, \ 463 { FAULT_FLAG_RETRY_NOWAIT, "RETRY_NOWAIT" }, \ 464 { FAULT_FLAG_KILLABLE, "KILLABLE" }, \ 465 { FAULT_FLAG_TRIED, "TRIED" }, \ 466 { FAULT_FLAG_USER, "USER" }, \ 467 { FAULT_FLAG_REMOTE, "REMOTE" }, \ 468 { FAULT_FLAG_INSTRUCTION, "INSTRUCTION" }, \ 469 { FAULT_FLAG_INTERRUPTIBLE, "INTERRUPTIBLE" } 470 471 /* 472 * vm_fault is filled by the pagefault handler and passed to the vma's 473 * ->fault function. The vma's ->fault is responsible for returning a bitmask 474 * of VM_FAULT_xxx flags that give details about how the fault was handled. 475 * 476 * MM layer fills up gfp_mask for page allocations but fault handler might 477 * alter it if its implementation requires a different allocation context. 478 * 479 * pgoff should be used in favour of virtual_address, if possible. 480 */ 481 struct vm_fault { 482 const struct { 483 struct vm_area_struct *vma; /* Target VMA */ 484 gfp_t gfp_mask; /* gfp mask to be used for allocations */ 485 pgoff_t pgoff; /* Logical page offset based on vma */ 486 unsigned long address; /* Faulting virtual address - masked */ 487 unsigned long real_address; /* Faulting virtual address - unmasked */ 488 }; 489 enum fault_flag flags; /* FAULT_FLAG_xxx flags 490 * XXX: should really be 'const' */ 491 pmd_t *pmd; /* Pointer to pmd entry matching 492 * the 'address' */ 493 pud_t *pud; /* Pointer to pud entry matching 494 * the 'address' 495 */ 496 union { 497 pte_t orig_pte; /* Value of PTE at the time of fault */ 498 pmd_t orig_pmd; /* Value of PMD at the time of fault, 499 * used by PMD fault only. 500 */ 501 }; 502 503 struct page *cow_page; /* Page handler may use for COW fault */ 504 struct page *page; /* ->fault handlers should return a 505 * page here, unless VM_FAULT_NOPAGE 506 * is set (which is also implied by 507 * VM_FAULT_ERROR). 508 */ 509 /* These three entries are valid only while holding ptl lock */ 510 pte_t *pte; /* Pointer to pte entry matching 511 * the 'address'. NULL if the page 512 * table hasn't been allocated. 513 */ 514 spinlock_t *ptl; /* Page table lock. 515 * Protects pte page table if 'pte' 516 * is not NULL, otherwise pmd. 517 */ 518 pgtable_t prealloc_pte; /* Pre-allocated pte page table. 519 * vm_ops->map_pages() sets up a page 520 * table from atomic context. 521 * do_fault_around() pre-allocates 522 * page table to avoid allocation from 523 * atomic context. 524 */ 525 }; 526 527 /* page entry size for vm->huge_fault() */ 528 enum page_entry_size { 529 PE_SIZE_PTE = 0, 530 PE_SIZE_PMD, 531 PE_SIZE_PUD, 532 }; 533 534 /* 535 * These are the virtual MM functions - opening of an area, closing and 536 * unmapping it (needed to keep files on disk up-to-date etc), pointer 537 * to the functions called when a no-page or a wp-page exception occurs. 538 */ 539 struct vm_operations_struct { 540 void (*open)(struct vm_area_struct * area); 541 /** 542 * @close: Called when the VMA is being removed from the MM. 543 * Context: User context. May sleep. Caller holds mmap_lock. 544 */ 545 void (*close)(struct vm_area_struct * area); 546 /* Called any time before splitting to check if it's allowed */ 547 int (*may_split)(struct vm_area_struct *area, unsigned long addr); 548 int (*mremap)(struct vm_area_struct *area); 549 /* 550 * Called by mprotect() to make driver-specific permission 551 * checks before mprotect() is finalised. The VMA must not 552 * be modified. Returns 0 if eprotect() can proceed. 553 */ 554 int (*mprotect)(struct vm_area_struct *vma, unsigned long start, 555 unsigned long end, unsigned long newflags); 556 vm_fault_t (*fault)(struct vm_fault *vmf); 557 vm_fault_t (*huge_fault)(struct vm_fault *vmf, 558 enum page_entry_size pe_size); 559 vm_fault_t (*map_pages)(struct vm_fault *vmf, 560 pgoff_t start_pgoff, pgoff_t end_pgoff); 561 unsigned long (*pagesize)(struct vm_area_struct * area); 562 563 /* notification that a previously read-only page is about to become 564 * writable, if an error is returned it will cause a SIGBUS */ 565 vm_fault_t (*page_mkwrite)(struct vm_fault *vmf); 566 567 /* same as page_mkwrite when using VM_PFNMAP|VM_MIXEDMAP */ 568 vm_fault_t (*pfn_mkwrite)(struct vm_fault *vmf); 569 570 /* called by access_process_vm when get_user_pages() fails, typically 571 * for use by special VMAs. See also generic_access_phys() for a generic 572 * implementation useful for any iomem mapping. 573 */ 574 int (*access)(struct vm_area_struct *vma, unsigned long addr, 575 void *buf, int len, int write); 576 577 /* Called by the /proc/PID/maps code to ask the vma whether it 578 * has a special name. Returning non-NULL will also cause this 579 * vma to be dumped unconditionally. */ 580 const char *(*name)(struct vm_area_struct *vma); 581 582 #ifdef CONFIG_NUMA 583 /* 584 * set_policy() op must add a reference to any non-NULL @new mempolicy 585 * to hold the policy upon return. Caller should pass NULL @new to 586 * remove a policy and fall back to surrounding context--i.e. do not 587 * install a MPOL_DEFAULT policy, nor the task or system default 588 * mempolicy. 589 */ 590 int (*set_policy)(struct vm_area_struct *vma, struct mempolicy *new); 591 592 /* 593 * get_policy() op must add reference [mpol_get()] to any policy at 594 * (vma,addr) marked as MPOL_SHARED. The shared policy infrastructure 595 * in mm/mempolicy.c will do this automatically. 596 * get_policy() must NOT add a ref if the policy at (vma,addr) is not 597 * marked as MPOL_SHARED. vma policies are protected by the mmap_lock. 598 * If no [shared/vma] mempolicy exists at the addr, get_policy() op 599 * must return NULL--i.e., do not "fallback" to task or system default 600 * policy. 601 */ 602 struct mempolicy *(*get_policy)(struct vm_area_struct *vma, 603 unsigned long addr); 604 #endif 605 /* 606 * Called by vm_normal_page() for special PTEs to find the 607 * page for @addr. This is useful if the default behavior 608 * (using pte_page()) would not find the correct page. 609 */ 610 struct page *(*find_special_page)(struct vm_area_struct *vma, 611 unsigned long addr); 612 }; 613 614 static inline void vma_init(struct vm_area_struct *vma, struct mm_struct *mm) 615 { 616 static const struct vm_operations_struct dummy_vm_ops = {}; 617 618 memset(vma, 0, sizeof(*vma)); 619 vma->vm_mm = mm; 620 vma->vm_ops = &dummy_vm_ops; 621 INIT_LIST_HEAD(&vma->anon_vma_chain); 622 } 623 624 static inline void vma_set_anonymous(struct vm_area_struct *vma) 625 { 626 vma->vm_ops = NULL; 627 } 628 629 static inline bool vma_is_anonymous(struct vm_area_struct *vma) 630 { 631 return !vma->vm_ops; 632 } 633 634 static inline bool vma_is_temporary_stack(struct vm_area_struct *vma) 635 { 636 int maybe_stack = vma->vm_flags & (VM_GROWSDOWN | VM_GROWSUP); 637 638 if (!maybe_stack) 639 return false; 640 641 if ((vma->vm_flags & VM_STACK_INCOMPLETE_SETUP) == 642 VM_STACK_INCOMPLETE_SETUP) 643 return true; 644 645 return false; 646 } 647 648 static inline bool vma_is_foreign(struct vm_area_struct *vma) 649 { 650 if (!current->mm) 651 return true; 652 653 if (current->mm != vma->vm_mm) 654 return true; 655 656 return false; 657 } 658 659 static inline bool vma_is_accessible(struct vm_area_struct *vma) 660 { 661 return vma->vm_flags & VM_ACCESS_FLAGS; 662 } 663 664 static inline 665 struct vm_area_struct *vma_find(struct vma_iterator *vmi, unsigned long max) 666 { 667 return mas_find(&vmi->mas, max); 668 } 669 670 static inline struct vm_area_struct *vma_next(struct vma_iterator *vmi) 671 { 672 /* 673 * Uses vma_find() to get the first VMA when the iterator starts. 674 * Calling mas_next() could skip the first entry. 675 */ 676 return vma_find(vmi, ULONG_MAX); 677 } 678 679 static inline struct vm_area_struct *vma_prev(struct vma_iterator *vmi) 680 { 681 return mas_prev(&vmi->mas, 0); 682 } 683 684 static inline unsigned long vma_iter_addr(struct vma_iterator *vmi) 685 { 686 return vmi->mas.index; 687 } 688 689 #define for_each_vma(__vmi, __vma) \ 690 while (((__vma) = vma_next(&(__vmi))) != NULL) 691 692 /* The MM code likes to work with exclusive end addresses */ 693 #define for_each_vma_range(__vmi, __vma, __end) \ 694 while (((__vma) = vma_find(&(__vmi), (__end) - 1)) != NULL) 695 696 #ifdef CONFIG_SHMEM 697 /* 698 * The vma_is_shmem is not inline because it is used only by slow 699 * paths in userfault. 700 */ 701 bool vma_is_shmem(struct vm_area_struct *vma); 702 #else 703 static inline bool vma_is_shmem(struct vm_area_struct *vma) { return false; } 704 #endif 705 706 int vma_is_stack_for_current(struct vm_area_struct *vma); 707 708 /* flush_tlb_range() takes a vma, not a mm, and can care about flags */ 709 #define TLB_FLUSH_VMA(mm,flags) { .vm_mm = (mm), .vm_flags = (flags) } 710 711 struct mmu_gather; 712 struct inode; 713 714 static inline unsigned int compound_order(struct page *page) 715 { 716 if (!PageHead(page)) 717 return 0; 718 return page[1].compound_order; 719 } 720 721 /** 722 * folio_order - The allocation order of a folio. 723 * @folio: The folio. 724 * 725 * A folio is composed of 2^order pages. See get_order() for the definition 726 * of order. 727 * 728 * Return: The order of the folio. 729 */ 730 static inline unsigned int folio_order(struct folio *folio) 731 { 732 if (!folio_test_large(folio)) 733 return 0; 734 return folio->_folio_order; 735 } 736 737 #include <linux/huge_mm.h> 738 739 /* 740 * Methods to modify the page usage count. 741 * 742 * What counts for a page usage: 743 * - cache mapping (page->mapping) 744 * - private data (page->private) 745 * - page mapped in a task's page tables, each mapping 746 * is counted separately 747 * 748 * Also, many kernel routines increase the page count before a critical 749 * routine so they can be sure the page doesn't go away from under them. 750 */ 751 752 /* 753 * Drop a ref, return true if the refcount fell to zero (the page has no users) 754 */ 755 static inline int put_page_testzero(struct page *page) 756 { 757 VM_BUG_ON_PAGE(page_ref_count(page) == 0, page); 758 return page_ref_dec_and_test(page); 759 } 760 761 static inline int folio_put_testzero(struct folio *folio) 762 { 763 return put_page_testzero(&folio->page); 764 } 765 766 /* 767 * Try to grab a ref unless the page has a refcount of zero, return false if 768 * that is the case. 769 * This can be called when MMU is off so it must not access 770 * any of the virtual mappings. 771 */ 772 static inline bool get_page_unless_zero(struct page *page) 773 { 774 return page_ref_add_unless(page, 1, 0); 775 } 776 777 extern int page_is_ram(unsigned long pfn); 778 779 enum { 780 REGION_INTERSECTS, 781 REGION_DISJOINT, 782 REGION_MIXED, 783 }; 784 785 int region_intersects(resource_size_t offset, size_t size, unsigned long flags, 786 unsigned long desc); 787 788 /* Support for virtually mapped pages */ 789 struct page *vmalloc_to_page(const void *addr); 790 unsigned long vmalloc_to_pfn(const void *addr); 791 792 /* 793 * Determine if an address is within the vmalloc range 794 * 795 * On nommu, vmalloc/vfree wrap through kmalloc/kfree directly, so there 796 * is no special casing required. 797 */ 798 799 #ifndef is_ioremap_addr 800 #define is_ioremap_addr(x) is_vmalloc_addr(x) 801 #endif 802 803 #ifdef CONFIG_MMU 804 extern bool is_vmalloc_addr(const void *x); 805 extern int is_vmalloc_or_module_addr(const void *x); 806 #else 807 static inline bool is_vmalloc_addr(const void *x) 808 { 809 return false; 810 } 811 static inline int is_vmalloc_or_module_addr(const void *x) 812 { 813 return 0; 814 } 815 #endif 816 817 /* 818 * How many times the entire folio is mapped as a single unit (eg by a 819 * PMD or PUD entry). This is probably not what you want, except for 820 * debugging purposes; look at folio_mapcount() or page_mapcount() 821 * instead. 822 */ 823 static inline int folio_entire_mapcount(struct folio *folio) 824 { 825 VM_BUG_ON_FOLIO(!folio_test_large(folio), folio); 826 return atomic_read(folio_mapcount_ptr(folio)) + 1; 827 } 828 829 /* 830 * Mapcount of compound page as a whole, does not include mapped sub-pages. 831 * 832 * Must be called only for compound pages. 833 */ 834 static inline int compound_mapcount(struct page *page) 835 { 836 return folio_entire_mapcount(page_folio(page)); 837 } 838 839 /* 840 * The atomic page->_mapcount, starts from -1: so that transitions 841 * both from it and to it can be tracked, using atomic_inc_and_test 842 * and atomic_add_negative(-1). 843 */ 844 static inline void page_mapcount_reset(struct page *page) 845 { 846 atomic_set(&(page)->_mapcount, -1); 847 } 848 849 int __page_mapcount(struct page *page); 850 851 /* 852 * Mapcount of 0-order page; when compound sub-page, includes 853 * compound_mapcount(). 854 * 855 * Result is undefined for pages which cannot be mapped into userspace. 856 * For example SLAB or special types of pages. See function page_has_type(). 857 * They use this place in struct page differently. 858 */ 859 static inline int page_mapcount(struct page *page) 860 { 861 if (unlikely(PageCompound(page))) 862 return __page_mapcount(page); 863 return atomic_read(&page->_mapcount) + 1; 864 } 865 866 int folio_mapcount(struct folio *folio); 867 868 #ifdef CONFIG_TRANSPARENT_HUGEPAGE 869 static inline int total_mapcount(struct page *page) 870 { 871 return folio_mapcount(page_folio(page)); 872 } 873 874 #else 875 static inline int total_mapcount(struct page *page) 876 { 877 return page_mapcount(page); 878 } 879 #endif 880 881 static inline struct page *virt_to_head_page(const void *x) 882 { 883 struct page *page = virt_to_page(x); 884 885 return compound_head(page); 886 } 887 888 static inline struct folio *virt_to_folio(const void *x) 889 { 890 struct page *page = virt_to_page(x); 891 892 return page_folio(page); 893 } 894 895 void __folio_put(struct folio *folio); 896 897 void put_pages_list(struct list_head *pages); 898 899 void split_page(struct page *page, unsigned int order); 900 void folio_copy(struct folio *dst, struct folio *src); 901 902 unsigned long nr_free_buffer_pages(void); 903 904 /* 905 * Compound pages have a destructor function. Provide a 906 * prototype for that function and accessor functions. 907 * These are _only_ valid on the head of a compound page. 908 */ 909 typedef void compound_page_dtor(struct page *); 910 911 /* Keep the enum in sync with compound_page_dtors array in mm/page_alloc.c */ 912 enum compound_dtor_id { 913 NULL_COMPOUND_DTOR, 914 COMPOUND_PAGE_DTOR, 915 #ifdef CONFIG_HUGETLB_PAGE 916 HUGETLB_PAGE_DTOR, 917 #endif 918 #ifdef CONFIG_TRANSPARENT_HUGEPAGE 919 TRANSHUGE_PAGE_DTOR, 920 #endif 921 NR_COMPOUND_DTORS, 922 }; 923 extern compound_page_dtor * const compound_page_dtors[NR_COMPOUND_DTORS]; 924 925 static inline void set_compound_page_dtor(struct page *page, 926 enum compound_dtor_id compound_dtor) 927 { 928 VM_BUG_ON_PAGE(compound_dtor >= NR_COMPOUND_DTORS, page); 929 page[1].compound_dtor = compound_dtor; 930 } 931 932 void destroy_large_folio(struct folio *folio); 933 934 static inline int head_compound_pincount(struct page *head) 935 { 936 return atomic_read(compound_pincount_ptr(head)); 937 } 938 939 static inline void set_compound_order(struct page *page, unsigned int order) 940 { 941 page[1].compound_order = order; 942 #ifdef CONFIG_64BIT 943 page[1].compound_nr = 1U << order; 944 #endif 945 } 946 947 /* Returns the number of pages in this potentially compound page. */ 948 static inline unsigned long compound_nr(struct page *page) 949 { 950 if (!PageHead(page)) 951 return 1; 952 #ifdef CONFIG_64BIT 953 return page[1].compound_nr; 954 #else 955 return 1UL << compound_order(page); 956 #endif 957 } 958 959 /* Returns the number of bytes in this potentially compound page. */ 960 static inline unsigned long page_size(struct page *page) 961 { 962 return PAGE_SIZE << compound_order(page); 963 } 964 965 /* Returns the number of bits needed for the number of bytes in a page */ 966 static inline unsigned int page_shift(struct page *page) 967 { 968 return PAGE_SHIFT + compound_order(page); 969 } 970 971 /** 972 * thp_order - Order of a transparent huge page. 973 * @page: Head page of a transparent huge page. 974 */ 975 static inline unsigned int thp_order(struct page *page) 976 { 977 VM_BUG_ON_PGFLAGS(PageTail(page), page); 978 return compound_order(page); 979 } 980 981 /** 982 * thp_nr_pages - The number of regular pages in this huge page. 983 * @page: The head page of a huge page. 984 */ 985 static inline int thp_nr_pages(struct page *page) 986 { 987 VM_BUG_ON_PGFLAGS(PageTail(page), page); 988 return compound_nr(page); 989 } 990 991 /** 992 * thp_size - Size of a transparent huge page. 993 * @page: Head page of a transparent huge page. 994 * 995 * Return: Number of bytes in this page. 996 */ 997 static inline unsigned long thp_size(struct page *page) 998 { 999 return PAGE_SIZE << thp_order(page); 1000 } 1001 1002 void free_compound_page(struct page *page); 1003 1004 #ifdef CONFIG_MMU 1005 /* 1006 * Do pte_mkwrite, but only if the vma says VM_WRITE. We do this when 1007 * servicing faults for write access. In the normal case, do always want 1008 * pte_mkwrite. But get_user_pages can cause write faults for mappings 1009 * that do not have writing enabled, when used by access_process_vm. 1010 */ 1011 static inline pte_t maybe_mkwrite(pte_t pte, struct vm_area_struct *vma) 1012 { 1013 if (likely(vma->vm_flags & VM_WRITE)) 1014 pte = pte_mkwrite(pte); 1015 return pte; 1016 } 1017 1018 vm_fault_t do_set_pmd(struct vm_fault *vmf, struct page *page); 1019 void do_set_pte(struct vm_fault *vmf, struct page *page, unsigned long addr); 1020 1021 vm_fault_t finish_fault(struct vm_fault *vmf); 1022 vm_fault_t finish_mkwrite_fault(struct vm_fault *vmf); 1023 #endif 1024 1025 /* 1026 * Multiple processes may "see" the same page. E.g. for untouched 1027 * mappings of /dev/null, all processes see the same page full of 1028 * zeroes, and text pages of executables and shared libraries have 1029 * only one copy in memory, at most, normally. 1030 * 1031 * For the non-reserved pages, page_count(page) denotes a reference count. 1032 * page_count() == 0 means the page is free. page->lru is then used for 1033 * freelist management in the buddy allocator. 1034 * page_count() > 0 means the page has been allocated. 1035 * 1036 * Pages are allocated by the slab allocator in order to provide memory 1037 * to kmalloc and kmem_cache_alloc. In this case, the management of the 1038 * page, and the fields in 'struct page' are the responsibility of mm/slab.c 1039 * unless a particular usage is carefully commented. (the responsibility of 1040 * freeing the kmalloc memory is the caller's, of course). 1041 * 1042 * A page may be used by anyone else who does a __get_free_page(). 1043 * In this case, page_count still tracks the references, and should only 1044 * be used through the normal accessor functions. The top bits of page->flags 1045 * and page->virtual store page management information, but all other fields 1046 * are unused and could be used privately, carefully. The management of this 1047 * page is the responsibility of the one who allocated it, and those who have 1048 * subsequently been given references to it. 1049 * 1050 * The other pages (we may call them "pagecache pages") are completely 1051 * managed by the Linux memory manager: I/O, buffers, swapping etc. 1052 * The following discussion applies only to them. 1053 * 1054 * A pagecache page contains an opaque `private' member, which belongs to the 1055 * page's address_space. Usually, this is the address of a circular list of 1056 * the page's disk buffers. PG_private must be set to tell the VM to call 1057 * into the filesystem to release these pages. 1058 * 1059 * A page may belong to an inode's memory mapping. In this case, page->mapping 1060 * is the pointer to the inode, and page->index is the file offset of the page, 1061 * in units of PAGE_SIZE. 1062 * 1063 * If pagecache pages are not associated with an inode, they are said to be 1064 * anonymous pages. These may become associated with the swapcache, and in that 1065 * case PG_swapcache is set, and page->private is an offset into the swapcache. 1066 * 1067 * In either case (swapcache or inode backed), the pagecache itself holds one 1068 * reference to the page. Setting PG_private should also increment the 1069 * refcount. The each user mapping also has a reference to the page. 1070 * 1071 * The pagecache pages are stored in a per-mapping radix tree, which is 1072 * rooted at mapping->i_pages, and indexed by offset. 1073 * Where 2.4 and early 2.6 kernels kept dirty/clean pages in per-address_space 1074 * lists, we instead now tag pages as dirty/writeback in the radix tree. 1075 * 1076 * All pagecache pages may be subject to I/O: 1077 * - inode pages may need to be read from disk, 1078 * - inode pages which have been modified and are MAP_SHARED may need 1079 * to be written back to the inode on disk, 1080 * - anonymous pages (including MAP_PRIVATE file mappings) which have been 1081 * modified may need to be swapped out to swap space and (later) to be read 1082 * back into memory. 1083 */ 1084 1085 #if defined(CONFIG_ZONE_DEVICE) && defined(CONFIG_FS_DAX) 1086 DECLARE_STATIC_KEY_FALSE(devmap_managed_key); 1087 1088 bool __put_devmap_managed_page_refs(struct page *page, int refs); 1089 static inline bool put_devmap_managed_page_refs(struct page *page, int refs) 1090 { 1091 if (!static_branch_unlikely(&devmap_managed_key)) 1092 return false; 1093 if (!is_zone_device_page(page)) 1094 return false; 1095 return __put_devmap_managed_page_refs(page, refs); 1096 } 1097 #else /* CONFIG_ZONE_DEVICE && CONFIG_FS_DAX */ 1098 static inline bool put_devmap_managed_page_refs(struct page *page, int refs) 1099 { 1100 return false; 1101 } 1102 #endif /* CONFIG_ZONE_DEVICE && CONFIG_FS_DAX */ 1103 1104 static inline bool put_devmap_managed_page(struct page *page) 1105 { 1106 return put_devmap_managed_page_refs(page, 1); 1107 } 1108 1109 /* 127: arbitrary random number, small enough to assemble well */ 1110 #define folio_ref_zero_or_close_to_overflow(folio) \ 1111 ((unsigned int) folio_ref_count(folio) + 127u <= 127u) 1112 1113 /** 1114 * folio_get - Increment the reference count on a folio. 1115 * @folio: The folio. 1116 * 1117 * Context: May be called in any context, as long as you know that 1118 * you have a refcount on the folio. If you do not already have one, 1119 * folio_try_get() may be the right interface for you to use. 1120 */ 1121 static inline void folio_get(struct folio *folio) 1122 { 1123 VM_BUG_ON_FOLIO(folio_ref_zero_or_close_to_overflow(folio), folio); 1124 folio_ref_inc(folio); 1125 } 1126 1127 static inline void get_page(struct page *page) 1128 { 1129 folio_get(page_folio(page)); 1130 } 1131 1132 bool __must_check try_grab_page(struct page *page, unsigned int flags); 1133 1134 static inline __must_check bool try_get_page(struct page *page) 1135 { 1136 page = compound_head(page); 1137 if (WARN_ON_ONCE(page_ref_count(page) <= 0)) 1138 return false; 1139 page_ref_inc(page); 1140 return true; 1141 } 1142 1143 /** 1144 * folio_put - Decrement the reference count on a folio. 1145 * @folio: The folio. 1146 * 1147 * If the folio's reference count reaches zero, the memory will be 1148 * released back to the page allocator and may be used by another 1149 * allocation immediately. Do not access the memory or the struct folio 1150 * after calling folio_put() unless you can be sure that it wasn't the 1151 * last reference. 1152 * 1153 * Context: May be called in process or interrupt context, but not in NMI 1154 * context. May be called while holding a spinlock. 1155 */ 1156 static inline void folio_put(struct folio *folio) 1157 { 1158 if (folio_put_testzero(folio)) 1159 __folio_put(folio); 1160 } 1161 1162 /** 1163 * folio_put_refs - Reduce the reference count on a folio. 1164 * @folio: The folio. 1165 * @refs: The amount to subtract from the folio's reference count. 1166 * 1167 * If the folio's reference count reaches zero, the memory will be 1168 * released back to the page allocator and may be used by another 1169 * allocation immediately. Do not access the memory or the struct folio 1170 * after calling folio_put_refs() unless you can be sure that these weren't 1171 * the last references. 1172 * 1173 * Context: May be called in process or interrupt context, but not in NMI 1174 * context. May be called while holding a spinlock. 1175 */ 1176 static inline void folio_put_refs(struct folio *folio, int refs) 1177 { 1178 if (folio_ref_sub_and_test(folio, refs)) 1179 __folio_put(folio); 1180 } 1181 1182 void release_pages(struct page **pages, int nr); 1183 1184 /** 1185 * folios_put - Decrement the reference count on an array of folios. 1186 * @folios: The folios. 1187 * @nr: How many folios there are. 1188 * 1189 * Like folio_put(), but for an array of folios. This is more efficient 1190 * than writing the loop yourself as it will optimise the locks which 1191 * need to be taken if the folios are freed. 1192 * 1193 * Context: May be called in process or interrupt context, but not in NMI 1194 * context. May be called while holding a spinlock. 1195 */ 1196 static inline void folios_put(struct folio **folios, unsigned int nr) 1197 { 1198 release_pages((struct page **)folios, nr); 1199 } 1200 1201 static inline void put_page(struct page *page) 1202 { 1203 struct folio *folio = page_folio(page); 1204 1205 /* 1206 * For some devmap managed pages we need to catch refcount transition 1207 * from 2 to 1: 1208 */ 1209 if (put_devmap_managed_page(&folio->page)) 1210 return; 1211 folio_put(folio); 1212 } 1213 1214 /* 1215 * GUP_PIN_COUNTING_BIAS, and the associated functions that use it, overload 1216 * the page's refcount so that two separate items are tracked: the original page 1217 * reference count, and also a new count of how many pin_user_pages() calls were 1218 * made against the page. ("gup-pinned" is another term for the latter). 1219 * 1220 * With this scheme, pin_user_pages() becomes special: such pages are marked as 1221 * distinct from normal pages. As such, the unpin_user_page() call (and its 1222 * variants) must be used in order to release gup-pinned pages. 1223 * 1224 * Choice of value: 1225 * 1226 * By making GUP_PIN_COUNTING_BIAS a power of two, debugging of page reference 1227 * counts with respect to pin_user_pages() and unpin_user_page() becomes 1228 * simpler, due to the fact that adding an even power of two to the page 1229 * refcount has the effect of using only the upper N bits, for the code that 1230 * counts up using the bias value. This means that the lower bits are left for 1231 * the exclusive use of the original code that increments and decrements by one 1232 * (or at least, by much smaller values than the bias value). 1233 * 1234 * Of course, once the lower bits overflow into the upper bits (and this is 1235 * OK, because subtraction recovers the original values), then visual inspection 1236 * no longer suffices to directly view the separate counts. However, for normal 1237 * applications that don't have huge page reference counts, this won't be an 1238 * issue. 1239 * 1240 * Locking: the lockless algorithm described in folio_try_get_rcu() 1241 * provides safe operation for get_user_pages(), page_mkclean() and 1242 * other calls that race to set up page table entries. 1243 */ 1244 #define GUP_PIN_COUNTING_BIAS (1U << 10) 1245 1246 void unpin_user_page(struct page *page); 1247 void unpin_user_pages_dirty_lock(struct page **pages, unsigned long npages, 1248 bool make_dirty); 1249 void unpin_user_page_range_dirty_lock(struct page *page, unsigned long npages, 1250 bool make_dirty); 1251 void unpin_user_pages(struct page **pages, unsigned long npages); 1252 1253 static inline bool is_cow_mapping(vm_flags_t flags) 1254 { 1255 return (flags & (VM_SHARED | VM_MAYWRITE)) == VM_MAYWRITE; 1256 } 1257 1258 #if defined(CONFIG_SPARSEMEM) && !defined(CONFIG_SPARSEMEM_VMEMMAP) 1259 #define SECTION_IN_PAGE_FLAGS 1260 #endif 1261 1262 /* 1263 * The identification function is mainly used by the buddy allocator for 1264 * determining if two pages could be buddies. We are not really identifying 1265 * the zone since we could be using the section number id if we do not have 1266 * node id available in page flags. 1267 * We only guarantee that it will return the same value for two combinable 1268 * pages in a zone. 1269 */ 1270 static inline int page_zone_id(struct page *page) 1271 { 1272 return (page->flags >> ZONEID_PGSHIFT) & ZONEID_MASK; 1273 } 1274 1275 #ifdef NODE_NOT_IN_PAGE_FLAGS 1276 extern int page_to_nid(const struct page *page); 1277 #else 1278 static inline int page_to_nid(const struct page *page) 1279 { 1280 struct page *p = (struct page *)page; 1281 1282 return (PF_POISONED_CHECK(p)->flags >> NODES_PGSHIFT) & NODES_MASK; 1283 } 1284 #endif 1285 1286 static inline int folio_nid(const struct folio *folio) 1287 { 1288 return page_to_nid(&folio->page); 1289 } 1290 1291 #ifdef CONFIG_NUMA_BALANCING 1292 /* page access time bits needs to hold at least 4 seconds */ 1293 #define PAGE_ACCESS_TIME_MIN_BITS 12 1294 #if LAST_CPUPID_SHIFT < PAGE_ACCESS_TIME_MIN_BITS 1295 #define PAGE_ACCESS_TIME_BUCKETS \ 1296 (PAGE_ACCESS_TIME_MIN_BITS - LAST_CPUPID_SHIFT) 1297 #else 1298 #define PAGE_ACCESS_TIME_BUCKETS 0 1299 #endif 1300 1301 #define PAGE_ACCESS_TIME_MASK \ 1302 (LAST_CPUPID_MASK << PAGE_ACCESS_TIME_BUCKETS) 1303 1304 static inline int cpu_pid_to_cpupid(int cpu, int pid) 1305 { 1306 return ((cpu & LAST__CPU_MASK) << LAST__PID_SHIFT) | (pid & LAST__PID_MASK); 1307 } 1308 1309 static inline int cpupid_to_pid(int cpupid) 1310 { 1311 return cpupid & LAST__PID_MASK; 1312 } 1313 1314 static inline int cpupid_to_cpu(int cpupid) 1315 { 1316 return (cpupid >> LAST__PID_SHIFT) & LAST__CPU_MASK; 1317 } 1318 1319 static inline int cpupid_to_nid(int cpupid) 1320 { 1321 return cpu_to_node(cpupid_to_cpu(cpupid)); 1322 } 1323 1324 static inline bool cpupid_pid_unset(int cpupid) 1325 { 1326 return cpupid_to_pid(cpupid) == (-1 & LAST__PID_MASK); 1327 } 1328 1329 static inline bool cpupid_cpu_unset(int cpupid) 1330 { 1331 return cpupid_to_cpu(cpupid) == (-1 & LAST__CPU_MASK); 1332 } 1333 1334 static inline bool __cpupid_match_pid(pid_t task_pid, int cpupid) 1335 { 1336 return (task_pid & LAST__PID_MASK) == cpupid_to_pid(cpupid); 1337 } 1338 1339 #define cpupid_match_pid(task, cpupid) __cpupid_match_pid(task->pid, cpupid) 1340 #ifdef LAST_CPUPID_NOT_IN_PAGE_FLAGS 1341 static inline int page_cpupid_xchg_last(struct page *page, int cpupid) 1342 { 1343 return xchg(&page->_last_cpupid, cpupid & LAST_CPUPID_MASK); 1344 } 1345 1346 static inline int page_cpupid_last(struct page *page) 1347 { 1348 return page->_last_cpupid; 1349 } 1350 static inline void page_cpupid_reset_last(struct page *page) 1351 { 1352 page->_last_cpupid = -1 & LAST_CPUPID_MASK; 1353 } 1354 #else 1355 static inline int page_cpupid_last(struct page *page) 1356 { 1357 return (page->flags >> LAST_CPUPID_PGSHIFT) & LAST_CPUPID_MASK; 1358 } 1359 1360 extern int page_cpupid_xchg_last(struct page *page, int cpupid); 1361 1362 static inline void page_cpupid_reset_last(struct page *page) 1363 { 1364 page->flags |= LAST_CPUPID_MASK << LAST_CPUPID_PGSHIFT; 1365 } 1366 #endif /* LAST_CPUPID_NOT_IN_PAGE_FLAGS */ 1367 1368 static inline int xchg_page_access_time(struct page *page, int time) 1369 { 1370 int last_time; 1371 1372 last_time = page_cpupid_xchg_last(page, time >> PAGE_ACCESS_TIME_BUCKETS); 1373 return last_time << PAGE_ACCESS_TIME_BUCKETS; 1374 } 1375 #else /* !CONFIG_NUMA_BALANCING */ 1376 static inline int page_cpupid_xchg_last(struct page *page, int cpupid) 1377 { 1378 return page_to_nid(page); /* XXX */ 1379 } 1380 1381 static inline int xchg_page_access_time(struct page *page, int time) 1382 { 1383 return 0; 1384 } 1385 1386 static inline int page_cpupid_last(struct page *page) 1387 { 1388 return page_to_nid(page); /* XXX */ 1389 } 1390 1391 static inline int cpupid_to_nid(int cpupid) 1392 { 1393 return -1; 1394 } 1395 1396 static inline int cpupid_to_pid(int cpupid) 1397 { 1398 return -1; 1399 } 1400 1401 static inline int cpupid_to_cpu(int cpupid) 1402 { 1403 return -1; 1404 } 1405 1406 static inline int cpu_pid_to_cpupid(int nid, int pid) 1407 { 1408 return -1; 1409 } 1410 1411 static inline bool cpupid_pid_unset(int cpupid) 1412 { 1413 return true; 1414 } 1415 1416 static inline void page_cpupid_reset_last(struct page *page) 1417 { 1418 } 1419 1420 static inline bool cpupid_match_pid(struct task_struct *task, int cpupid) 1421 { 1422 return false; 1423 } 1424 #endif /* CONFIG_NUMA_BALANCING */ 1425 1426 #if defined(CONFIG_KASAN_SW_TAGS) || defined(CONFIG_KASAN_HW_TAGS) 1427 1428 /* 1429 * KASAN per-page tags are stored xor'ed with 0xff. This allows to avoid 1430 * setting tags for all pages to native kernel tag value 0xff, as the default 1431 * value 0x00 maps to 0xff. 1432 */ 1433 1434 static inline u8 page_kasan_tag(const struct page *page) 1435 { 1436 u8 tag = 0xff; 1437 1438 if (kasan_enabled()) { 1439 tag = (page->flags >> KASAN_TAG_PGSHIFT) & KASAN_TAG_MASK; 1440 tag ^= 0xff; 1441 } 1442 1443 return tag; 1444 } 1445 1446 static inline void page_kasan_tag_set(struct page *page, u8 tag) 1447 { 1448 unsigned long old_flags, flags; 1449 1450 if (!kasan_enabled()) 1451 return; 1452 1453 tag ^= 0xff; 1454 old_flags = READ_ONCE(page->flags); 1455 do { 1456 flags = old_flags; 1457 flags &= ~(KASAN_TAG_MASK << KASAN_TAG_PGSHIFT); 1458 flags |= (tag & KASAN_TAG_MASK) << KASAN_TAG_PGSHIFT; 1459 } while (unlikely(!try_cmpxchg(&page->flags, &old_flags, flags))); 1460 } 1461 1462 static inline void page_kasan_tag_reset(struct page *page) 1463 { 1464 if (kasan_enabled()) 1465 page_kasan_tag_set(page, 0xff); 1466 } 1467 1468 #else /* CONFIG_KASAN_SW_TAGS || CONFIG_KASAN_HW_TAGS */ 1469 1470 static inline u8 page_kasan_tag(const struct page *page) 1471 { 1472 return 0xff; 1473 } 1474 1475 static inline void page_kasan_tag_set(struct page *page, u8 tag) { } 1476 static inline void page_kasan_tag_reset(struct page *page) { } 1477 1478 #endif /* CONFIG_KASAN_SW_TAGS || CONFIG_KASAN_HW_TAGS */ 1479 1480 static inline struct zone *page_zone(const struct page *page) 1481 { 1482 return &NODE_DATA(page_to_nid(page))->node_zones[page_zonenum(page)]; 1483 } 1484 1485 static inline pg_data_t *page_pgdat(const struct page *page) 1486 { 1487 return NODE_DATA(page_to_nid(page)); 1488 } 1489 1490 static inline struct zone *folio_zone(const struct folio *folio) 1491 { 1492 return page_zone(&folio->page); 1493 } 1494 1495 static inline pg_data_t *folio_pgdat(const struct folio *folio) 1496 { 1497 return page_pgdat(&folio->page); 1498 } 1499 1500 #ifdef SECTION_IN_PAGE_FLAGS 1501 static inline void set_page_section(struct page *page, unsigned long section) 1502 { 1503 page->flags &= ~(SECTIONS_MASK << SECTIONS_PGSHIFT); 1504 page->flags |= (section & SECTIONS_MASK) << SECTIONS_PGSHIFT; 1505 } 1506 1507 static inline unsigned long page_to_section(const struct page *page) 1508 { 1509 return (page->flags >> SECTIONS_PGSHIFT) & SECTIONS_MASK; 1510 } 1511 #endif 1512 1513 /** 1514 * folio_pfn - Return the Page Frame Number of a folio. 1515 * @folio: The folio. 1516 * 1517 * A folio may contain multiple pages. The pages have consecutive 1518 * Page Frame Numbers. 1519 * 1520 * Return: The Page Frame Number of the first page in the folio. 1521 */ 1522 static inline unsigned long folio_pfn(struct folio *folio) 1523 { 1524 return page_to_pfn(&folio->page); 1525 } 1526 1527 static inline struct folio *pfn_folio(unsigned long pfn) 1528 { 1529 return page_folio(pfn_to_page(pfn)); 1530 } 1531 1532 static inline atomic_t *folio_pincount_ptr(struct folio *folio) 1533 { 1534 return &folio_page(folio, 1)->compound_pincount; 1535 } 1536 1537 /** 1538 * folio_maybe_dma_pinned - Report if a folio may be pinned for DMA. 1539 * @folio: The folio. 1540 * 1541 * This function checks if a folio has been pinned via a call to 1542 * a function in the pin_user_pages() family. 1543 * 1544 * For small folios, the return value is partially fuzzy: false is not fuzzy, 1545 * because it means "definitely not pinned for DMA", but true means "probably 1546 * pinned for DMA, but possibly a false positive due to having at least 1547 * GUP_PIN_COUNTING_BIAS worth of normal folio references". 1548 * 1549 * False positives are OK, because: a) it's unlikely for a folio to 1550 * get that many refcounts, and b) all the callers of this routine are 1551 * expected to be able to deal gracefully with a false positive. 1552 * 1553 * For large folios, the result will be exactly correct. That's because 1554 * we have more tracking data available: the compound_pincount is used 1555 * instead of the GUP_PIN_COUNTING_BIAS scheme. 1556 * 1557 * For more information, please see Documentation/core-api/pin_user_pages.rst. 1558 * 1559 * Return: True, if it is likely that the page has been "dma-pinned". 1560 * False, if the page is definitely not dma-pinned. 1561 */ 1562 static inline bool folio_maybe_dma_pinned(struct folio *folio) 1563 { 1564 if (folio_test_large(folio)) 1565 return atomic_read(folio_pincount_ptr(folio)) > 0; 1566 1567 /* 1568 * folio_ref_count() is signed. If that refcount overflows, then 1569 * folio_ref_count() returns a negative value, and callers will avoid 1570 * further incrementing the refcount. 1571 * 1572 * Here, for that overflow case, use the sign bit to count a little 1573 * bit higher via unsigned math, and thus still get an accurate result. 1574 */ 1575 return ((unsigned int)folio_ref_count(folio)) >= 1576 GUP_PIN_COUNTING_BIAS; 1577 } 1578 1579 static inline bool page_maybe_dma_pinned(struct page *page) 1580 { 1581 return folio_maybe_dma_pinned(page_folio(page)); 1582 } 1583 1584 /* 1585 * This should most likely only be called during fork() to see whether we 1586 * should break the cow immediately for an anon page on the src mm. 1587 * 1588 * The caller has to hold the PT lock and the vma->vm_mm->->write_protect_seq. 1589 */ 1590 static inline bool page_needs_cow_for_dma(struct vm_area_struct *vma, 1591 struct page *page) 1592 { 1593 VM_BUG_ON(!(raw_read_seqcount(&vma->vm_mm->write_protect_seq) & 1)); 1594 1595 if (!test_bit(MMF_HAS_PINNED, &vma->vm_mm->flags)) 1596 return false; 1597 1598 return page_maybe_dma_pinned(page); 1599 } 1600 1601 /* MIGRATE_CMA and ZONE_MOVABLE do not allow pin pages */ 1602 #ifdef CONFIG_MIGRATION 1603 static inline bool is_longterm_pinnable_page(struct page *page) 1604 { 1605 #ifdef CONFIG_CMA 1606 int mt = get_pageblock_migratetype(page); 1607 1608 if (mt == MIGRATE_CMA || mt == MIGRATE_ISOLATE) 1609 return false; 1610 #endif 1611 /* The zero page may always be pinned */ 1612 if (is_zero_pfn(page_to_pfn(page))) 1613 return true; 1614 1615 /* Coherent device memory must always allow eviction. */ 1616 if (is_device_coherent_page(page)) 1617 return false; 1618 1619 /* Otherwise, non-movable zone pages can be pinned. */ 1620 return !is_zone_movable_page(page); 1621 } 1622 #else 1623 static inline bool is_longterm_pinnable_page(struct page *page) 1624 { 1625 return true; 1626 } 1627 #endif 1628 1629 static inline bool folio_is_longterm_pinnable(struct folio *folio) 1630 { 1631 return is_longterm_pinnable_page(&folio->page); 1632 } 1633 1634 static inline void set_page_zone(struct page *page, enum zone_type zone) 1635 { 1636 page->flags &= ~(ZONES_MASK << ZONES_PGSHIFT); 1637 page->flags |= (zone & ZONES_MASK) << ZONES_PGSHIFT; 1638 } 1639 1640 static inline void set_page_node(struct page *page, unsigned long node) 1641 { 1642 page->flags &= ~(NODES_MASK << NODES_PGSHIFT); 1643 page->flags |= (node & NODES_MASK) << NODES_PGSHIFT; 1644 } 1645 1646 static inline void set_page_links(struct page *page, enum zone_type zone, 1647 unsigned long node, unsigned long pfn) 1648 { 1649 set_page_zone(page, zone); 1650 set_page_node(page, node); 1651 #ifdef SECTION_IN_PAGE_FLAGS 1652 set_page_section(page, pfn_to_section_nr(pfn)); 1653 #endif 1654 } 1655 1656 /** 1657 * folio_nr_pages - The number of pages in the folio. 1658 * @folio: The folio. 1659 * 1660 * Return: A positive power of two. 1661 */ 1662 static inline long folio_nr_pages(struct folio *folio) 1663 { 1664 if (!folio_test_large(folio)) 1665 return 1; 1666 #ifdef CONFIG_64BIT 1667 return folio->_folio_nr_pages; 1668 #else 1669 return 1L << folio->_folio_order; 1670 #endif 1671 } 1672 1673 /** 1674 * folio_next - Move to the next physical folio. 1675 * @folio: The folio we're currently operating on. 1676 * 1677 * If you have physically contiguous memory which may span more than 1678 * one folio (eg a &struct bio_vec), use this function to move from one 1679 * folio to the next. Do not use it if the memory is only virtually 1680 * contiguous as the folios are almost certainly not adjacent to each 1681 * other. This is the folio equivalent to writing ``page++``. 1682 * 1683 * Context: We assume that the folios are refcounted and/or locked at a 1684 * higher level and do not adjust the reference counts. 1685 * Return: The next struct folio. 1686 */ 1687 static inline struct folio *folio_next(struct folio *folio) 1688 { 1689 return (struct folio *)folio_page(folio, folio_nr_pages(folio)); 1690 } 1691 1692 /** 1693 * folio_shift - The size of the memory described by this folio. 1694 * @folio: The folio. 1695 * 1696 * A folio represents a number of bytes which is a power-of-two in size. 1697 * This function tells you which power-of-two the folio is. See also 1698 * folio_size() and folio_order(). 1699 * 1700 * Context: The caller should have a reference on the folio to prevent 1701 * it from being split. It is not necessary for the folio to be locked. 1702 * Return: The base-2 logarithm of the size of this folio. 1703 */ 1704 static inline unsigned int folio_shift(struct folio *folio) 1705 { 1706 return PAGE_SHIFT + folio_order(folio); 1707 } 1708 1709 /** 1710 * folio_size - The number of bytes in a folio. 1711 * @folio: The folio. 1712 * 1713 * Context: The caller should have a reference on the folio to prevent 1714 * it from being split. It is not necessary for the folio to be locked. 1715 * Return: The number of bytes in this folio. 1716 */ 1717 static inline size_t folio_size(struct folio *folio) 1718 { 1719 return PAGE_SIZE << folio_order(folio); 1720 } 1721 1722 #ifndef HAVE_ARCH_MAKE_PAGE_ACCESSIBLE 1723 static inline int arch_make_page_accessible(struct page *page) 1724 { 1725 return 0; 1726 } 1727 #endif 1728 1729 #ifndef HAVE_ARCH_MAKE_FOLIO_ACCESSIBLE 1730 static inline int arch_make_folio_accessible(struct folio *folio) 1731 { 1732 int ret; 1733 long i, nr = folio_nr_pages(folio); 1734 1735 for (i = 0; i < nr; i++) { 1736 ret = arch_make_page_accessible(folio_page(folio, i)); 1737 if (ret) 1738 break; 1739 } 1740 1741 return ret; 1742 } 1743 #endif 1744 1745 /* 1746 * Some inline functions in vmstat.h depend on page_zone() 1747 */ 1748 #include <linux/vmstat.h> 1749 1750 static __always_inline void *lowmem_page_address(const struct page *page) 1751 { 1752 return page_to_virt(page); 1753 } 1754 1755 #if defined(CONFIG_HIGHMEM) && !defined(WANT_PAGE_VIRTUAL) 1756 #define HASHED_PAGE_VIRTUAL 1757 #endif 1758 1759 #if defined(WANT_PAGE_VIRTUAL) 1760 static inline void *page_address(const struct page *page) 1761 { 1762 return page->virtual; 1763 } 1764 static inline void set_page_address(struct page *page, void *address) 1765 { 1766 page->virtual = address; 1767 } 1768 #define page_address_init() do { } while(0) 1769 #endif 1770 1771 #if defined(HASHED_PAGE_VIRTUAL) 1772 void *page_address(const struct page *page); 1773 void set_page_address(struct page *page, void *virtual); 1774 void page_address_init(void); 1775 #endif 1776 1777 #if !defined(HASHED_PAGE_VIRTUAL) && !defined(WANT_PAGE_VIRTUAL) 1778 #define page_address(page) lowmem_page_address(page) 1779 #define set_page_address(page, address) do { } while(0) 1780 #define page_address_init() do { } while(0) 1781 #endif 1782 1783 static inline void *folio_address(const struct folio *folio) 1784 { 1785 return page_address(&folio->page); 1786 } 1787 1788 extern void *page_rmapping(struct page *page); 1789 extern pgoff_t __page_file_index(struct page *page); 1790 1791 /* 1792 * Return the pagecache index of the passed page. Regular pagecache pages 1793 * use ->index whereas swapcache pages use swp_offset(->private) 1794 */ 1795 static inline pgoff_t page_index(struct page *page) 1796 { 1797 if (unlikely(PageSwapCache(page))) 1798 return __page_file_index(page); 1799 return page->index; 1800 } 1801 1802 bool page_mapped(struct page *page); 1803 bool folio_mapped(struct folio *folio); 1804 1805 /* 1806 * Return true only if the page has been allocated with 1807 * ALLOC_NO_WATERMARKS and the low watermark was not 1808 * met implying that the system is under some pressure. 1809 */ 1810 static inline bool page_is_pfmemalloc(const struct page *page) 1811 { 1812 /* 1813 * lru.next has bit 1 set if the page is allocated from the 1814 * pfmemalloc reserves. Callers may simply overwrite it if 1815 * they do not need to preserve that information. 1816 */ 1817 return (uintptr_t)page->lru.next & BIT(1); 1818 } 1819 1820 /* 1821 * Only to be called by the page allocator on a freshly allocated 1822 * page. 1823 */ 1824 static inline void set_page_pfmemalloc(struct page *page) 1825 { 1826 page->lru.next = (void *)BIT(1); 1827 } 1828 1829 static inline void clear_page_pfmemalloc(struct page *page) 1830 { 1831 page->lru.next = NULL; 1832 } 1833 1834 /* 1835 * Can be called by the pagefault handler when it gets a VM_FAULT_OOM. 1836 */ 1837 extern void pagefault_out_of_memory(void); 1838 1839 #define offset_in_page(p) ((unsigned long)(p) & ~PAGE_MASK) 1840 #define offset_in_thp(page, p) ((unsigned long)(p) & (thp_size(page) - 1)) 1841 #define offset_in_folio(folio, p) ((unsigned long)(p) & (folio_size(folio) - 1)) 1842 1843 /* 1844 * Flags passed to show_mem() and show_free_areas() to suppress output in 1845 * various contexts. 1846 */ 1847 #define SHOW_MEM_FILTER_NODES (0x0001u) /* disallowed nodes */ 1848 1849 extern void __show_free_areas(unsigned int flags, nodemask_t *nodemask, int max_zone_idx); 1850 static void __maybe_unused show_free_areas(unsigned int flags, nodemask_t *nodemask) 1851 { 1852 __show_free_areas(flags, nodemask, MAX_NR_ZONES - 1); 1853 } 1854 1855 #ifdef CONFIG_MMU 1856 extern bool can_do_mlock(void); 1857 #else 1858 static inline bool can_do_mlock(void) { return false; } 1859 #endif 1860 extern int user_shm_lock(size_t, struct ucounts *); 1861 extern void user_shm_unlock(size_t, struct ucounts *); 1862 1863 struct page *vm_normal_page(struct vm_area_struct *vma, unsigned long addr, 1864 pte_t pte); 1865 struct page *vm_normal_page_pmd(struct vm_area_struct *vma, unsigned long addr, 1866 pmd_t pmd); 1867 1868 void zap_vma_ptes(struct vm_area_struct *vma, unsigned long address, 1869 unsigned long size); 1870 void zap_page_range(struct vm_area_struct *vma, unsigned long address, 1871 unsigned long size); 1872 void unmap_vmas(struct mmu_gather *tlb, struct maple_tree *mt, 1873 struct vm_area_struct *start_vma, unsigned long start, 1874 unsigned long end); 1875 1876 struct mmu_notifier_range; 1877 1878 void free_pgd_range(struct mmu_gather *tlb, unsigned long addr, 1879 unsigned long end, unsigned long floor, unsigned long ceiling); 1880 int 1881 copy_page_range(struct vm_area_struct *dst_vma, struct vm_area_struct *src_vma); 1882 int follow_pte(struct mm_struct *mm, unsigned long address, 1883 pte_t **ptepp, spinlock_t **ptlp); 1884 int follow_pfn(struct vm_area_struct *vma, unsigned long address, 1885 unsigned long *pfn); 1886 int follow_phys(struct vm_area_struct *vma, unsigned long address, 1887 unsigned int flags, unsigned long *prot, resource_size_t *phys); 1888 int generic_access_phys(struct vm_area_struct *vma, unsigned long addr, 1889 void *buf, int len, int write); 1890 1891 extern void truncate_pagecache(struct inode *inode, loff_t new); 1892 extern void truncate_setsize(struct inode *inode, loff_t newsize); 1893 void pagecache_isize_extended(struct inode *inode, loff_t from, loff_t to); 1894 void truncate_pagecache_range(struct inode *inode, loff_t offset, loff_t end); 1895 int generic_error_remove_page(struct address_space *mapping, struct page *page); 1896 1897 #ifdef CONFIG_MMU 1898 extern vm_fault_t handle_mm_fault(struct vm_area_struct *vma, 1899 unsigned long address, unsigned int flags, 1900 struct pt_regs *regs); 1901 extern int fixup_user_fault(struct mm_struct *mm, 1902 unsigned long address, unsigned int fault_flags, 1903 bool *unlocked); 1904 void unmap_mapping_pages(struct address_space *mapping, 1905 pgoff_t start, pgoff_t nr, bool even_cows); 1906 void unmap_mapping_range(struct address_space *mapping, 1907 loff_t const holebegin, loff_t const holelen, int even_cows); 1908 #else 1909 static inline vm_fault_t handle_mm_fault(struct vm_area_struct *vma, 1910 unsigned long address, unsigned int flags, 1911 struct pt_regs *regs) 1912 { 1913 /* should never happen if there's no MMU */ 1914 BUG(); 1915 return VM_FAULT_SIGBUS; 1916 } 1917 static inline int fixup_user_fault(struct mm_struct *mm, unsigned long address, 1918 unsigned int fault_flags, bool *unlocked) 1919 { 1920 /* should never happen if there's no MMU */ 1921 BUG(); 1922 return -EFAULT; 1923 } 1924 static inline void unmap_mapping_pages(struct address_space *mapping, 1925 pgoff_t start, pgoff_t nr, bool even_cows) { } 1926 static inline void unmap_mapping_range(struct address_space *mapping, 1927 loff_t const holebegin, loff_t const holelen, int even_cows) { } 1928 #endif 1929 1930 static inline void unmap_shared_mapping_range(struct address_space *mapping, 1931 loff_t const holebegin, loff_t const holelen) 1932 { 1933 unmap_mapping_range(mapping, holebegin, holelen, 0); 1934 } 1935 1936 extern int access_process_vm(struct task_struct *tsk, unsigned long addr, 1937 void *buf, int len, unsigned int gup_flags); 1938 extern int access_remote_vm(struct mm_struct *mm, unsigned long addr, 1939 void *buf, int len, unsigned int gup_flags); 1940 extern int __access_remote_vm(struct mm_struct *mm, unsigned long addr, 1941 void *buf, int len, unsigned int gup_flags); 1942 1943 long get_user_pages_remote(struct mm_struct *mm, 1944 unsigned long start, unsigned long nr_pages, 1945 unsigned int gup_flags, struct page **pages, 1946 struct vm_area_struct **vmas, int *locked); 1947 long pin_user_pages_remote(struct mm_struct *mm, 1948 unsigned long start, unsigned long nr_pages, 1949 unsigned int gup_flags, struct page **pages, 1950 struct vm_area_struct **vmas, int *locked); 1951 long get_user_pages(unsigned long start, unsigned long nr_pages, 1952 unsigned int gup_flags, struct page **pages, 1953 struct vm_area_struct **vmas); 1954 long pin_user_pages(unsigned long start, unsigned long nr_pages, 1955 unsigned int gup_flags, struct page **pages, 1956 struct vm_area_struct **vmas); 1957 long get_user_pages_unlocked(unsigned long start, unsigned long nr_pages, 1958 struct page **pages, unsigned int gup_flags); 1959 long pin_user_pages_unlocked(unsigned long start, unsigned long nr_pages, 1960 struct page **pages, unsigned int gup_flags); 1961 1962 int get_user_pages_fast(unsigned long start, int nr_pages, 1963 unsigned int gup_flags, struct page **pages); 1964 int pin_user_pages_fast(unsigned long start, int nr_pages, 1965 unsigned int gup_flags, struct page **pages); 1966 1967 int account_locked_vm(struct mm_struct *mm, unsigned long pages, bool inc); 1968 int __account_locked_vm(struct mm_struct *mm, unsigned long pages, bool inc, 1969 struct task_struct *task, bool bypass_rlim); 1970 1971 struct kvec; 1972 int get_kernel_pages(const struct kvec *iov, int nr_pages, int write, 1973 struct page **pages); 1974 struct page *get_dump_page(unsigned long addr); 1975 1976 bool folio_mark_dirty(struct folio *folio); 1977 bool set_page_dirty(struct page *page); 1978 int set_page_dirty_lock(struct page *page); 1979 1980 int get_cmdline(struct task_struct *task, char *buffer, int buflen); 1981 1982 extern unsigned long move_page_tables(struct vm_area_struct *vma, 1983 unsigned long old_addr, struct vm_area_struct *new_vma, 1984 unsigned long new_addr, unsigned long len, 1985 bool need_rmap_locks); 1986 1987 /* 1988 * Flags used by change_protection(). For now we make it a bitmap so 1989 * that we can pass in multiple flags just like parameters. However 1990 * for now all the callers are only use one of the flags at the same 1991 * time. 1992 */ 1993 /* 1994 * Whether we should manually check if we can map individual PTEs writable, 1995 * because something (e.g., COW, uffd-wp) blocks that from happening for all 1996 * PTEs automatically in a writable mapping. 1997 */ 1998 #define MM_CP_TRY_CHANGE_WRITABLE (1UL << 0) 1999 /* Whether this protection change is for NUMA hints */ 2000 #define MM_CP_PROT_NUMA (1UL << 1) 2001 /* Whether this change is for write protecting */ 2002 #define MM_CP_UFFD_WP (1UL << 2) /* do wp */ 2003 #define MM_CP_UFFD_WP_RESOLVE (1UL << 3) /* Resolve wp */ 2004 #define MM_CP_UFFD_WP_ALL (MM_CP_UFFD_WP | \ 2005 MM_CP_UFFD_WP_RESOLVE) 2006 2007 extern unsigned long change_protection(struct mmu_gather *tlb, 2008 struct vm_area_struct *vma, unsigned long start, 2009 unsigned long end, pgprot_t newprot, 2010 unsigned long cp_flags); 2011 extern int mprotect_fixup(struct mmu_gather *tlb, struct vm_area_struct *vma, 2012 struct vm_area_struct **pprev, unsigned long start, 2013 unsigned long end, unsigned long newflags); 2014 2015 /* 2016 * doesn't attempt to fault and will return short. 2017 */ 2018 int get_user_pages_fast_only(unsigned long start, int nr_pages, 2019 unsigned int gup_flags, struct page **pages); 2020 int pin_user_pages_fast_only(unsigned long start, int nr_pages, 2021 unsigned int gup_flags, struct page **pages); 2022 2023 static inline bool get_user_page_fast_only(unsigned long addr, 2024 unsigned int gup_flags, struct page **pagep) 2025 { 2026 return get_user_pages_fast_only(addr, 1, gup_flags, pagep) == 1; 2027 } 2028 /* 2029 * per-process(per-mm_struct) statistics. 2030 */ 2031 static inline unsigned long get_mm_counter(struct mm_struct *mm, int member) 2032 { 2033 long val = atomic_long_read(&mm->rss_stat.count[member]); 2034 2035 #ifdef SPLIT_RSS_COUNTING 2036 /* 2037 * counter is updated in asynchronous manner and may go to minus. 2038 * But it's never be expected number for users. 2039 */ 2040 if (val < 0) 2041 val = 0; 2042 #endif 2043 return (unsigned long)val; 2044 } 2045 2046 void mm_trace_rss_stat(struct mm_struct *mm, int member, long count); 2047 2048 static inline void add_mm_counter(struct mm_struct *mm, int member, long value) 2049 { 2050 long count = atomic_long_add_return(value, &mm->rss_stat.count[member]); 2051 2052 mm_trace_rss_stat(mm, member, count); 2053 } 2054 2055 static inline void inc_mm_counter(struct mm_struct *mm, int member) 2056 { 2057 long count = atomic_long_inc_return(&mm->rss_stat.count[member]); 2058 2059 mm_trace_rss_stat(mm, member, count); 2060 } 2061 2062 static inline void dec_mm_counter(struct mm_struct *mm, int member) 2063 { 2064 long count = atomic_long_dec_return(&mm->rss_stat.count[member]); 2065 2066 mm_trace_rss_stat(mm, member, count); 2067 } 2068 2069 /* Optimized variant when page is already known not to be PageAnon */ 2070 static inline int mm_counter_file(struct page *page) 2071 { 2072 if (PageSwapBacked(page)) 2073 return MM_SHMEMPAGES; 2074 return MM_FILEPAGES; 2075 } 2076 2077 static inline int mm_counter(struct page *page) 2078 { 2079 if (PageAnon(page)) 2080 return MM_ANONPAGES; 2081 return mm_counter_file(page); 2082 } 2083 2084 static inline unsigned long get_mm_rss(struct mm_struct *mm) 2085 { 2086 return get_mm_counter(mm, MM_FILEPAGES) + 2087 get_mm_counter(mm, MM_ANONPAGES) + 2088 get_mm_counter(mm, MM_SHMEMPAGES); 2089 } 2090 2091 static inline unsigned long get_mm_hiwater_rss(struct mm_struct *mm) 2092 { 2093 return max(mm->hiwater_rss, get_mm_rss(mm)); 2094 } 2095 2096 static inline unsigned long get_mm_hiwater_vm(struct mm_struct *mm) 2097 { 2098 return max(mm->hiwater_vm, mm->total_vm); 2099 } 2100 2101 static inline void update_hiwater_rss(struct mm_struct *mm) 2102 { 2103 unsigned long _rss = get_mm_rss(mm); 2104 2105 if ((mm)->hiwater_rss < _rss) 2106 (mm)->hiwater_rss = _rss; 2107 } 2108 2109 static inline void update_hiwater_vm(struct mm_struct *mm) 2110 { 2111 if (mm->hiwater_vm < mm->total_vm) 2112 mm->hiwater_vm = mm->total_vm; 2113 } 2114 2115 static inline void reset_mm_hiwater_rss(struct mm_struct *mm) 2116 { 2117 mm->hiwater_rss = get_mm_rss(mm); 2118 } 2119 2120 static inline void setmax_mm_hiwater_rss(unsigned long *maxrss, 2121 struct mm_struct *mm) 2122 { 2123 unsigned long hiwater_rss = get_mm_hiwater_rss(mm); 2124 2125 if (*maxrss < hiwater_rss) 2126 *maxrss = hiwater_rss; 2127 } 2128 2129 #if defined(SPLIT_RSS_COUNTING) 2130 void sync_mm_rss(struct mm_struct *mm); 2131 #else 2132 static inline void sync_mm_rss(struct mm_struct *mm) 2133 { 2134 } 2135 #endif 2136 2137 #ifndef CONFIG_ARCH_HAS_PTE_SPECIAL 2138 static inline int pte_special(pte_t pte) 2139 { 2140 return 0; 2141 } 2142 2143 static inline pte_t pte_mkspecial(pte_t pte) 2144 { 2145 return pte; 2146 } 2147 #endif 2148 2149 #ifndef CONFIG_ARCH_HAS_PTE_DEVMAP 2150 static inline int pte_devmap(pte_t pte) 2151 { 2152 return 0; 2153 } 2154 #endif 2155 2156 int vma_wants_writenotify(struct vm_area_struct *vma, pgprot_t vm_page_prot); 2157 2158 extern pte_t *__get_locked_pte(struct mm_struct *mm, unsigned long addr, 2159 spinlock_t **ptl); 2160 static inline pte_t *get_locked_pte(struct mm_struct *mm, unsigned long addr, 2161 spinlock_t **ptl) 2162 { 2163 pte_t *ptep; 2164 __cond_lock(*ptl, ptep = __get_locked_pte(mm, addr, ptl)); 2165 return ptep; 2166 } 2167 2168 #ifdef __PAGETABLE_P4D_FOLDED 2169 static inline int __p4d_alloc(struct mm_struct *mm, pgd_t *pgd, 2170 unsigned long address) 2171 { 2172 return 0; 2173 } 2174 #else 2175 int __p4d_alloc(struct mm_struct *mm, pgd_t *pgd, unsigned long address); 2176 #endif 2177 2178 #if defined(__PAGETABLE_PUD_FOLDED) || !defined(CONFIG_MMU) 2179 static inline int __pud_alloc(struct mm_struct *mm, p4d_t *p4d, 2180 unsigned long address) 2181 { 2182 return 0; 2183 } 2184 static inline void mm_inc_nr_puds(struct mm_struct *mm) {} 2185 static inline void mm_dec_nr_puds(struct mm_struct *mm) {} 2186 2187 #else 2188 int __pud_alloc(struct mm_struct *mm, p4d_t *p4d, unsigned long address); 2189 2190 static inline void mm_inc_nr_puds(struct mm_struct *mm) 2191 { 2192 if (mm_pud_folded(mm)) 2193 return; 2194 atomic_long_add(PTRS_PER_PUD * sizeof(pud_t), &mm->pgtables_bytes); 2195 } 2196 2197 static inline void mm_dec_nr_puds(struct mm_struct *mm) 2198 { 2199 if (mm_pud_folded(mm)) 2200 return; 2201 atomic_long_sub(PTRS_PER_PUD * sizeof(pud_t), &mm->pgtables_bytes); 2202 } 2203 #endif 2204 2205 #if defined(__PAGETABLE_PMD_FOLDED) || !defined(CONFIG_MMU) 2206 static inline int __pmd_alloc(struct mm_struct *mm, pud_t *pud, 2207 unsigned long address) 2208 { 2209 return 0; 2210 } 2211 2212 static inline void mm_inc_nr_pmds(struct mm_struct *mm) {} 2213 static inline void mm_dec_nr_pmds(struct mm_struct *mm) {} 2214 2215 #else 2216 int __pmd_alloc(struct mm_struct *mm, pud_t *pud, unsigned long address); 2217 2218 static inline void mm_inc_nr_pmds(struct mm_struct *mm) 2219 { 2220 if (mm_pmd_folded(mm)) 2221 return; 2222 atomic_long_add(PTRS_PER_PMD * sizeof(pmd_t), &mm->pgtables_bytes); 2223 } 2224 2225 static inline void mm_dec_nr_pmds(struct mm_struct *mm) 2226 { 2227 if (mm_pmd_folded(mm)) 2228 return; 2229 atomic_long_sub(PTRS_PER_PMD * sizeof(pmd_t), &mm->pgtables_bytes); 2230 } 2231 #endif 2232 2233 #ifdef CONFIG_MMU 2234 static inline void mm_pgtables_bytes_init(struct mm_struct *mm) 2235 { 2236 atomic_long_set(&mm->pgtables_bytes, 0); 2237 } 2238 2239 static inline unsigned long mm_pgtables_bytes(const struct mm_struct *mm) 2240 { 2241 return atomic_long_read(&mm->pgtables_bytes); 2242 } 2243 2244 static inline void mm_inc_nr_ptes(struct mm_struct *mm) 2245 { 2246 atomic_long_add(PTRS_PER_PTE * sizeof(pte_t), &mm->pgtables_bytes); 2247 } 2248 2249 static inline void mm_dec_nr_ptes(struct mm_struct *mm) 2250 { 2251 atomic_long_sub(PTRS_PER_PTE * sizeof(pte_t), &mm->pgtables_bytes); 2252 } 2253 #else 2254 2255 static inline void mm_pgtables_bytes_init(struct mm_struct *mm) {} 2256 static inline unsigned long mm_pgtables_bytes(const struct mm_struct *mm) 2257 { 2258 return 0; 2259 } 2260 2261 static inline void mm_inc_nr_ptes(struct mm_struct *mm) {} 2262 static inline void mm_dec_nr_ptes(struct mm_struct *mm) {} 2263 #endif 2264 2265 int __pte_alloc(struct mm_struct *mm, pmd_t *pmd); 2266 int __pte_alloc_kernel(pmd_t *pmd); 2267 2268 #if defined(CONFIG_MMU) 2269 2270 static inline p4d_t *p4d_alloc(struct mm_struct *mm, pgd_t *pgd, 2271 unsigned long address) 2272 { 2273 return (unlikely(pgd_none(*pgd)) && __p4d_alloc(mm, pgd, address)) ? 2274 NULL : p4d_offset(pgd, address); 2275 } 2276 2277 static inline pud_t *pud_alloc(struct mm_struct *mm, p4d_t *p4d, 2278 unsigned long address) 2279 { 2280 return (unlikely(p4d_none(*p4d)) && __pud_alloc(mm, p4d, address)) ? 2281 NULL : pud_offset(p4d, address); 2282 } 2283 2284 static inline pmd_t *pmd_alloc(struct mm_struct *mm, pud_t *pud, unsigned long address) 2285 { 2286 return (unlikely(pud_none(*pud)) && __pmd_alloc(mm, pud, address))? 2287 NULL: pmd_offset(pud, address); 2288 } 2289 #endif /* CONFIG_MMU */ 2290 2291 #if USE_SPLIT_PTE_PTLOCKS 2292 #if ALLOC_SPLIT_PTLOCKS 2293 void __init ptlock_cache_init(void); 2294 extern bool ptlock_alloc(struct page *page); 2295 extern void ptlock_free(struct page *page); 2296 2297 static inline spinlock_t *ptlock_ptr(struct page *page) 2298 { 2299 return page->ptl; 2300 } 2301 #else /* ALLOC_SPLIT_PTLOCKS */ 2302 static inline void ptlock_cache_init(void) 2303 { 2304 } 2305 2306 static inline bool ptlock_alloc(struct page *page) 2307 { 2308 return true; 2309 } 2310 2311 static inline void ptlock_free(struct page *page) 2312 { 2313 } 2314 2315 static inline spinlock_t *ptlock_ptr(struct page *page) 2316 { 2317 return &page->ptl; 2318 } 2319 #endif /* ALLOC_SPLIT_PTLOCKS */ 2320 2321 static inline spinlock_t *pte_lockptr(struct mm_struct *mm, pmd_t *pmd) 2322 { 2323 return ptlock_ptr(pmd_page(*pmd)); 2324 } 2325 2326 static inline bool ptlock_init(struct page *page) 2327 { 2328 /* 2329 * prep_new_page() initialize page->private (and therefore page->ptl) 2330 * with 0. Make sure nobody took it in use in between. 2331 * 2332 * It can happen if arch try to use slab for page table allocation: 2333 * slab code uses page->slab_cache, which share storage with page->ptl. 2334 */ 2335 VM_BUG_ON_PAGE(*(unsigned long *)&page->ptl, page); 2336 if (!ptlock_alloc(page)) 2337 return false; 2338 spin_lock_init(ptlock_ptr(page)); 2339 return true; 2340 } 2341 2342 #else /* !USE_SPLIT_PTE_PTLOCKS */ 2343 /* 2344 * We use mm->page_table_lock to guard all pagetable pages of the mm. 2345 */ 2346 static inline spinlock_t *pte_lockptr(struct mm_struct *mm, pmd_t *pmd) 2347 { 2348 return &mm->page_table_lock; 2349 } 2350 static inline void ptlock_cache_init(void) {} 2351 static inline bool ptlock_init(struct page *page) { return true; } 2352 static inline void ptlock_free(struct page *page) {} 2353 #endif /* USE_SPLIT_PTE_PTLOCKS */ 2354 2355 static inline void pgtable_init(void) 2356 { 2357 ptlock_cache_init(); 2358 pgtable_cache_init(); 2359 } 2360 2361 static inline bool pgtable_pte_page_ctor(struct page *page) 2362 { 2363 if (!ptlock_init(page)) 2364 return false; 2365 __SetPageTable(page); 2366 inc_lruvec_page_state(page, NR_PAGETABLE); 2367 return true; 2368 } 2369 2370 static inline void pgtable_pte_page_dtor(struct page *page) 2371 { 2372 ptlock_free(page); 2373 __ClearPageTable(page); 2374 dec_lruvec_page_state(page, NR_PAGETABLE); 2375 } 2376 2377 #define pte_offset_map_lock(mm, pmd, address, ptlp) \ 2378 ({ \ 2379 spinlock_t *__ptl = pte_lockptr(mm, pmd); \ 2380 pte_t *__pte = pte_offset_map(pmd, address); \ 2381 *(ptlp) = __ptl; \ 2382 spin_lock(__ptl); \ 2383 __pte; \ 2384 }) 2385 2386 #define pte_unmap_unlock(pte, ptl) do { \ 2387 spin_unlock(ptl); \ 2388 pte_unmap(pte); \ 2389 } while (0) 2390 2391 #define pte_alloc(mm, pmd) (unlikely(pmd_none(*(pmd))) && __pte_alloc(mm, pmd)) 2392 2393 #define pte_alloc_map(mm, pmd, address) \ 2394 (pte_alloc(mm, pmd) ? NULL : pte_offset_map(pmd, address)) 2395 2396 #define pte_alloc_map_lock(mm, pmd, address, ptlp) \ 2397 (pte_alloc(mm, pmd) ? \ 2398 NULL : pte_offset_map_lock(mm, pmd, address, ptlp)) 2399 2400 #define pte_alloc_kernel(pmd, address) \ 2401 ((unlikely(pmd_none(*(pmd))) && __pte_alloc_kernel(pmd))? \ 2402 NULL: pte_offset_kernel(pmd, address)) 2403 2404 #if USE_SPLIT_PMD_PTLOCKS 2405 2406 static struct page *pmd_to_page(pmd_t *pmd) 2407 { 2408 unsigned long mask = ~(PTRS_PER_PMD * sizeof(pmd_t) - 1); 2409 return virt_to_page((void *)((unsigned long) pmd & mask)); 2410 } 2411 2412 static inline spinlock_t *pmd_lockptr(struct mm_struct *mm, pmd_t *pmd) 2413 { 2414 return ptlock_ptr(pmd_to_page(pmd)); 2415 } 2416 2417 static inline bool pmd_ptlock_init(struct page *page) 2418 { 2419 #ifdef CONFIG_TRANSPARENT_HUGEPAGE 2420 page->pmd_huge_pte = NULL; 2421 #endif 2422 return ptlock_init(page); 2423 } 2424 2425 static inline void pmd_ptlock_free(struct page *page) 2426 { 2427 #ifdef CONFIG_TRANSPARENT_HUGEPAGE 2428 VM_BUG_ON_PAGE(page->pmd_huge_pte, page); 2429 #endif 2430 ptlock_free(page); 2431 } 2432 2433 #define pmd_huge_pte(mm, pmd) (pmd_to_page(pmd)->pmd_huge_pte) 2434 2435 #else 2436 2437 static inline spinlock_t *pmd_lockptr(struct mm_struct *mm, pmd_t *pmd) 2438 { 2439 return &mm->page_table_lock; 2440 } 2441 2442 static inline bool pmd_ptlock_init(struct page *page) { return true; } 2443 static inline void pmd_ptlock_free(struct page *page) {} 2444 2445 #define pmd_huge_pte(mm, pmd) ((mm)->pmd_huge_pte) 2446 2447 #endif 2448 2449 static inline spinlock_t *pmd_lock(struct mm_struct *mm, pmd_t *pmd) 2450 { 2451 spinlock_t *ptl = pmd_lockptr(mm, pmd); 2452 spin_lock(ptl); 2453 return ptl; 2454 } 2455 2456 static inline bool pgtable_pmd_page_ctor(struct page *page) 2457 { 2458 if (!pmd_ptlock_init(page)) 2459 return false; 2460 __SetPageTable(page); 2461 inc_lruvec_page_state(page, NR_PAGETABLE); 2462 return true; 2463 } 2464 2465 static inline void pgtable_pmd_page_dtor(struct page *page) 2466 { 2467 pmd_ptlock_free(page); 2468 __ClearPageTable(page); 2469 dec_lruvec_page_state(page, NR_PAGETABLE); 2470 } 2471 2472 /* 2473 * No scalability reason to split PUD locks yet, but follow the same pattern 2474 * as the PMD locks to make it easier if we decide to. The VM should not be 2475 * considered ready to switch to split PUD locks yet; there may be places 2476 * which need to be converted from page_table_lock. 2477 */ 2478 static inline spinlock_t *pud_lockptr(struct mm_struct *mm, pud_t *pud) 2479 { 2480 return &mm->page_table_lock; 2481 } 2482 2483 static inline spinlock_t *pud_lock(struct mm_struct *mm, pud_t *pud) 2484 { 2485 spinlock_t *ptl = pud_lockptr(mm, pud); 2486 2487 spin_lock(ptl); 2488 return ptl; 2489 } 2490 2491 extern void __init pagecache_init(void); 2492 extern void free_initmem(void); 2493 2494 /* 2495 * Free reserved pages within range [PAGE_ALIGN(start), end & PAGE_MASK) 2496 * into the buddy system. The freed pages will be poisoned with pattern 2497 * "poison" if it's within range [0, UCHAR_MAX]. 2498 * Return pages freed into the buddy system. 2499 */ 2500 extern unsigned long free_reserved_area(void *start, void *end, 2501 int poison, const char *s); 2502 2503 extern void adjust_managed_page_count(struct page *page, long count); 2504 extern void mem_init_print_info(void); 2505 2506 extern void reserve_bootmem_region(phys_addr_t start, phys_addr_t end); 2507 2508 /* Free the reserved page into the buddy system, so it gets managed. */ 2509 static inline void free_reserved_page(struct page *page) 2510 { 2511 ClearPageReserved(page); 2512 init_page_count(page); 2513 __free_page(page); 2514 adjust_managed_page_count(page, 1); 2515 } 2516 #define free_highmem_page(page) free_reserved_page(page) 2517 2518 static inline void mark_page_reserved(struct page *page) 2519 { 2520 SetPageReserved(page); 2521 adjust_managed_page_count(page, -1); 2522 } 2523 2524 /* 2525 * Default method to free all the __init memory into the buddy system. 2526 * The freed pages will be poisoned with pattern "poison" if it's within 2527 * range [0, UCHAR_MAX]. 2528 * Return pages freed into the buddy system. 2529 */ 2530 static inline unsigned long free_initmem_default(int poison) 2531 { 2532 extern char __init_begin[], __init_end[]; 2533 2534 return free_reserved_area(&__init_begin, &__init_end, 2535 poison, "unused kernel image (initmem)"); 2536 } 2537 2538 static inline unsigned long get_num_physpages(void) 2539 { 2540 int nid; 2541 unsigned long phys_pages = 0; 2542 2543 for_each_online_node(nid) 2544 phys_pages += node_present_pages(nid); 2545 2546 return phys_pages; 2547 } 2548 2549 /* 2550 * Using memblock node mappings, an architecture may initialise its 2551 * zones, allocate the backing mem_map and account for memory holes in an 2552 * architecture independent manner. 2553 * 2554 * An architecture is expected to register range of page frames backed by 2555 * physical memory with memblock_add[_node]() before calling 2556 * free_area_init() passing in the PFN each zone ends at. At a basic 2557 * usage, an architecture is expected to do something like 2558 * 2559 * unsigned long max_zone_pfns[MAX_NR_ZONES] = {max_dma, max_normal_pfn, 2560 * max_highmem_pfn}; 2561 * for_each_valid_physical_page_range() 2562 * memblock_add_node(base, size, nid, MEMBLOCK_NONE) 2563 * free_area_init(max_zone_pfns); 2564 */ 2565 void free_area_init(unsigned long *max_zone_pfn); 2566 unsigned long node_map_pfn_alignment(void); 2567 unsigned long __absent_pages_in_range(int nid, unsigned long start_pfn, 2568 unsigned long end_pfn); 2569 extern unsigned long absent_pages_in_range(unsigned long start_pfn, 2570 unsigned long end_pfn); 2571 extern void get_pfn_range_for_nid(unsigned int nid, 2572 unsigned long *start_pfn, unsigned long *end_pfn); 2573 2574 #ifndef CONFIG_NUMA 2575 static inline int early_pfn_to_nid(unsigned long pfn) 2576 { 2577 return 0; 2578 } 2579 #else 2580 /* please see mm/page_alloc.c */ 2581 extern int __meminit early_pfn_to_nid(unsigned long pfn); 2582 #endif 2583 2584 extern void set_dma_reserve(unsigned long new_dma_reserve); 2585 extern void memmap_init_range(unsigned long, int, unsigned long, 2586 unsigned long, unsigned long, enum meminit_context, 2587 struct vmem_altmap *, int migratetype); 2588 extern void setup_per_zone_wmarks(void); 2589 extern void calculate_min_free_kbytes(void); 2590 extern int __meminit init_per_zone_wmark_min(void); 2591 extern void mem_init(void); 2592 extern void __init mmap_init(void); 2593 2594 extern void __show_mem(unsigned int flags, nodemask_t *nodemask, int max_zone_idx); 2595 static inline void show_mem(unsigned int flags, nodemask_t *nodemask) 2596 { 2597 __show_mem(flags, nodemask, MAX_NR_ZONES - 1); 2598 } 2599 extern long si_mem_available(void); 2600 extern void si_meminfo(struct sysinfo * val); 2601 extern void si_meminfo_node(struct sysinfo *val, int nid); 2602 #ifdef __HAVE_ARCH_RESERVED_KERNEL_PAGES 2603 extern unsigned long arch_reserved_kernel_pages(void); 2604 #endif 2605 2606 extern __printf(3, 4) 2607 void warn_alloc(gfp_t gfp_mask, nodemask_t *nodemask, const char *fmt, ...); 2608 2609 extern void setup_per_cpu_pageset(void); 2610 2611 /* page_alloc.c */ 2612 extern int min_free_kbytes; 2613 extern int watermark_boost_factor; 2614 extern int watermark_scale_factor; 2615 extern bool arch_has_descending_max_zone_pfns(void); 2616 2617 /* nommu.c */ 2618 extern atomic_long_t mmap_pages_allocated; 2619 extern int nommu_shrink_inode_mappings(struct inode *, size_t, size_t); 2620 2621 /* interval_tree.c */ 2622 void vma_interval_tree_insert(struct vm_area_struct *node, 2623 struct rb_root_cached *root); 2624 void vma_interval_tree_insert_after(struct vm_area_struct *node, 2625 struct vm_area_struct *prev, 2626 struct rb_root_cached *root); 2627 void vma_interval_tree_remove(struct vm_area_struct *node, 2628 struct rb_root_cached *root); 2629 struct vm_area_struct *vma_interval_tree_iter_first(struct rb_root_cached *root, 2630 unsigned long start, unsigned long last); 2631 struct vm_area_struct *vma_interval_tree_iter_next(struct vm_area_struct *node, 2632 unsigned long start, unsigned long last); 2633 2634 #define vma_interval_tree_foreach(vma, root, start, last) \ 2635 for (vma = vma_interval_tree_iter_first(root, start, last); \ 2636 vma; vma = vma_interval_tree_iter_next(vma, start, last)) 2637 2638 void anon_vma_interval_tree_insert(struct anon_vma_chain *node, 2639 struct rb_root_cached *root); 2640 void anon_vma_interval_tree_remove(struct anon_vma_chain *node, 2641 struct rb_root_cached *root); 2642 struct anon_vma_chain * 2643 anon_vma_interval_tree_iter_first(struct rb_root_cached *root, 2644 unsigned long start, unsigned long last); 2645 struct anon_vma_chain *anon_vma_interval_tree_iter_next( 2646 struct anon_vma_chain *node, unsigned long start, unsigned long last); 2647 #ifdef CONFIG_DEBUG_VM_RB 2648 void anon_vma_interval_tree_verify(struct anon_vma_chain *node); 2649 #endif 2650 2651 #define anon_vma_interval_tree_foreach(avc, root, start, last) \ 2652 for (avc = anon_vma_interval_tree_iter_first(root, start, last); \ 2653 avc; avc = anon_vma_interval_tree_iter_next(avc, start, last)) 2654 2655 /* mmap.c */ 2656 extern int __vm_enough_memory(struct mm_struct *mm, long pages, int cap_sys_admin); 2657 extern int __vma_adjust(struct vm_area_struct *vma, unsigned long start, 2658 unsigned long end, pgoff_t pgoff, struct vm_area_struct *insert, 2659 struct vm_area_struct *expand); 2660 static inline int vma_adjust(struct vm_area_struct *vma, unsigned long start, 2661 unsigned long end, pgoff_t pgoff, struct vm_area_struct *insert) 2662 { 2663 return __vma_adjust(vma, start, end, pgoff, insert, NULL); 2664 } 2665 extern struct vm_area_struct *vma_merge(struct mm_struct *, 2666 struct vm_area_struct *prev, unsigned long addr, unsigned long end, 2667 unsigned long vm_flags, struct anon_vma *, struct file *, pgoff_t, 2668 struct mempolicy *, struct vm_userfaultfd_ctx, struct anon_vma_name *); 2669 extern struct anon_vma *find_mergeable_anon_vma(struct vm_area_struct *); 2670 extern int __split_vma(struct mm_struct *, struct vm_area_struct *, 2671 unsigned long addr, int new_below); 2672 extern int split_vma(struct mm_struct *, struct vm_area_struct *, 2673 unsigned long addr, int new_below); 2674 extern int insert_vm_struct(struct mm_struct *, struct vm_area_struct *); 2675 extern void unlink_file_vma(struct vm_area_struct *); 2676 extern struct vm_area_struct *copy_vma(struct vm_area_struct **, 2677 unsigned long addr, unsigned long len, pgoff_t pgoff, 2678 bool *need_rmap_locks); 2679 extern void exit_mmap(struct mm_struct *); 2680 2681 void vma_mas_store(struct vm_area_struct *vma, struct ma_state *mas); 2682 void vma_mas_remove(struct vm_area_struct *vma, struct ma_state *mas); 2683 2684 static inline int check_data_rlimit(unsigned long rlim, 2685 unsigned long new, 2686 unsigned long start, 2687 unsigned long end_data, 2688 unsigned long start_data) 2689 { 2690 if (rlim < RLIM_INFINITY) { 2691 if (((new - start) + (end_data - start_data)) > rlim) 2692 return -ENOSPC; 2693 } 2694 2695 return 0; 2696 } 2697 2698 extern int mm_take_all_locks(struct mm_struct *mm); 2699 extern void mm_drop_all_locks(struct mm_struct *mm); 2700 2701 extern int set_mm_exe_file(struct mm_struct *mm, struct file *new_exe_file); 2702 extern int replace_mm_exe_file(struct mm_struct *mm, struct file *new_exe_file); 2703 extern struct file *get_mm_exe_file(struct mm_struct *mm); 2704 extern struct file *get_task_exe_file(struct task_struct *task); 2705 2706 extern bool may_expand_vm(struct mm_struct *, vm_flags_t, unsigned long npages); 2707 extern void vm_stat_account(struct mm_struct *, vm_flags_t, long npages); 2708 2709 extern bool vma_is_special_mapping(const struct vm_area_struct *vma, 2710 const struct vm_special_mapping *sm); 2711 extern struct vm_area_struct *_install_special_mapping(struct mm_struct *mm, 2712 unsigned long addr, unsigned long len, 2713 unsigned long flags, 2714 const struct vm_special_mapping *spec); 2715 /* This is an obsolete alternative to _install_special_mapping. */ 2716 extern int install_special_mapping(struct mm_struct *mm, 2717 unsigned long addr, unsigned long len, 2718 unsigned long flags, struct page **pages); 2719 2720 unsigned long randomize_stack_top(unsigned long stack_top); 2721 unsigned long randomize_page(unsigned long start, unsigned long range); 2722 2723 extern unsigned long get_unmapped_area(struct file *, unsigned long, unsigned long, unsigned long, unsigned long); 2724 2725 extern unsigned long mmap_region(struct file *file, unsigned long addr, 2726 unsigned long len, vm_flags_t vm_flags, unsigned long pgoff, 2727 struct list_head *uf); 2728 extern unsigned long do_mmap(struct file *file, unsigned long addr, 2729 unsigned long len, unsigned long prot, unsigned long flags, 2730 unsigned long pgoff, unsigned long *populate, struct list_head *uf); 2731 extern int do_mas_munmap(struct ma_state *mas, struct mm_struct *mm, 2732 unsigned long start, size_t len, struct list_head *uf, 2733 bool downgrade); 2734 extern int do_munmap(struct mm_struct *, unsigned long, size_t, 2735 struct list_head *uf); 2736 extern int do_madvise(struct mm_struct *mm, unsigned long start, size_t len_in, int behavior); 2737 2738 #ifdef CONFIG_MMU 2739 extern int __mm_populate(unsigned long addr, unsigned long len, 2740 int ignore_errors); 2741 static inline void mm_populate(unsigned long addr, unsigned long len) 2742 { 2743 /* Ignore errors */ 2744 (void) __mm_populate(addr, len, 1); 2745 } 2746 #else 2747 static inline void mm_populate(unsigned long addr, unsigned long len) {} 2748 #endif 2749 2750 /* These take the mm semaphore themselves */ 2751 extern int __must_check vm_brk(unsigned long, unsigned long); 2752 extern int __must_check vm_brk_flags(unsigned long, unsigned long, unsigned long); 2753 extern int vm_munmap(unsigned long, size_t); 2754 extern unsigned long __must_check vm_mmap(struct file *, unsigned long, 2755 unsigned long, unsigned long, 2756 unsigned long, unsigned long); 2757 2758 struct vm_unmapped_area_info { 2759 #define VM_UNMAPPED_AREA_TOPDOWN 1 2760 unsigned long flags; 2761 unsigned long length; 2762 unsigned long low_limit; 2763 unsigned long high_limit; 2764 unsigned long align_mask; 2765 unsigned long align_offset; 2766 }; 2767 2768 extern unsigned long vm_unmapped_area(struct vm_unmapped_area_info *info); 2769 2770 /* truncate.c */ 2771 extern void truncate_inode_pages(struct address_space *, loff_t); 2772 extern void truncate_inode_pages_range(struct address_space *, 2773 loff_t lstart, loff_t lend); 2774 extern void truncate_inode_pages_final(struct address_space *); 2775 2776 /* generic vm_area_ops exported for stackable file systems */ 2777 extern vm_fault_t filemap_fault(struct vm_fault *vmf); 2778 extern vm_fault_t filemap_map_pages(struct vm_fault *vmf, 2779 pgoff_t start_pgoff, pgoff_t end_pgoff); 2780 extern vm_fault_t filemap_page_mkwrite(struct vm_fault *vmf); 2781 2782 extern unsigned long stack_guard_gap; 2783 /* Generic expand stack which grows the stack according to GROWS{UP,DOWN} */ 2784 extern int expand_stack(struct vm_area_struct *vma, unsigned long address); 2785 2786 /* CONFIG_STACK_GROWSUP still needs to grow downwards at some places */ 2787 extern int expand_downwards(struct vm_area_struct *vma, 2788 unsigned long address); 2789 #if VM_GROWSUP 2790 extern int expand_upwards(struct vm_area_struct *vma, unsigned long address); 2791 #else 2792 #define expand_upwards(vma, address) (0) 2793 #endif 2794 2795 /* Look up the first VMA which satisfies addr < vm_end, NULL if none. */ 2796 extern struct vm_area_struct * find_vma(struct mm_struct * mm, unsigned long addr); 2797 extern struct vm_area_struct * find_vma_prev(struct mm_struct * mm, unsigned long addr, 2798 struct vm_area_struct **pprev); 2799 2800 /* 2801 * Look up the first VMA which intersects the interval [start_addr, end_addr) 2802 * NULL if none. Assume start_addr < end_addr. 2803 */ 2804 struct vm_area_struct *find_vma_intersection(struct mm_struct *mm, 2805 unsigned long start_addr, unsigned long end_addr); 2806 2807 /** 2808 * vma_lookup() - Find a VMA at a specific address 2809 * @mm: The process address space. 2810 * @addr: The user address. 2811 * 2812 * Return: The vm_area_struct at the given address, %NULL otherwise. 2813 */ 2814 static inline 2815 struct vm_area_struct *vma_lookup(struct mm_struct *mm, unsigned long addr) 2816 { 2817 return mtree_load(&mm->mm_mt, addr); 2818 } 2819 2820 static inline unsigned long vm_start_gap(struct vm_area_struct *vma) 2821 { 2822 unsigned long vm_start = vma->vm_start; 2823 2824 if (vma->vm_flags & VM_GROWSDOWN) { 2825 vm_start -= stack_guard_gap; 2826 if (vm_start > vma->vm_start) 2827 vm_start = 0; 2828 } 2829 return vm_start; 2830 } 2831 2832 static inline unsigned long vm_end_gap(struct vm_area_struct *vma) 2833 { 2834 unsigned long vm_end = vma->vm_end; 2835 2836 if (vma->vm_flags & VM_GROWSUP) { 2837 vm_end += stack_guard_gap; 2838 if (vm_end < vma->vm_end) 2839 vm_end = -PAGE_SIZE; 2840 } 2841 return vm_end; 2842 } 2843 2844 static inline unsigned long vma_pages(struct vm_area_struct *vma) 2845 { 2846 return (vma->vm_end - vma->vm_start) >> PAGE_SHIFT; 2847 } 2848 2849 /* Look up the first VMA which exactly match the interval vm_start ... vm_end */ 2850 static inline struct vm_area_struct *find_exact_vma(struct mm_struct *mm, 2851 unsigned long vm_start, unsigned long vm_end) 2852 { 2853 struct vm_area_struct *vma = vma_lookup(mm, vm_start); 2854 2855 if (vma && (vma->vm_start != vm_start || vma->vm_end != vm_end)) 2856 vma = NULL; 2857 2858 return vma; 2859 } 2860 2861 static inline bool range_in_vma(struct vm_area_struct *vma, 2862 unsigned long start, unsigned long end) 2863 { 2864 return (vma && vma->vm_start <= start && end <= vma->vm_end); 2865 } 2866 2867 #ifdef CONFIG_MMU 2868 pgprot_t vm_get_page_prot(unsigned long vm_flags); 2869 void vma_set_page_prot(struct vm_area_struct *vma); 2870 #else 2871 static inline pgprot_t vm_get_page_prot(unsigned long vm_flags) 2872 { 2873 return __pgprot(0); 2874 } 2875 static inline void vma_set_page_prot(struct vm_area_struct *vma) 2876 { 2877 vma->vm_page_prot = vm_get_page_prot(vma->vm_flags); 2878 } 2879 #endif 2880 2881 void vma_set_file(struct vm_area_struct *vma, struct file *file); 2882 2883 #ifdef CONFIG_NUMA_BALANCING 2884 unsigned long change_prot_numa(struct vm_area_struct *vma, 2885 unsigned long start, unsigned long end); 2886 #endif 2887 2888 struct vm_area_struct *find_extend_vma(struct mm_struct *, unsigned long addr); 2889 int remap_pfn_range(struct vm_area_struct *, unsigned long addr, 2890 unsigned long pfn, unsigned long size, pgprot_t); 2891 int remap_pfn_range_notrack(struct vm_area_struct *vma, unsigned long addr, 2892 unsigned long pfn, unsigned long size, pgprot_t prot); 2893 int vm_insert_page(struct vm_area_struct *, unsigned long addr, struct page *); 2894 int vm_insert_pages(struct vm_area_struct *vma, unsigned long addr, 2895 struct page **pages, unsigned long *num); 2896 int vm_map_pages(struct vm_area_struct *vma, struct page **pages, 2897 unsigned long num); 2898 int vm_map_pages_zero(struct vm_area_struct *vma, struct page **pages, 2899 unsigned long num); 2900 vm_fault_t vmf_insert_pfn(struct vm_area_struct *vma, unsigned long addr, 2901 unsigned long pfn); 2902 vm_fault_t vmf_insert_pfn_prot(struct vm_area_struct *vma, unsigned long addr, 2903 unsigned long pfn, pgprot_t pgprot); 2904 vm_fault_t vmf_insert_mixed(struct vm_area_struct *vma, unsigned long addr, 2905 pfn_t pfn); 2906 vm_fault_t vmf_insert_mixed_prot(struct vm_area_struct *vma, unsigned long addr, 2907 pfn_t pfn, pgprot_t pgprot); 2908 vm_fault_t vmf_insert_mixed_mkwrite(struct vm_area_struct *vma, 2909 unsigned long addr, pfn_t pfn); 2910 int vm_iomap_memory(struct vm_area_struct *vma, phys_addr_t start, unsigned long len); 2911 2912 static inline vm_fault_t vmf_insert_page(struct vm_area_struct *vma, 2913 unsigned long addr, struct page *page) 2914 { 2915 int err = vm_insert_page(vma, addr, page); 2916 2917 if (err == -ENOMEM) 2918 return VM_FAULT_OOM; 2919 if (err < 0 && err != -EBUSY) 2920 return VM_FAULT_SIGBUS; 2921 2922 return VM_FAULT_NOPAGE; 2923 } 2924 2925 #ifndef io_remap_pfn_range 2926 static inline int io_remap_pfn_range(struct vm_area_struct *vma, 2927 unsigned long addr, unsigned long pfn, 2928 unsigned long size, pgprot_t prot) 2929 { 2930 return remap_pfn_range(vma, addr, pfn, size, pgprot_decrypted(prot)); 2931 } 2932 #endif 2933 2934 static inline vm_fault_t vmf_error(int err) 2935 { 2936 if (err == -ENOMEM) 2937 return VM_FAULT_OOM; 2938 return VM_FAULT_SIGBUS; 2939 } 2940 2941 struct page *follow_page(struct vm_area_struct *vma, unsigned long address, 2942 unsigned int foll_flags); 2943 2944 #define FOLL_WRITE 0x01 /* check pte is writable */ 2945 #define FOLL_TOUCH 0x02 /* mark page accessed */ 2946 #define FOLL_GET 0x04 /* do get_page on page */ 2947 #define FOLL_DUMP 0x08 /* give error on hole if it would be zero */ 2948 #define FOLL_FORCE 0x10 /* get_user_pages read/write w/o permission */ 2949 #define FOLL_NOWAIT 0x20 /* if a disk transfer is needed, start the IO 2950 * and return without waiting upon it */ 2951 #define FOLL_NOFAULT 0x80 /* do not fault in pages */ 2952 #define FOLL_HWPOISON 0x100 /* check page is hwpoisoned */ 2953 #define FOLL_MIGRATION 0x400 /* wait for page to replace migration entry */ 2954 #define FOLL_TRIED 0x800 /* a retry, previous pass started an IO */ 2955 #define FOLL_REMOTE 0x2000 /* we are working on non-current tsk/mm */ 2956 #define FOLL_ANON 0x8000 /* don't do file mappings */ 2957 #define FOLL_LONGTERM 0x10000 /* mapping lifetime is indefinite: see below */ 2958 #define FOLL_SPLIT_PMD 0x20000 /* split huge pmd before returning */ 2959 #define FOLL_PIN 0x40000 /* pages must be released via unpin_user_page */ 2960 #define FOLL_FAST_ONLY 0x80000 /* gup_fast: prevent fall-back to slow gup */ 2961 2962 /* 2963 * FOLL_PIN and FOLL_LONGTERM may be used in various combinations with each 2964 * other. Here is what they mean, and how to use them: 2965 * 2966 * FOLL_LONGTERM indicates that the page will be held for an indefinite time 2967 * period _often_ under userspace control. This is in contrast to 2968 * iov_iter_get_pages(), whose usages are transient. 2969 * 2970 * FIXME: For pages which are part of a filesystem, mappings are subject to the 2971 * lifetime enforced by the filesystem and we need guarantees that longterm 2972 * users like RDMA and V4L2 only establish mappings which coordinate usage with 2973 * the filesystem. Ideas for this coordination include revoking the longterm 2974 * pin, delaying writeback, bounce buffer page writeback, etc. As FS DAX was 2975 * added after the problem with filesystems was found FS DAX VMAs are 2976 * specifically failed. Filesystem pages are still subject to bugs and use of 2977 * FOLL_LONGTERM should be avoided on those pages. 2978 * 2979 * FIXME: Also NOTE that FOLL_LONGTERM is not supported in every GUP call. 2980 * Currently only get_user_pages() and get_user_pages_fast() support this flag 2981 * and calls to get_user_pages_[un]locked are specifically not allowed. This 2982 * is due to an incompatibility with the FS DAX check and 2983 * FAULT_FLAG_ALLOW_RETRY. 2984 * 2985 * In the CMA case: long term pins in a CMA region would unnecessarily fragment 2986 * that region. And so, CMA attempts to migrate the page before pinning, when 2987 * FOLL_LONGTERM is specified. 2988 * 2989 * FOLL_PIN indicates that a special kind of tracking (not just page->_refcount, 2990 * but an additional pin counting system) will be invoked. This is intended for 2991 * anything that gets a page reference and then touches page data (for example, 2992 * Direct IO). This lets the filesystem know that some non-file-system entity is 2993 * potentially changing the pages' data. In contrast to FOLL_GET (whose pages 2994 * are released via put_page()), FOLL_PIN pages must be released, ultimately, by 2995 * a call to unpin_user_page(). 2996 * 2997 * FOLL_PIN is similar to FOLL_GET: both of these pin pages. They use different 2998 * and separate refcounting mechanisms, however, and that means that each has 2999 * its own acquire and release mechanisms: 3000 * 3001 * FOLL_GET: get_user_pages*() to acquire, and put_page() to release. 3002 * 3003 * FOLL_PIN: pin_user_pages*() to acquire, and unpin_user_pages to release. 3004 * 3005 * FOLL_PIN and FOLL_GET are mutually exclusive for a given function call. 3006 * (The underlying pages may experience both FOLL_GET-based and FOLL_PIN-based 3007 * calls applied to them, and that's perfectly OK. This is a constraint on the 3008 * callers, not on the pages.) 3009 * 3010 * FOLL_PIN should be set internally by the pin_user_pages*() APIs, never 3011 * directly by the caller. That's in order to help avoid mismatches when 3012 * releasing pages: get_user_pages*() pages must be released via put_page(), 3013 * while pin_user_pages*() pages must be released via unpin_user_page(). 3014 * 3015 * Please see Documentation/core-api/pin_user_pages.rst for more information. 3016 */ 3017 3018 static inline int vm_fault_to_errno(vm_fault_t vm_fault, int foll_flags) 3019 { 3020 if (vm_fault & VM_FAULT_OOM) 3021 return -ENOMEM; 3022 if (vm_fault & (VM_FAULT_HWPOISON | VM_FAULT_HWPOISON_LARGE)) 3023 return (foll_flags & FOLL_HWPOISON) ? -EHWPOISON : -EFAULT; 3024 if (vm_fault & (VM_FAULT_SIGBUS | VM_FAULT_SIGSEGV)) 3025 return -EFAULT; 3026 return 0; 3027 } 3028 3029 /* 3030 * Indicates for which pages that are write-protected in the page table, 3031 * whether GUP has to trigger unsharing via FAULT_FLAG_UNSHARE such that the 3032 * GUP pin will remain consistent with the pages mapped into the page tables 3033 * of the MM. 3034 * 3035 * Temporary unmapping of PageAnonExclusive() pages or clearing of 3036 * PageAnonExclusive() has to protect against concurrent GUP: 3037 * * Ordinary GUP: Using the PT lock 3038 * * GUP-fast and fork(): mm->write_protect_seq 3039 * * GUP-fast and KSM or temporary unmapping (swap, migration): see 3040 * page_try_share_anon_rmap() 3041 * 3042 * Must be called with the (sub)page that's actually referenced via the 3043 * page table entry, which might not necessarily be the head page for a 3044 * PTE-mapped THP. 3045 */ 3046 static inline bool gup_must_unshare(unsigned int flags, struct page *page) 3047 { 3048 /* 3049 * FOLL_WRITE is implicitly handled correctly as the page table entry 3050 * has to be writable -- and if it references (part of) an anonymous 3051 * folio, that part is required to be marked exclusive. 3052 */ 3053 if ((flags & (FOLL_WRITE | FOLL_PIN)) != FOLL_PIN) 3054 return false; 3055 /* 3056 * Note: PageAnon(page) is stable until the page is actually getting 3057 * freed. 3058 */ 3059 if (!PageAnon(page)) 3060 return false; 3061 3062 /* Paired with a memory barrier in page_try_share_anon_rmap(). */ 3063 if (IS_ENABLED(CONFIG_HAVE_FAST_GUP)) 3064 smp_rmb(); 3065 3066 /* 3067 * Note that PageKsm() pages cannot be exclusive, and consequently, 3068 * cannot get pinned. 3069 */ 3070 return !PageAnonExclusive(page); 3071 } 3072 3073 /* 3074 * Indicates whether GUP can follow a PROT_NONE mapped page, or whether 3075 * a (NUMA hinting) fault is required. 3076 */ 3077 static inline bool gup_can_follow_protnone(unsigned int flags) 3078 { 3079 /* 3080 * FOLL_FORCE has to be able to make progress even if the VMA is 3081 * inaccessible. Further, FOLL_FORCE access usually does not represent 3082 * application behaviour and we should avoid triggering NUMA hinting 3083 * faults. 3084 */ 3085 return flags & FOLL_FORCE; 3086 } 3087 3088 typedef int (*pte_fn_t)(pte_t *pte, unsigned long addr, void *data); 3089 extern int apply_to_page_range(struct mm_struct *mm, unsigned long address, 3090 unsigned long size, pte_fn_t fn, void *data); 3091 extern int apply_to_existing_page_range(struct mm_struct *mm, 3092 unsigned long address, unsigned long size, 3093 pte_fn_t fn, void *data); 3094 3095 extern void __init init_mem_debugging_and_hardening(void); 3096 #ifdef CONFIG_PAGE_POISONING 3097 extern void __kernel_poison_pages(struct page *page, int numpages); 3098 extern void __kernel_unpoison_pages(struct page *page, int numpages); 3099 extern bool _page_poisoning_enabled_early; 3100 DECLARE_STATIC_KEY_FALSE(_page_poisoning_enabled); 3101 static inline bool page_poisoning_enabled(void) 3102 { 3103 return _page_poisoning_enabled_early; 3104 } 3105 /* 3106 * For use in fast paths after init_mem_debugging() has run, or when a 3107 * false negative result is not harmful when called too early. 3108 */ 3109 static inline bool page_poisoning_enabled_static(void) 3110 { 3111 return static_branch_unlikely(&_page_poisoning_enabled); 3112 } 3113 static inline void kernel_poison_pages(struct page *page, int numpages) 3114 { 3115 if (page_poisoning_enabled_static()) 3116 __kernel_poison_pages(page, numpages); 3117 } 3118 static inline void kernel_unpoison_pages(struct page *page, int numpages) 3119 { 3120 if (page_poisoning_enabled_static()) 3121 __kernel_unpoison_pages(page, numpages); 3122 } 3123 #else 3124 static inline bool page_poisoning_enabled(void) { return false; } 3125 static inline bool page_poisoning_enabled_static(void) { return false; } 3126 static inline void __kernel_poison_pages(struct page *page, int nunmpages) { } 3127 static inline void kernel_poison_pages(struct page *page, int numpages) { } 3128 static inline void kernel_unpoison_pages(struct page *page, int numpages) { } 3129 #endif 3130 3131 DECLARE_STATIC_KEY_MAYBE(CONFIG_INIT_ON_ALLOC_DEFAULT_ON, init_on_alloc); 3132 static inline bool want_init_on_alloc(gfp_t flags) 3133 { 3134 if (static_branch_maybe(CONFIG_INIT_ON_ALLOC_DEFAULT_ON, 3135 &init_on_alloc)) 3136 return true; 3137 return flags & __GFP_ZERO; 3138 } 3139 3140 DECLARE_STATIC_KEY_MAYBE(CONFIG_INIT_ON_FREE_DEFAULT_ON, init_on_free); 3141 static inline bool want_init_on_free(void) 3142 { 3143 return static_branch_maybe(CONFIG_INIT_ON_FREE_DEFAULT_ON, 3144 &init_on_free); 3145 } 3146 3147 extern bool _debug_pagealloc_enabled_early; 3148 DECLARE_STATIC_KEY_FALSE(_debug_pagealloc_enabled); 3149 3150 static inline bool debug_pagealloc_enabled(void) 3151 { 3152 return IS_ENABLED(CONFIG_DEBUG_PAGEALLOC) && 3153 _debug_pagealloc_enabled_early; 3154 } 3155 3156 /* 3157 * For use in fast paths after init_debug_pagealloc() has run, or when a 3158 * false negative result is not harmful when called too early. 3159 */ 3160 static inline bool debug_pagealloc_enabled_static(void) 3161 { 3162 if (!IS_ENABLED(CONFIG_DEBUG_PAGEALLOC)) 3163 return false; 3164 3165 return static_branch_unlikely(&_debug_pagealloc_enabled); 3166 } 3167 3168 #ifdef CONFIG_DEBUG_PAGEALLOC 3169 /* 3170 * To support DEBUG_PAGEALLOC architecture must ensure that 3171 * __kernel_map_pages() never fails 3172 */ 3173 extern void __kernel_map_pages(struct page *page, int numpages, int enable); 3174 3175 static inline void debug_pagealloc_map_pages(struct page *page, int numpages) 3176 { 3177 if (debug_pagealloc_enabled_static()) 3178 __kernel_map_pages(page, numpages, 1); 3179 } 3180 3181 static inline void debug_pagealloc_unmap_pages(struct page *page, int numpages) 3182 { 3183 if (debug_pagealloc_enabled_static()) 3184 __kernel_map_pages(page, numpages, 0); 3185 } 3186 #else /* CONFIG_DEBUG_PAGEALLOC */ 3187 static inline void debug_pagealloc_map_pages(struct page *page, int numpages) {} 3188 static inline void debug_pagealloc_unmap_pages(struct page *page, int numpages) {} 3189 #endif /* CONFIG_DEBUG_PAGEALLOC */ 3190 3191 #ifdef __HAVE_ARCH_GATE_AREA 3192 extern struct vm_area_struct *get_gate_vma(struct mm_struct *mm); 3193 extern int in_gate_area_no_mm(unsigned long addr); 3194 extern int in_gate_area(struct mm_struct *mm, unsigned long addr); 3195 #else 3196 static inline struct vm_area_struct *get_gate_vma(struct mm_struct *mm) 3197 { 3198 return NULL; 3199 } 3200 static inline int in_gate_area_no_mm(unsigned long addr) { return 0; } 3201 static inline int in_gate_area(struct mm_struct *mm, unsigned long addr) 3202 { 3203 return 0; 3204 } 3205 #endif /* __HAVE_ARCH_GATE_AREA */ 3206 3207 extern bool process_shares_mm(struct task_struct *p, struct mm_struct *mm); 3208 3209 #ifdef CONFIG_SYSCTL 3210 extern int sysctl_drop_caches; 3211 int drop_caches_sysctl_handler(struct ctl_table *, int, void *, size_t *, 3212 loff_t *); 3213 #endif 3214 3215 void drop_slab(void); 3216 3217 #ifndef CONFIG_MMU 3218 #define randomize_va_space 0 3219 #else 3220 extern int randomize_va_space; 3221 #endif 3222 3223 const char * arch_vma_name(struct vm_area_struct *vma); 3224 #ifdef CONFIG_MMU 3225 void print_vma_addr(char *prefix, unsigned long rip); 3226 #else 3227 static inline void print_vma_addr(char *prefix, unsigned long rip) 3228 { 3229 } 3230 #endif 3231 3232 void *sparse_buffer_alloc(unsigned long size); 3233 struct page * __populate_section_memmap(unsigned long pfn, 3234 unsigned long nr_pages, int nid, struct vmem_altmap *altmap, 3235 struct dev_pagemap *pgmap); 3236 pgd_t *vmemmap_pgd_populate(unsigned long addr, int node); 3237 p4d_t *vmemmap_p4d_populate(pgd_t *pgd, unsigned long addr, int node); 3238 pud_t *vmemmap_pud_populate(p4d_t *p4d, unsigned long addr, int node); 3239 pmd_t *vmemmap_pmd_populate(pud_t *pud, unsigned long addr, int node); 3240 pte_t *vmemmap_pte_populate(pmd_t *pmd, unsigned long addr, int node, 3241 struct vmem_altmap *altmap, struct page *reuse); 3242 void *vmemmap_alloc_block(unsigned long size, int node); 3243 struct vmem_altmap; 3244 void *vmemmap_alloc_block_buf(unsigned long size, int node, 3245 struct vmem_altmap *altmap); 3246 void vmemmap_verify(pte_t *, int, unsigned long, unsigned long); 3247 int vmemmap_populate_basepages(unsigned long start, unsigned long end, 3248 int node, struct vmem_altmap *altmap); 3249 int vmemmap_populate(unsigned long start, unsigned long end, int node, 3250 struct vmem_altmap *altmap); 3251 void vmemmap_populate_print_last(void); 3252 #ifdef CONFIG_MEMORY_HOTPLUG 3253 void vmemmap_free(unsigned long start, unsigned long end, 3254 struct vmem_altmap *altmap); 3255 #endif 3256 void register_page_bootmem_memmap(unsigned long section_nr, struct page *map, 3257 unsigned long nr_pages); 3258 3259 enum mf_flags { 3260 MF_COUNT_INCREASED = 1 << 0, 3261 MF_ACTION_REQUIRED = 1 << 1, 3262 MF_MUST_KILL = 1 << 2, 3263 MF_SOFT_OFFLINE = 1 << 3, 3264 MF_UNPOISON = 1 << 4, 3265 MF_SW_SIMULATED = 1 << 5, 3266 MF_NO_RETRY = 1 << 6, 3267 }; 3268 int mf_dax_kill_procs(struct address_space *mapping, pgoff_t index, 3269 unsigned long count, int mf_flags); 3270 extern int memory_failure(unsigned long pfn, int flags); 3271 extern void memory_failure_queue(unsigned long pfn, int flags); 3272 extern void memory_failure_queue_kick(int cpu); 3273 extern int unpoison_memory(unsigned long pfn); 3274 extern int sysctl_memory_failure_early_kill; 3275 extern int sysctl_memory_failure_recovery; 3276 extern void shake_page(struct page *p); 3277 extern atomic_long_t num_poisoned_pages __read_mostly; 3278 extern int soft_offline_page(unsigned long pfn, int flags); 3279 #ifdef CONFIG_MEMORY_FAILURE 3280 extern int __get_huge_page_for_hwpoison(unsigned long pfn, int flags); 3281 #else 3282 static inline int __get_huge_page_for_hwpoison(unsigned long pfn, int flags) 3283 { 3284 return 0; 3285 } 3286 #endif 3287 3288 #ifndef arch_memory_failure 3289 static inline int arch_memory_failure(unsigned long pfn, int flags) 3290 { 3291 return -ENXIO; 3292 } 3293 #endif 3294 3295 #ifndef arch_is_platform_page 3296 static inline bool arch_is_platform_page(u64 paddr) 3297 { 3298 return false; 3299 } 3300 #endif 3301 3302 /* 3303 * Error handlers for various types of pages. 3304 */ 3305 enum mf_result { 3306 MF_IGNORED, /* Error: cannot be handled */ 3307 MF_FAILED, /* Error: handling failed */ 3308 MF_DELAYED, /* Will be handled later */ 3309 MF_RECOVERED, /* Successfully recovered */ 3310 }; 3311 3312 enum mf_action_page_type { 3313 MF_MSG_KERNEL, 3314 MF_MSG_KERNEL_HIGH_ORDER, 3315 MF_MSG_SLAB, 3316 MF_MSG_DIFFERENT_COMPOUND, 3317 MF_MSG_HUGE, 3318 MF_MSG_FREE_HUGE, 3319 MF_MSG_UNMAP_FAILED, 3320 MF_MSG_DIRTY_SWAPCACHE, 3321 MF_MSG_CLEAN_SWAPCACHE, 3322 MF_MSG_DIRTY_MLOCKED_LRU, 3323 MF_MSG_CLEAN_MLOCKED_LRU, 3324 MF_MSG_DIRTY_UNEVICTABLE_LRU, 3325 MF_MSG_CLEAN_UNEVICTABLE_LRU, 3326 MF_MSG_DIRTY_LRU, 3327 MF_MSG_CLEAN_LRU, 3328 MF_MSG_TRUNCATED_LRU, 3329 MF_MSG_BUDDY, 3330 MF_MSG_DAX, 3331 MF_MSG_UNSPLIT_THP, 3332 MF_MSG_UNKNOWN, 3333 }; 3334 3335 #if defined(CONFIG_TRANSPARENT_HUGEPAGE) || defined(CONFIG_HUGETLBFS) 3336 extern void clear_huge_page(struct page *page, 3337 unsigned long addr_hint, 3338 unsigned int pages_per_huge_page); 3339 extern void copy_user_huge_page(struct page *dst, struct page *src, 3340 unsigned long addr_hint, 3341 struct vm_area_struct *vma, 3342 unsigned int pages_per_huge_page); 3343 extern long copy_huge_page_from_user(struct page *dst_page, 3344 const void __user *usr_src, 3345 unsigned int pages_per_huge_page, 3346 bool allow_pagefault); 3347 3348 /** 3349 * vma_is_special_huge - Are transhuge page-table entries considered special? 3350 * @vma: Pointer to the struct vm_area_struct to consider 3351 * 3352 * Whether transhuge page-table entries are considered "special" following 3353 * the definition in vm_normal_page(). 3354 * 3355 * Return: true if transhuge page-table entries should be considered special, 3356 * false otherwise. 3357 */ 3358 static inline bool vma_is_special_huge(const struct vm_area_struct *vma) 3359 { 3360 return vma_is_dax(vma) || (vma->vm_file && 3361 (vma->vm_flags & (VM_PFNMAP | VM_MIXEDMAP))); 3362 } 3363 3364 #endif /* CONFIG_TRANSPARENT_HUGEPAGE || CONFIG_HUGETLBFS */ 3365 3366 #ifdef CONFIG_DEBUG_PAGEALLOC 3367 extern unsigned int _debug_guardpage_minorder; 3368 DECLARE_STATIC_KEY_FALSE(_debug_guardpage_enabled); 3369 3370 static inline unsigned int debug_guardpage_minorder(void) 3371 { 3372 return _debug_guardpage_minorder; 3373 } 3374 3375 static inline bool debug_guardpage_enabled(void) 3376 { 3377 return static_branch_unlikely(&_debug_guardpage_enabled); 3378 } 3379 3380 static inline bool page_is_guard(struct page *page) 3381 { 3382 if (!debug_guardpage_enabled()) 3383 return false; 3384 3385 return PageGuard(page); 3386 } 3387 #else 3388 static inline unsigned int debug_guardpage_minorder(void) { return 0; } 3389 static inline bool debug_guardpage_enabled(void) { return false; } 3390 static inline bool page_is_guard(struct page *page) { return false; } 3391 #endif /* CONFIG_DEBUG_PAGEALLOC */ 3392 3393 #if MAX_NUMNODES > 1 3394 void __init setup_nr_node_ids(void); 3395 #else 3396 static inline void setup_nr_node_ids(void) {} 3397 #endif 3398 3399 extern int memcmp_pages(struct page *page1, struct page *page2); 3400 3401 static inline int pages_identical(struct page *page1, struct page *page2) 3402 { 3403 return !memcmp_pages(page1, page2); 3404 } 3405 3406 #ifdef CONFIG_MAPPING_DIRTY_HELPERS 3407 unsigned long clean_record_shared_mapping_range(struct address_space *mapping, 3408 pgoff_t first_index, pgoff_t nr, 3409 pgoff_t bitmap_pgoff, 3410 unsigned long *bitmap, 3411 pgoff_t *start, 3412 pgoff_t *end); 3413 3414 unsigned long wp_shared_mapping_range(struct address_space *mapping, 3415 pgoff_t first_index, pgoff_t nr); 3416 #endif 3417 3418 extern int sysctl_nr_trim_pages; 3419 3420 #ifdef CONFIG_PRINTK 3421 void mem_dump_obj(void *object); 3422 #else 3423 static inline void mem_dump_obj(void *object) {} 3424 #endif 3425 3426 /** 3427 * seal_check_future_write - Check for F_SEAL_FUTURE_WRITE flag and handle it 3428 * @seals: the seals to check 3429 * @vma: the vma to operate on 3430 * 3431 * Check whether F_SEAL_FUTURE_WRITE is set; if so, do proper check/handling on 3432 * the vma flags. Return 0 if check pass, or <0 for errors. 3433 */ 3434 static inline int seal_check_future_write(int seals, struct vm_area_struct *vma) 3435 { 3436 if (seals & F_SEAL_FUTURE_WRITE) { 3437 /* 3438 * New PROT_WRITE and MAP_SHARED mmaps are not allowed when 3439 * "future write" seal active. 3440 */ 3441 if ((vma->vm_flags & VM_SHARED) && (vma->vm_flags & VM_WRITE)) 3442 return -EPERM; 3443 3444 /* 3445 * Since an F_SEAL_FUTURE_WRITE sealed memfd can be mapped as 3446 * MAP_SHARED and read-only, take care to not allow mprotect to 3447 * revert protections on such mappings. Do this only for shared 3448 * mappings. For private mappings, don't need to mask 3449 * VM_MAYWRITE as we still want them to be COW-writable. 3450 */ 3451 if (vma->vm_flags & VM_SHARED) 3452 vma->vm_flags &= ~(VM_MAYWRITE); 3453 } 3454 3455 return 0; 3456 } 3457 3458 #ifdef CONFIG_ANON_VMA_NAME 3459 int madvise_set_anon_name(struct mm_struct *mm, unsigned long start, 3460 unsigned long len_in, 3461 struct anon_vma_name *anon_name); 3462 #else 3463 static inline int 3464 madvise_set_anon_name(struct mm_struct *mm, unsigned long start, 3465 unsigned long len_in, struct anon_vma_name *anon_name) { 3466 return 0; 3467 } 3468 #endif 3469 3470 /* 3471 * Whether to drop the pte markers, for example, the uffd-wp information for 3472 * file-backed memory. This should only be specified when we will completely 3473 * drop the page in the mm, either by truncation or unmapping of the vma. By 3474 * default, the flag is not set. 3475 */ 3476 #define ZAP_FLAG_DROP_MARKER ((__force zap_flags_t) BIT(0)) 3477 3478 #endif /* _LINUX_MM_H */ 3479