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
   8 /*
   9  * swapcache pages are stored in the swapper_space radix tree.  We want to
  10  * get good packing density in that tree, so the index should be dense in
  11  * the low-order bits.
  12  *
  13  * We arrange the `type' and `offset' fields so that `type' is at the seven
  14  * high-order bits of the swp_entry_t and `offset' is right-aligned in the
  15  * remaining bits.  Although `type' itself needs only five bits, we allow for
  16  * shmem/tmpfs to shift it all up a further two bits: see swp_to_radix_entry().
  17  *
  18  * swp_entry_t's are *never* stored anywhere in their arch-dependent format.
  19  */
  20 #define SWP_TYPE_SHIFT(e)       ((sizeof(e.val) * 8) - \
  21                         (MAX_SWAPFILES_SHIFT + RADIX_TREE_EXCEPTIONAL_SHIFT))
  22 #define SWP_OFFSET_MASK(e)      ((1UL << SWP_TYPE_SHIFT(e)) - 1)
  23
  24 /*
  25  * Store a type+offset into a swp_entry_t in an arch-independent format
  26  */
  27 static inline swp_entry_t swp_entry(unsigned long type, pgoff_t offset)
  28 {
  29         swp_entry_t ret;
  30
  31         ret.val = (type << SWP_TYPE_SHIFT(ret)) |
  32                         (offset & SWP_OFFSET_MASK(ret));
  33         return ret;
  34 }
  35
  36 /*
  37  * Extract the `type' field from a swp_entry_t.  The swp_entry_t is in
  38  * arch-independent format
  39  */
  40 static inline unsigned swp_type(swp_entry_t entry)
  41 {
  42         return (entry.val >> SWP_TYPE_SHIFT(entry));
  43 }
  44
  45 /*
  46  * Extract the `offset' field from a swp_entry_t.  The swp_entry_t is in
  47  * arch-independent format
  48  */
  49 static inline pgoff_t swp_offset(swp_entry_t entry)
  50 {
  51         return entry.val & SWP_OFFSET_MASK(entry);
  52 }
  53
  54 #ifdef CONFIG_MMU
  55 /* check whether a pte points to a swap entry */
  56 static inline int is_swap_pte(pte_t pte)
  57 {
  58         return !pte_none(pte) && !pte_present(pte);
  59 }
  60 #endif
  61
  62 /*
  63  * Convert the arch-dependent pte representation of a swp_entry_t into an
  64  * arch-independent swp_entry_t.
  65  */
  66 static inline swp_entry_t pte_to_swp_entry(pte_t pte)
  67 {
  68         swp_entry_t arch_entry;
  69
  70         if (pte_swp_soft_dirty(pte))
  71                 pte = pte_swp_clear_soft_dirty(pte);
  72         arch_entry = __pte_to_swp_entry(pte);
  73         return swp_entry(__swp_type(arch_entry), __swp_offset(arch_entry));
  74 }
  75
  76 /*
  77  * Convert the arch-independent representation of a swp_entry_t into the
  78  * arch-dependent pte representation.
  79  */
  80 static inline pte_t swp_entry_to_pte(swp_entry_t entry)
  81 {
  82         swp_entry_t arch_entry;
  83
  84         arch_entry = __swp_entry(swp_type(entry), swp_offset(entry));
  85         return __swp_entry_to_pte(arch_entry);
  86 }
  87
  88 static inline swp_entry_t radix_to_swp_entry(void *arg)
  89 {
  90         swp_entry_t entry;
  91
  92         entry.val = (unsigned long)arg >> RADIX_TREE_EXCEPTIONAL_SHIFT;
  93         return entry;
  94 }
  95
  96 static inline void *swp_to_radix_entry(swp_entry_t entry)
  97 {
  98         unsigned long value;
  99
 100         value = entry.val << RADIX_TREE_EXCEPTIONAL_SHIFT;
 101         return (void *)(value | RADIX_TREE_EXCEPTIONAL_ENTRY);
 102 }
 103
 104 #if IS_ENABLED(CONFIG_DEVICE_PRIVATE)
 105 static inline swp_entry_t make_device_private_entry(struct page *page, bool write)
 106 {
 107         return swp_entry(write ? SWP_DEVICE_WRITE : SWP_DEVICE_READ,
 108                          page_to_pfn(page));
 109 }
 110
 111 static inline bool is_device_private_entry(swp_entry_t entry)
 112 {
 113         int type = swp_type(entry);
 114         return type == SWP_DEVICE_READ || type == SWP_DEVICE_WRITE;
 115 }
 116
 117 static inline void make_device_private_entry_read(swp_entry_t *entry)
 118 {
 119         *entry = swp_entry(SWP_DEVICE_READ, swp_offset(*entry));
 120 }
 121
 122 static inline bool is_write_device_private_entry(swp_entry_t entry)
 123 {
 124         return unlikely(swp_type(entry) == SWP_DEVICE_WRITE);
 125 }
 126
 127 static inline unsigned long device_private_entry_to_pfn(swp_entry_t entry)
 128 {
 129         return swp_offset(entry);
 130 }
 131
 132 static inline struct page *device_private_entry_to_page(swp_entry_t entry)
 133 {
 134         return pfn_to_page(swp_offset(entry));
 135 }
 136
 137 int device_private_entry_fault(struct vm_area_struct *vma,
 138                        unsigned long addr,
 139                        swp_entry_t entry,
 140                        unsigned int flags,
 141                        pmd_t *pmdp);
 142 #else /* CONFIG_DEVICE_PRIVATE */
 143 static inline swp_entry_t make_device_private_entry(struct page *page, bool write)
 144 {
 145         return swp_entry(0, 0);
 146 }
 147
 148 static inline void make_device_private_entry_read(swp_entry_t *entry)
 149 {
 150 }
 151
 152 static inline bool is_device_private_entry(swp_entry_t entry)
 153 {
 154         return false;
 155 }
 156
 157 static inline bool is_write_device_private_entry(swp_entry_t entry)
 158 {
 159         return false;
 160 }
 161
 162 static inline unsigned long device_private_entry_to_pfn(swp_entry_t entry)
 163 {
 164         return 0;
 165 }
 166
 167 static inline struct page *device_private_entry_to_page(swp_entry_t entry)
 168 {
 169         return NULL;
 170 }
 171
 172 static inline int device_private_entry_fault(struct vm_area_struct *vma,
 173                                      unsigned long addr,
 174                                      swp_entry_t entry,
 175                                      unsigned int flags,
 176                                      pmd_t *pmdp)
 177 {
 178         return VM_FAULT_SIGBUS;
 179 }
 180 #endif /* CONFIG_DEVICE_PRIVATE */
 181
 182 #ifdef CONFIG_MIGRATION
 183 static inline swp_entry_t make_migration_entry(struct page *page, int write)
 184 {
 185         BUG_ON(!PageLocked(compound_head(page)));
 186
 187         return swp_entry(write ? SWP_MIGRATION_WRITE : SWP_MIGRATION_READ,
 188                         page_to_pfn(page));
 189 }
 190
 191 static inline int is_migration_entry(swp_entry_t entry)
 192 {
 193         return unlikely(swp_type(entry) == SWP_MIGRATION_READ ||
 194                         swp_type(entry) == SWP_MIGRATION_WRITE);
 195 }
 196
 197 static inline int is_write_migration_entry(swp_entry_t entry)
 198 {
 199         return unlikely(swp_type(entry) == SWP_MIGRATION_WRITE);
 200 }
 201
 202 static inline unsigned long migration_entry_to_pfn(swp_entry_t entry)
 203 {
 204         return swp_offset(entry);
 205 }
 206
 207 static inline struct page *migration_entry_to_page(swp_entry_t entry)
 208 {
 209         struct page *p = pfn_to_page(swp_offset(entry));
 210         /*
 211          * Any use of migration entries may only occur while the
 212          * corresponding page is locked
 213          */
 214         BUG_ON(!PageLocked(compound_head(p)));
 215         return p;
 216 }
 217
 218 static inline void make_migration_entry_read(swp_entry_t *entry)
 219 {
 220         *entry = swp_entry(SWP_MIGRATION_READ, swp_offset(*entry));
 221 }
 222
 223 extern void __migration_entry_wait(struct mm_struct *mm, pte_t *ptep,
 224                                         spinlock_t *ptl);
 225 extern void migration_entry_wait(struct mm_struct *mm, pmd_t *pmd,
 226                                         unsigned long address);
 227 extern void migration_entry_wait_huge(struct vm_area_struct *vma,
 228                 struct mm_struct *mm, pte_t *pte);
 229 #else
 230
 231 #define make_migration_entry(page, write) swp_entry(0, 0)
 232 static inline int is_migration_entry(swp_entry_t swp)
 233 {
 234         return 0;
 235 }
 236
 237 static inline unsigned long migration_entry_to_pfn(swp_entry_t entry)
 238 {
 239         return 0;
 240 }
 241
 242 static inline struct page *migration_entry_to_page(swp_entry_t entry)
 243 {
 244         return NULL;
 245 }
 246
 247 static inline void make_migration_entry_read(swp_entry_t *entryp) { }
 248 static inline void __migration_entry_wait(struct mm_struct *mm, pte_t *ptep,
 249                                         spinlock_t *ptl) { }
 250 static inline void migration_entry_wait(struct mm_struct *mm, pmd_t *pmd,
 251                                          unsigned long address) { }
 252 static inline void migration_entry_wait_huge(struct vm_area_struct *vma,
 253                 struct mm_struct *mm, pte_t *pte) { }
 254 static inline int is_write_migration_entry(swp_entry_t entry)
 255 {
 256         return 0;
 257 }
 258
 259 #endif
 260
 261 struct page_vma_mapped_walk;
 262
 263 #ifdef CONFIG_ARCH_ENABLE_THP_MIGRATION
 264 extern void set_pmd_migration_entry(struct page_vma_mapped_walk *pvmw,
 265                 struct page *page);
 266
 267 extern void remove_migration_pmd(struct page_vma_mapped_walk *pvmw,
 268                 struct page *new);
 269
 270 extern void pmd_migration_entry_wait(struct mm_struct *mm, pmd_t *pmd);
 271
 272 static inline swp_entry_t pmd_to_swp_entry(pmd_t pmd)
 273 {
 274         swp_entry_t arch_entry;
 275
 276         if (pmd_swp_soft_dirty(pmd))
 277                 pmd = pmd_swp_clear_soft_dirty(pmd);
 278         arch_entry = __pmd_to_swp_entry(pmd);
 279         return swp_entry(__swp_type(arch_entry), __swp_offset(arch_entry));
 280 }
 281
 282 static inline pmd_t swp_entry_to_pmd(swp_entry_t entry)
 283 {
 284         swp_entry_t arch_entry;
 285
 286         arch_entry = __swp_entry(swp_type(entry), swp_offset(entry));
 287         return __swp_entry_to_pmd(arch_entry);
 288 }
 289
 290 static inline int is_pmd_migration_entry(pmd_t pmd)
 291 {
 292         return !pmd_present(pmd) && is_migration_entry(pmd_to_swp_entry(pmd));
 293 }
 294 #else
 295 static inline void set_pmd_migration_entry(struct page_vma_mapped_walk *pvmw,
 296                 struct page *page)
 297 {
 298         BUILD_BUG();
 299 }
 300
 301 static inline void remove_migration_pmd(struct page_vma_mapped_walk *pvmw,
 302                 struct page *new)
 303 {
 304         BUILD_BUG();
 305 }
 306
 307 static inline void pmd_migration_entry_wait(struct mm_struct *m, pmd_t *p) { }
 308
 309 static inline swp_entry_t pmd_to_swp_entry(pmd_t pmd)
 310 {
 311         return swp_entry(0, 0);
 312 }
 313
 314 static inline pmd_t swp_entry_to_pmd(swp_entry_t entry)
 315 {
 316         return __pmd(0);
 317 }
 318
 319 static inline int is_pmd_migration_entry(pmd_t pmd)
 320 {
 321         return 0;
 322 }
 323 #endif
 324
 325 #ifdef CONFIG_MEMORY_FAILURE
 326
 327 extern atomic_long_t num_poisoned_pages __read_mostly;
 328
 329 /*
 330  * Support for hardware poisoned pages
 331  */
 332 static inline swp_entry_t make_hwpoison_entry(struct page *page)
 333 {
 334         BUG_ON(!PageLocked(page));
 335         return swp_entry(SWP_HWPOISON, page_to_pfn(page));
 336 }
 337
 338 static inline int is_hwpoison_entry(swp_entry_t entry)
 339 {
 340         return swp_type(entry) == SWP_HWPOISON;
 341 }
 342
 343 static inline bool test_set_page_hwpoison(struct page *page)
 344 {
 345         return TestSetPageHWPoison(page);
 346 }
 347
 348 static inline void num_poisoned_pages_inc(void)
 349 {
 350         atomic_long_inc(&num_poisoned_pages);
 351 }
 352
 353 static inline void num_poisoned_pages_dec(void)
 354 {
 355         atomic_long_dec(&num_poisoned_pages);
 356 }
 357
 358 #else
 359
 360 static inline swp_entry_t make_hwpoison_entry(struct page *page)
 361 {
 362         return swp_entry(0, 0);
 363 }
 364
 365 static inline int is_hwpoison_entry(swp_entry_t swp)
 366 {
 367         return 0;
 368 }
 369
 370 static inline bool test_set_page_hwpoison(struct page *page)
 371 {
 372         return false;
 373 }
 374
 375 static inline void num_poisoned_pages_inc(void)
 376 {
 377 }
 378 #endif
 379
 380 #if defined(CONFIG_MEMORY_FAILURE) || defined(CONFIG_MIGRATION)
 381 static inline int non_swap_entry(swp_entry_t entry)
 382 {
 383         return swp_type(entry) >= MAX_SWAPFILES;
 384 }
 385 #else
 386 static inline int non_swap_entry(swp_entry_t entry)
 387 {
 388         return 0;
 389 }
 390 #endif
 391
 392 #endif /* _LINUX_SWAPOPS_H */