include/linux/swapops.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #ifndef _LINUX_SWAPOPS_H
   3 #define _LINUX_SWAPOPS_H
   4
   5 #include <linux/radix-tree.h>
   6 #include <linux/bug.h>
   7 #include <linux/mm_types.h>
   8
   9 #ifdef CONFIG_MMU
  10
  11 #ifdef CONFIG_SWAP
  12 #include <linux/swapfile.h>
  13 #endif  /* CONFIG_SWAP */
  14
  15 /*
  16  * swapcache pages are stored in the swapper_space radix tree.  We want to
  17  * get good packing density in that tree, so the index should be dense in
  18  * the low-order bits.
  19  *
  20  * We arrange the `type' and `offset' fields so that `type' is at the six
  21  * high-order bits of the swp_entry_t and `offset' is right-aligned in the
  22  * remaining bits.  Although `type' itself needs only five bits, we allow for
  23  * shmem/tmpfs to shift it all up a further one bit: see swp_to_radix_entry().
  24  *
  25  * swp_entry_t's are *never* stored anywhere in their arch-dependent format.
  26  */
  27 #define SWP_TYPE_SHIFT  (BITS_PER_XA_VALUE - MAX_SWAPFILES_SHIFT)
  28 #define SWP_OFFSET_MASK ((1UL << SWP_TYPE_SHIFT) - 1)
  29
  30 /*
  31  * Definitions only for PFN swap entries (see is_pfn_swap_entry()).  To
  32  * store PFN, we only need SWP_PFN_BITS bits.  Each of the pfn swap entries
  33  * can use the extra bits to store other information besides PFN.
  34  */
  35 #ifdef MAX_PHYSMEM_BITS
  36 #define SWP_PFN_BITS                    (MAX_PHYSMEM_BITS - PAGE_SHIFT)
  37 #else  /* MAX_PHYSMEM_BITS */
  38 #define SWP_PFN_BITS                    (BITS_PER_LONG - PAGE_SHIFT)
  39 #endif  /* MAX_PHYSMEM_BITS */
  40 #define SWP_PFN_MASK                    (BIT(SWP_PFN_BITS) - 1)
  41
  42 /**
  43  * Migration swap entry specific bitfield definitions.  Layout:
  44  *
  45  *   |----------+--------------------|
  46  *   | swp_type | swp_offset         |
  47  *   |----------+--------+-+-+-------|
  48  *   |          | resv   |D|A|  PFN  |
  49  *   |----------+--------+-+-+-------|
  50  *
  51  * @SWP_MIG_YOUNG_BIT: Whether the page used to have young bit set (bit A)
  52  * @SWP_MIG_DIRTY_BIT: Whether the page used to have dirty bit set (bit D)
  53  *
  54  * Note: A/D bits will be stored in migration entries iff there're enough
  55  * free bits in arch specific swp offset.  By default we'll ignore A/D bits
  56  * when migrating a page.  Please refer to migration_entry_supports_ad()
  57  * for more information.  If there're more bits besides PFN and A/D bits,
  58  * they should be reserved and always be zeros.
  59  */
  60 #define SWP_MIG_YOUNG_BIT               (SWP_PFN_BITS)
  61 #define SWP_MIG_DIRTY_BIT               (SWP_PFN_BITS + 1)
  62 #define SWP_MIG_TOTAL_BITS              (SWP_PFN_BITS + 2)
  63
  64 #define SWP_MIG_YOUNG                   BIT(SWP_MIG_YOUNG_BIT)
  65 #define SWP_MIG_DIRTY                   BIT(SWP_MIG_DIRTY_BIT)
  66
  67 static inline bool is_pfn_swap_entry(swp_entry_t entry);
  68
  69 /* Clear all flags but only keep swp_entry_t related information */
  70 static inline pte_t pte_swp_clear_flags(pte_t pte)
  71 {
  72         if (pte_swp_exclusive(pte))
  73                 pte = pte_swp_clear_exclusive(pte);
  74         if (pte_swp_soft_dirty(pte))
  75                 pte = pte_swp_clear_soft_dirty(pte);
  76         if (pte_swp_uffd_wp(pte))
  77                 pte = pte_swp_clear_uffd_wp(pte);
  78         return pte;
  79 }
  80
  81 /*
  82  * Store a type+offset into a swp_entry_t in an arch-independent format
  83  */
  84 static inline swp_entry_t swp_entry(unsigned long type, pgoff_t offset)
  85 {
  86         swp_entry_t ret;
  87
  88         ret.val = (type << SWP_TYPE_SHIFT) | (offset & SWP_OFFSET_MASK);
  89         return ret;
  90 }
  91
  92 /*
  93  * Extract the `type' field from a swp_entry_t.  The swp_entry_t is in
  94  * arch-independent format
  95  */
  96 static inline unsigned swp_type(swp_entry_t entry)
  97 {
  98         return (entry.val >> SWP_TYPE_SHIFT);
  99 }
 100
 101 /*
 102  * Extract the `offset' field from a swp_entry_t.  The swp_entry_t is in
 103  * arch-independent format
 104  */
 105 static inline pgoff_t swp_offset(swp_entry_t entry)
 106 {
 107         return entry.val & SWP_OFFSET_MASK;
 108 }
 109
 110 /*
 111  * This should only be called upon a pfn swap entry to get the PFN stored
 112  * in the swap entry.  Please refers to is_pfn_swap_entry() for definition
 113  * of pfn swap entry.
 114  */
 115 static inline unsigned long swp_offset_pfn(swp_entry_t entry)
 116 {
 117         VM_BUG_ON(!is_pfn_swap_entry(entry));
 118         return swp_offset(entry) & SWP_PFN_MASK;
 119 }
 120
 121 /* check whether a pte points to a swap entry */
 122 static inline int is_swap_pte(pte_t pte)
 123 {
 124         return !pte_none(pte) && !pte_present(pte);
 125 }
 126
 127 /*
 128  * Convert the arch-dependent pte representation of a swp_entry_t into an
 129  * arch-independent swp_entry_t.
 130  */
 131 static inline swp_entry_t pte_to_swp_entry(pte_t pte)
 132 {
 133         swp_entry_t arch_entry;
 134
 135         pte = pte_swp_clear_flags(pte);
 136         arch_entry = __pte_to_swp_entry(pte);
 137         return swp_entry(__swp_type(arch_entry), __swp_offset(arch_entry));
 138 }
 139
 140 /*
 141  * Convert the arch-independent representation of a swp_entry_t into the
 142  * arch-dependent pte representation.
 143  */
 144 static inline pte_t swp_entry_to_pte(swp_entry_t entry)
 145 {
 146         swp_entry_t arch_entry;
 147
 148         arch_entry = __swp_entry(swp_type(entry), swp_offset(entry));
 149         return __swp_entry_to_pte(arch_entry);
 150 }
 151
 152 static inline swp_entry_t radix_to_swp_entry(void *arg)
 153 {
 154         swp_entry_t entry;
 155
 156         entry.val = xa_to_value(arg);
 157         return entry;
 158 }
 159
 160 static inline void *swp_to_radix_entry(swp_entry_t entry)
 161 {
 162         return xa_mk_value(entry.val);
 163 }
 164
 165 static inline swp_entry_t make_swapin_error_entry(struct page *page)
 166 {
 167         return swp_entry(SWP_SWAPIN_ERROR, page_to_pfn(page));
 168 }
 169
 170 static inline int is_swapin_error_entry(swp_entry_t entry)
 171 {
 172         return swp_type(entry) == SWP_SWAPIN_ERROR;
 173 }
 174
 175 #if IS_ENABLED(CONFIG_DEVICE_PRIVATE)
 176 static inline swp_entry_t make_readable_device_private_entry(pgoff_t offset)
 177 {
 178         return swp_entry(SWP_DEVICE_READ, offset);
 179 }
 180
 181 static inline swp_entry_t make_writable_device_private_entry(pgoff_t offset)
 182 {
 183         return swp_entry(SWP_DEVICE_WRITE, offset);
 184 }
 185
 186 static inline bool is_device_private_entry(swp_entry_t entry)
 187 {
 188         int type = swp_type(entry);
 189         return type == SWP_DEVICE_READ || type == SWP_DEVICE_WRITE;
 190 }
 191
 192 static inline bool is_writable_device_private_entry(swp_entry_t entry)
 193 {
 194         return unlikely(swp_type(entry) == SWP_DEVICE_WRITE);
 195 }
 196
 197 static inline swp_entry_t make_readable_device_exclusive_entry(pgoff_t offset)
 198 {
 199         return swp_entry(SWP_DEVICE_EXCLUSIVE_READ, offset);
 200 }
 201
 202 static inline swp_entry_t make_writable_device_exclusive_entry(pgoff_t offset)
 203 {
 204         return swp_entry(SWP_DEVICE_EXCLUSIVE_WRITE, offset);
 205 }
 206
 207 static inline bool is_device_exclusive_entry(swp_entry_t entry)
 208 {
 209         return swp_type(entry) == SWP_DEVICE_EXCLUSIVE_READ ||
 210                 swp_type(entry) == SWP_DEVICE_EXCLUSIVE_WRITE;
 211 }
 212
 213 static inline bool is_writable_device_exclusive_entry(swp_entry_t entry)
 214 {
 215         return unlikely(swp_type(entry) == SWP_DEVICE_EXCLUSIVE_WRITE);
 216 }
 217 #else /* CONFIG_DEVICE_PRIVATE */
 218 static inline swp_entry_t make_readable_device_private_entry(pgoff_t offset)
 219 {
 220         return swp_entry(0, 0);
 221 }
 222
 223 static inline swp_entry_t make_writable_device_private_entry(pgoff_t offset)
 224 {
 225         return swp_entry(0, 0);
 226 }
 227
 228 static inline bool is_device_private_entry(swp_entry_t entry)
 229 {
 230         return false;
 231 }
 232
 233 static inline bool is_writable_device_private_entry(swp_entry_t entry)
 234 {
 235         return false;
 236 }
 237
 238 static inline swp_entry_t make_readable_device_exclusive_entry(pgoff_t offset)
 239 {
 240         return swp_entry(0, 0);
 241 }
 242
 243 static inline swp_entry_t make_writable_device_exclusive_entry(pgoff_t offset)
 244 {
 245         return swp_entry(0, 0);
 246 }
 247
 248 static inline bool is_device_exclusive_entry(swp_entry_t entry)
 249 {
 250         return false;
 251 }
 252
 253 static inline bool is_writable_device_exclusive_entry(swp_entry_t entry)
 254 {
 255         return false;
 256 }
 257 #endif /* CONFIG_DEVICE_PRIVATE */
 258
 259 #ifdef CONFIG_MIGRATION
 260 static inline int is_migration_entry(swp_entry_t entry)
 261 {
 262         return unlikely(swp_type(entry) == SWP_MIGRATION_READ ||
 263                         swp_type(entry) == SWP_MIGRATION_READ_EXCLUSIVE ||
 264                         swp_type(entry) == SWP_MIGRATION_WRITE);
 265 }
 266
 267 static inline int is_writable_migration_entry(swp_entry_t entry)
 268 {
 269         return unlikely(swp_type(entry) == SWP_MIGRATION_WRITE);
 270 }
 271
 272 static inline int is_readable_migration_entry(swp_entry_t entry)
 273 {
 274         return unlikely(swp_type(entry) == SWP_MIGRATION_READ);
 275 }
 276
 277 static inline int is_readable_exclusive_migration_entry(swp_entry_t entry)
 278 {
 279         return unlikely(swp_type(entry) == SWP_MIGRATION_READ_EXCLUSIVE);
 280 }
 281
 282 static inline swp_entry_t make_readable_migration_entry(pgoff_t offset)
 283 {
 284         return swp_entry(SWP_MIGRATION_READ, offset);
 285 }
 286
 287 static inline swp_entry_t make_readable_exclusive_migration_entry(pgoff_t offset)
 288 {
 289         return swp_entry(SWP_MIGRATION_READ_EXCLUSIVE, offset);
 290 }
 291
 292 static inline swp_entry_t make_writable_migration_entry(pgoff_t offset)
 293 {
 294         return swp_entry(SWP_MIGRATION_WRITE, offset);
 295 }
 296
 297 /*
 298  * Returns whether the host has large enough swap offset field to support
 299  * carrying over pgtable A/D bits for page migrations.  The result is
 300  * pretty much arch specific.
 301  */
 302 static inline bool migration_entry_supports_ad(void)
 303 {
 304 #ifdef CONFIG_SWAP
 305         return swap_migration_ad_supported;
 306 #else  /* CONFIG_SWAP */
 307         return false;
 308 #endif  /* CONFIG_SWAP */
 309 }
 310
 311 static inline swp_entry_t make_migration_entry_young(swp_entry_t entry)
 312 {
 313         if (migration_entry_supports_ad())
 314                 return swp_entry(swp_type(entry),
 315                                  swp_offset(entry) | SWP_MIG_YOUNG);
 316         return entry;
 317 }
 318
 319 static inline bool is_migration_entry_young(swp_entry_t entry)
 320 {
 321         if (migration_entry_supports_ad())
 322                 return swp_offset(entry) & SWP_MIG_YOUNG;
 323         /* Keep the old behavior of aging page after migration */
 324         return false;
 325 }
 326
 327 static inline swp_entry_t make_migration_entry_dirty(swp_entry_t entry)
 328 {
 329         if (migration_entry_supports_ad())
 330                 return swp_entry(swp_type(entry),
 331                                  swp_offset(entry) | SWP_MIG_DIRTY);
 332         return entry;
 333 }
 334
 335 static inline bool is_migration_entry_dirty(swp_entry_t entry)
 336 {
 337         if (migration_entry_supports_ad())
 338                 return swp_offset(entry) & SWP_MIG_DIRTY;
 339         /* Keep the old behavior of clean page after migration */
 340         return false;
 341 }
 342
 343 extern void __migration_entry_wait(struct mm_struct *mm, pte_t *ptep,
 344                                         spinlock_t *ptl);
 345 extern void migration_entry_wait(struct mm_struct *mm, pmd_t *pmd,
 346                                         unsigned long address);
 347 #ifdef CONFIG_HUGETLB_PAGE
 348 extern void __migration_entry_wait_huge(pte_t *ptep, spinlock_t *ptl);
 349 extern void migration_entry_wait_huge(struct vm_area_struct *vma, pte_t *pte);
 350 #endif  /* CONFIG_HUGETLB_PAGE */
 351 #else  /* CONFIG_MIGRATION */
 352 static inline swp_entry_t make_readable_migration_entry(pgoff_t offset)
 353 {
 354         return swp_entry(0, 0);
 355 }
 356
 357 static inline swp_entry_t make_readable_exclusive_migration_entry(pgoff_t offset)
 358 {
 359         return swp_entry(0, 0);
 360 }
 361
 362 static inline swp_entry_t make_writable_migration_entry(pgoff_t offset)
 363 {
 364         return swp_entry(0, 0);
 365 }
 366
 367 static inline int is_migration_entry(swp_entry_t swp)
 368 {
 369         return 0;
 370 }
 371
 372 static inline void __migration_entry_wait(struct mm_struct *mm, pte_t *ptep,
 373                                         spinlock_t *ptl) { }
 374 static inline void migration_entry_wait(struct mm_struct *mm, pmd_t *pmd,
 375                                          unsigned long address) { }
 376 #ifdef CONFIG_HUGETLB_PAGE
 377 static inline void __migration_entry_wait_huge(pte_t *ptep, spinlock_t *ptl) { }
 378 static inline void migration_entry_wait_huge(struct vm_area_struct *vma, pte_t *pte) { }
 379 #endif  /* CONFIG_HUGETLB_PAGE */
 380 static inline int is_writable_migration_entry(swp_entry_t entry)
 381 {
 382         return 0;
 383 }
 384 static inline int is_readable_migration_entry(swp_entry_t entry)
 385 {
 386         return 0;
 387 }
 388
 389 static inline swp_entry_t make_migration_entry_young(swp_entry_t entry)
 390 {
 391         return entry;
 392 }
 393
 394 static inline bool is_migration_entry_young(swp_entry_t entry)
 395 {
 396         return false;
 397 }
 398
 399 static inline swp_entry_t make_migration_entry_dirty(swp_entry_t entry)
 400 {
 401         return entry;
 402 }
 403
 404 static inline bool is_migration_entry_dirty(swp_entry_t entry)
 405 {
 406         return false;
 407 }
 408 #endif  /* CONFIG_MIGRATION */
 409
 410 typedef unsigned long pte_marker;
 411
 412 #define  PTE_MARKER_UFFD_WP  BIT(0)
 413 #define  PTE_MARKER_MASK     (PTE_MARKER_UFFD_WP)
 414
 415 #ifdef CONFIG_PTE_MARKER
 416
 417 static inline swp_entry_t make_pte_marker_entry(pte_marker marker)
 418 {
 419         return swp_entry(SWP_PTE_MARKER, marker);
 420 }
 421
 422 static inline bool is_pte_marker_entry(swp_entry_t entry)
 423 {
 424         return swp_type(entry) == SWP_PTE_MARKER;
 425 }
 426
 427 static inline pte_marker pte_marker_get(swp_entry_t entry)
 428 {
 429         return swp_offset(entry) & PTE_MARKER_MASK;
 430 }
 431
 432 static inline bool is_pte_marker(pte_t pte)
 433 {
 434         return is_swap_pte(pte) && is_pte_marker_entry(pte_to_swp_entry(pte));
 435 }
 436
 437 #else /* CONFIG_PTE_MARKER */
 438
 439 static inline swp_entry_t make_pte_marker_entry(pte_marker marker)
 440 {
 441         /* This should never be called if !CONFIG_PTE_MARKER */
 442         WARN_ON_ONCE(1);
 443         return swp_entry(0, 0);
 444 }
 445
 446 static inline bool is_pte_marker_entry(swp_entry_t entry)
 447 {
 448         return false;
 449 }
 450
 451 static inline pte_marker pte_marker_get(swp_entry_t entry)
 452 {
 453         return 0;
 454 }
 455
 456 static inline bool is_pte_marker(pte_t pte)
 457 {
 458         return false;
 459 }
 460
 461 #endif /* CONFIG_PTE_MARKER */
 462
 463 static inline pte_t make_pte_marker(pte_marker marker)
 464 {
 465         return swp_entry_to_pte(make_pte_marker_entry(marker));
 466 }
 467
 468 /*
 469  * This is a special version to check pte_none() just to cover the case when
 470  * the pte is a pte marker.  It existed because in many cases the pte marker
 471  * should be seen as a none pte; it's just that we have stored some information
 472  * onto the none pte so it becomes not-none any more.
 473  *
 474  * It should be used when the pte is file-backed, ram-based and backing
 475  * userspace pages, like shmem.  It is not needed upon pgtables that do not
 476  * support pte markers at all.  For example, it's not needed on anonymous
 477  * memory, kernel-only memory (including when the system is during-boot),
 478  * non-ram based generic file-system.  It's fine to be used even there, but the
 479  * extra pte marker check will be pure overhead.
 480  *
 481  * For systems configured with !CONFIG_PTE_MARKER this will be automatically
 482  * optimized to pte_none().
 483  */
 484 static inline int pte_none_mostly(pte_t pte)
 485 {
 486         return pte_none(pte) || is_pte_marker(pte);
 487 }
 488
 489 static inline struct page *pfn_swap_entry_to_page(swp_entry_t entry)
 490 {
 491         struct page *p = pfn_to_page(swp_offset_pfn(entry));
 492
 493         /*
 494          * Any use of migration entries may only occur while the
 495          * corresponding page is locked
 496          */
 497         BUG_ON(is_migration_entry(entry) && !PageLocked(p));
 498
 499         return p;
 500 }
 501
 502 /*
 503  * A pfn swap entry is a special type of swap entry that always has a pfn stored
 504  * in the swap offset. They are used to represent unaddressable device memory
 505  * and to restrict access to a page undergoing migration.
 506  */
 507 static inline bool is_pfn_swap_entry(swp_entry_t entry)
 508 {
 509         /* Make sure the swp offset can always store the needed fields */
 510         BUILD_BUG_ON(SWP_TYPE_SHIFT < SWP_PFN_BITS);
 511
 512         return is_migration_entry(entry) || is_device_private_entry(entry) ||
 513                is_device_exclusive_entry(entry);
 514 }
 515
 516 struct page_vma_mapped_walk;
 517
 518 #ifdef CONFIG_ARCH_ENABLE_THP_MIGRATION
 519 extern int set_pmd_migration_entry(struct page_vma_mapped_walk *pvmw,
 520                 struct page *page);
 521
 522 extern void remove_migration_pmd(struct page_vma_mapped_walk *pvmw,
 523                 struct page *new);
 524
 525 extern void pmd_migration_entry_wait(struct mm_struct *mm, pmd_t *pmd);
 526
 527 static inline swp_entry_t pmd_to_swp_entry(pmd_t pmd)
 528 {
 529         swp_entry_t arch_entry;
 530
 531         if (pmd_swp_soft_dirty(pmd))
 532                 pmd = pmd_swp_clear_soft_dirty(pmd);
 533         if (pmd_swp_uffd_wp(pmd))
 534                 pmd = pmd_swp_clear_uffd_wp(pmd);
 535         arch_entry = __pmd_to_swp_entry(pmd);
 536         return swp_entry(__swp_type(arch_entry), __swp_offset(arch_entry));
 537 }
 538
 539 static inline pmd_t swp_entry_to_pmd(swp_entry_t entry)
 540 {
 541         swp_entry_t arch_entry;
 542
 543         arch_entry = __swp_entry(swp_type(entry), swp_offset(entry));
 544         return __swp_entry_to_pmd(arch_entry);
 545 }
 546
 547 static inline int is_pmd_migration_entry(pmd_t pmd)
 548 {
 549         return is_swap_pmd(pmd) && is_migration_entry(pmd_to_swp_entry(pmd));
 550 }
 551 #else  /* CONFIG_ARCH_ENABLE_THP_MIGRATION */
 552 static inline int set_pmd_migration_entry(struct page_vma_mapped_walk *pvmw,
 553                 struct page *page)
 554 {
 555         BUILD_BUG();
 556 }
 557
 558 static inline void remove_migration_pmd(struct page_vma_mapped_walk *pvmw,
 559                 struct page *new)
 560 {
 561         BUILD_BUG();
 562 }
 563
 564 static inline void pmd_migration_entry_wait(struct mm_struct *m, pmd_t *p) { }
 565
 566 static inline swp_entry_t pmd_to_swp_entry(pmd_t pmd)
 567 {
 568         return swp_entry(0, 0);
 569 }
 570
 571 static inline pmd_t swp_entry_to_pmd(swp_entry_t entry)
 572 {
 573         return __pmd(0);
 574 }
 575
 576 static inline int is_pmd_migration_entry(pmd_t pmd)
 577 {
 578         return 0;
 579 }
 580 #endif  /* CONFIG_ARCH_ENABLE_THP_MIGRATION */
 581
 582 #ifdef CONFIG_MEMORY_FAILURE
 583
 584 extern atomic_long_t num_poisoned_pages __read_mostly;
 585
 586 /*
 587  * Support for hardware poisoned pages
 588  */
 589 static inline swp_entry_t make_hwpoison_entry(struct page *page)
 590 {
 591         BUG_ON(!PageLocked(page));
 592         return swp_entry(SWP_HWPOISON, page_to_pfn(page));
 593 }
 594
 595 static inline int is_hwpoison_entry(swp_entry_t entry)
 596 {
 597         return swp_type(entry) == SWP_HWPOISON;
 598 }
 599
 600 static inline void num_poisoned_pages_inc(void)
 601 {
 602         atomic_long_inc(&num_poisoned_pages);
 603 }
 604
 605 static inline void num_poisoned_pages_sub(long i)
 606 {
 607         atomic_long_sub(i, &num_poisoned_pages);
 608 }
 609
 610 #else  /* CONFIG_MEMORY_FAILURE */
 611
 612 static inline swp_entry_t make_hwpoison_entry(struct page *page)
 613 {
 614         return swp_entry(0, 0);
 615 }
 616
 617 static inline int is_hwpoison_entry(swp_entry_t swp)
 618 {
 619         return 0;
 620 }
 621
 622 static inline void num_poisoned_pages_inc(void)
 623 {
 624 }
 625
 626 static inline void num_poisoned_pages_sub(long i)
 627 {
 628 }
 629 #endif  /* CONFIG_MEMORY_FAILURE */
 630
 631 static inline int non_swap_entry(swp_entry_t entry)
 632 {
 633         return swp_type(entry) >= MAX_SWAPFILES;
 634 }
 635
 636 #endif /* CONFIG_MMU */
 637 #endif /* _LINUX_SWAPOPS_H */