mm/swap.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *  linux/mm/swap.c
   4  *
   5  *  Copyright (C) 1991, 1992, 1993, 1994  Linus Torvalds
   6  */
   7
   8 /*
   9  * This file contains the default values for the operation of the
  10  * Linux VM subsystem. Fine-tuning documentation can be found in
  11  * Documentation/admin-guide/sysctl/vm.rst.
  12  * Started 18.12.91
  13  * Swap aging added 23.2.95, Stephen Tweedie.
  14  * Buffermem limits added 12.3.98, Rik van Riel.
  15  */
  16
  17 #include <linux/mm.h>
  18 #include <linux/sched.h>
  19 #include <linux/kernel_stat.h>
  20 #include <linux/swap.h>
  21 #include <linux/mman.h>
  22 #include <linux/pagemap.h>
  23 #include <linux/pagevec.h>
  24 #include <linux/init.h>
  25 #include <linux/export.h>
  26 #include <linux/mm_inline.h>
  27 #include <linux/percpu_counter.h>
  28 #include <linux/memremap.h>
  29 #include <linux/percpu.h>
  30 #include <linux/cpu.h>
  31 #include <linux/notifier.h>
  32 #include <linux/backing-dev.h>
  33 #include <linux/memcontrol.h>
  34 #include <linux/gfp.h>
  35 #include <linux/uio.h>
  36 #include <linux/hugetlb.h>
  37 #include <linux/page_idle.h>
  38 #include <linux/local_lock.h>
  39 #include <linux/buffer_head.h>
  40
  41 #include "internal.h"
  42
  43 #define CREATE_TRACE_POINTS
  44 #include <trace/events/pagemap.h>
  45
  46 /* How many pages do we try to swap or page in/out together? As a power of 2 */
  47 int page_cluster;
  48 static const int page_cluster_max = 31;
  49
  50 struct cpu_fbatches {
  51         /*
  52          * The following folio batches are grouped together because they are protected
  53          * by disabling preemption (and interrupts remain enabled).
  54          */
  55         local_lock_t lock;
  56         struct folio_batch lru_add;
  57         struct folio_batch lru_deactivate_file;
  58         struct folio_batch lru_deactivate;
  59         struct folio_batch lru_lazyfree;
  60 #ifdef CONFIG_SMP
  61         struct folio_batch lru_activate;
  62 #endif
  63         /* Protecting the following batches which require disabling interrupts */
  64         local_lock_t lock_irq;
  65         struct folio_batch lru_move_tail;
  66 };
  67
  68 static DEFINE_PER_CPU(struct cpu_fbatches, cpu_fbatches) = {
  69         .lock = INIT_LOCAL_LOCK(lock),
  70         .lock_irq = INIT_LOCAL_LOCK(lock_irq),
  71 };
  72
  73 static void __page_cache_release(struct folio *folio, struct lruvec **lruvecp,
  74                 unsigned long *flagsp)
  75 {
  76         if (folio_test_lru(folio)) {
  77                 folio_lruvec_relock_irqsave(folio, lruvecp, flagsp);
  78                 lruvec_del_folio(*lruvecp, folio);
  79                 __folio_clear_lru_flags(folio);
  80         }
  81 }
  82
  83 /*
  84  * This path almost never happens for VM activity - pages are normally freed
  85  * in batches.  But it gets used by networking - and for compound pages.
  86  */
  87 static void page_cache_release(struct folio *folio)
  88 {
  89         struct lruvec *lruvec = NULL;
  90         unsigned long flags;
  91
  92         __page_cache_release(folio, &lruvec, &flags);
  93         if (lruvec)
  94                 unlock_page_lruvec_irqrestore(lruvec, flags);
  95 }
  96
  97 void __folio_put(struct folio *folio)
  98 {
  99         if (unlikely(folio_is_zone_device(folio))) {
 100                 free_zone_device_folio(folio);
 101                 return;
 102         }
 103
 104         if (folio_test_hugetlb(folio)) {
 105                 free_huge_folio(folio);
 106                 return;
 107         }
 108
 109         page_cache_release(folio);
 110         folio_unqueue_deferred_split(folio);
 111         mem_cgroup_uncharge(folio);
 112         free_frozen_pages(&folio->page, folio_order(folio));
 113 }
 114 EXPORT_SYMBOL(__folio_put);
 115
 116 typedef void (*move_fn_t)(struct lruvec *lruvec, struct folio *folio);
 117
 118 static void lru_add(struct lruvec *lruvec, struct folio *folio)
 119 {
 120         int was_unevictable = folio_test_clear_unevictable(folio);
 121         long nr_pages = folio_nr_pages(folio);
 122
 123         VM_BUG_ON_FOLIO(folio_test_lru(folio), folio);
 124
 125         /*
 126          * Is an smp_mb__after_atomic() still required here, before
 127          * folio_evictable() tests the mlocked flag, to rule out the possibility
 128          * of stranding an evictable folio on an unevictable LRU?  I think
 129          * not, because __munlock_folio() only clears the mlocked flag
 130          * while the LRU lock is held.
 131          *
 132          * (That is not true of __page_cache_release(), and not necessarily
 133          * true of folios_put(): but those only clear the mlocked flag after
 134          * folio_put_testzero() has excluded any other users of the folio.)
 135          */
 136         if (folio_evictable(folio)) {
 137                 if (was_unevictable)
 138                         __count_vm_events(UNEVICTABLE_PGRESCUED, nr_pages);
 139         } else {
 140                 folio_clear_active(folio);
 141                 folio_set_unevictable(folio);
 142                 /*
 143                  * folio->mlock_count = !!folio_test_mlocked(folio)?
 144                  * But that leaves __mlock_folio() in doubt whether another
 145                  * actor has already counted the mlock or not.  Err on the
 146                  * safe side, underestimate, let page reclaim fix it, rather
 147                  * than leaving a page on the unevictable LRU indefinitely.
 148                  */
 149                 folio->mlock_count = 0;
 150                 if (!was_unevictable)
 151                         __count_vm_events(UNEVICTABLE_PGCULLED, nr_pages);
 152         }
 153
 154         lruvec_add_folio(lruvec, folio);
 155         trace_mm_lru_insertion(folio);
 156 }
 157
 158 static void folio_batch_move_lru(struct folio_batch *fbatch, move_fn_t move_fn)
 159 {
 160         int i;
 161         struct lruvec *lruvec = NULL;
 162         unsigned long flags = 0;
 163
 164         for (i = 0; i < folio_batch_count(fbatch); i++) {
 165                 struct folio *folio = fbatch->folios[i];
 166
 167                 folio_lruvec_relock_irqsave(folio, &lruvec, &flags);
 168                 move_fn(lruvec, folio);
 169
 170                 folio_set_lru(folio);
 171         }
 172
 173         if (lruvec)
 174                 unlock_page_lruvec_irqrestore(lruvec, flags);
 175         folios_put(fbatch);
 176 }
 177
 178 static void __folio_batch_add_and_move(struct folio_batch __percpu *fbatch,
 179                 struct folio *folio, move_fn_t move_fn,
 180                 bool on_lru, bool disable_irq)
 181 {
 182         unsigned long flags;
 183
 184         if (on_lru && !folio_test_clear_lru(folio))
 185                 return;
 186
 187         folio_get(folio);
 188
 189         if (disable_irq)
 190                 local_lock_irqsave(&cpu_fbatches.lock_irq, flags);
 191         else
 192                 local_lock(&cpu_fbatches.lock);
 193
 194         if (!folio_batch_add(this_cpu_ptr(fbatch), folio) || folio_test_large(folio) ||
 195             lru_cache_disabled())
 196                 folio_batch_move_lru(this_cpu_ptr(fbatch), move_fn);
 197
 198         if (disable_irq)
 199                 local_unlock_irqrestore(&cpu_fbatches.lock_irq, flags);
 200         else
 201                 local_unlock(&cpu_fbatches.lock);
 202 }
 203
 204 #define folio_batch_add_and_move(folio, op, on_lru)                                             \
 205         __folio_batch_add_and_move(                                                             \
 206                 &cpu_fbatches.op,                                                               \
 207                 folio,                                                                          \
 208                 op,                                                                             \
 209                 on_lru,                                                                         \
 210                 offsetof(struct cpu_fbatches, op) >= offsetof(struct cpu_fbatches, lock_irq)    \
 211         )
 212
 213 static void lru_move_tail(struct lruvec *lruvec, struct folio *folio)
 214 {
 215         if (folio_test_unevictable(folio))
 216                 return;
 217
 218         lruvec_del_folio(lruvec, folio);
 219         folio_clear_active(folio);
 220         lruvec_add_folio_tail(lruvec, folio);
 221         __count_vm_events(PGROTATED, folio_nr_pages(folio));
 222 }
 223
 224 /*
 225  * Writeback is about to end against a folio which has been marked for
 226  * immediate reclaim.  If it still appears to be reclaimable, move it
 227  * to the tail of the inactive list.
 228  *
 229  * folio_rotate_reclaimable() must disable IRQs, to prevent nasty races.
 230  */
 231 void folio_rotate_reclaimable(struct folio *folio)
 232 {
 233         if (folio_test_locked(folio) || folio_test_dirty(folio) ||
 234             folio_test_unevictable(folio))
 235                 return;
 236
 237         folio_batch_add_and_move(folio, lru_move_tail, true);
 238 }
 239
 240 void lru_note_cost(struct lruvec *lruvec, bool file,
 241                    unsigned int nr_io, unsigned int nr_rotated)
 242 {
 243         unsigned long cost;
 244
 245         /*
 246          * Reflect the relative cost of incurring IO and spending CPU
 247          * time on rotations. This doesn't attempt to make a precise
 248          * comparison, it just says: if reloads are about comparable
 249          * between the LRU lists, or rotations are overwhelmingly
 250          * different between them, adjust scan balance for CPU work.
 251          */
 252         cost = nr_io * SWAP_CLUSTER_MAX + nr_rotated;
 253
 254         do {
 255                 unsigned long lrusize;
 256
 257                 /*
 258                  * Hold lruvec->lru_lock is safe here, since
 259                  * 1) The pinned lruvec in reclaim, or
 260                  * 2) From a pre-LRU page during refault (which also holds the
 261                  *    rcu lock, so would be safe even if the page was on the LRU
 262                  *    and could move simultaneously to a new lruvec).
 263                  */
 264                 spin_lock_irq(&lruvec->lru_lock);
 265                 /* Record cost event */
 266                 if (file)
 267                         lruvec->file_cost += cost;
 268                 else
 269                         lruvec->anon_cost += cost;
 270
 271                 /*
 272                  * Decay previous events
 273                  *
 274                  * Because workloads change over time (and to avoid
 275                  * overflow) we keep these statistics as a floating
 276                  * average, which ends up weighing recent refaults
 277                  * more than old ones.
 278                  */
 279                 lrusize = lruvec_page_state(lruvec, NR_INACTIVE_ANON) +
 280                           lruvec_page_state(lruvec, NR_ACTIVE_ANON) +
 281                           lruvec_page_state(lruvec, NR_INACTIVE_FILE) +
 282                           lruvec_page_state(lruvec, NR_ACTIVE_FILE);
 283
 284                 if (lruvec->file_cost + lruvec->anon_cost > lrusize / 4) {
 285                         lruvec->file_cost /= 2;
 286                         lruvec->anon_cost /= 2;
 287                 }
 288                 spin_unlock_irq(&lruvec->lru_lock);
 289         } while ((lruvec = parent_lruvec(lruvec)));
 290 }
 291
 292 void lru_note_cost_refault(struct folio *folio)
 293 {
 294         lru_note_cost(folio_lruvec(folio), folio_is_file_lru(folio),
 295                       folio_nr_pages(folio), 0);
 296 }
 297
 298 static void lru_activate(struct lruvec *lruvec, struct folio *folio)
 299 {
 300         long nr_pages = folio_nr_pages(folio);
 301
 302         if (folio_test_active(folio) || folio_test_unevictable(folio))
 303                 return;
 304
 305
 306         lruvec_del_folio(lruvec, folio);
 307         folio_set_active(folio);
 308         lruvec_add_folio(lruvec, folio);
 309         trace_mm_lru_activate(folio);
 310
 311         __count_vm_events(PGACTIVATE, nr_pages);
 312         count_memcg_events(lruvec_memcg(lruvec), PGACTIVATE, nr_pages);
 313 }
 314
 315 #ifdef CONFIG_SMP
 316 static void folio_activate_drain(int cpu)
 317 {
 318         struct folio_batch *fbatch = &per_cpu(cpu_fbatches.lru_activate, cpu);
 319
 320         if (folio_batch_count(fbatch))
 321                 folio_batch_move_lru(fbatch, lru_activate);
 322 }
 323
 324 void folio_activate(struct folio *folio)
 325 {
 326         if (folio_test_active(folio) || folio_test_unevictable(folio))
 327                 return;
 328
 329         folio_batch_add_and_move(folio, lru_activate, true);
 330 }
 331
 332 #else
 333 static inline void folio_activate_drain(int cpu)
 334 {
 335 }
 336
 337 void folio_activate(struct folio *folio)
 338 {
 339         struct lruvec *lruvec;
 340
 341         if (!folio_test_clear_lru(folio))
 342                 return;
 343
 344         lruvec = folio_lruvec_lock_irq(folio);
 345         lru_activate(lruvec, folio);
 346         unlock_page_lruvec_irq(lruvec);
 347         folio_set_lru(folio);
 348 }
 349 #endif
 350
 351 static void __lru_cache_activate_folio(struct folio *folio)
 352 {
 353         struct folio_batch *fbatch;
 354         int i;
 355
 356         local_lock(&cpu_fbatches.lock);
 357         fbatch = this_cpu_ptr(&cpu_fbatches.lru_add);
 358
 359         /*
 360          * Search backwards on the optimistic assumption that the folio being
 361          * activated has just been added to this batch. Note that only
 362          * the local batch is examined as a !LRU folio could be in the
 363          * process of being released, reclaimed, migrated or on a remote
 364          * batch that is currently being drained. Furthermore, marking
 365          * a remote batch's folio active potentially hits a race where
 366          * a folio is marked active just after it is added to the inactive
 367          * list causing accounting errors and BUG_ON checks to trigger.
 368          */
 369         for (i = folio_batch_count(fbatch) - 1; i >= 0; i--) {
 370                 struct folio *batch_folio = fbatch->folios[i];
 371
 372                 if (batch_folio == folio) {
 373                         folio_set_active(folio);
 374                         break;
 375                 }
 376         }
 377
 378         local_unlock(&cpu_fbatches.lock);
 379 }
 380
 381 #ifdef CONFIG_LRU_GEN
 382
 383 static void lru_gen_inc_refs(struct folio *folio)
 384 {
 385         unsigned long new_flags, old_flags = READ_ONCE(folio->flags);
 386
 387         if (folio_test_unevictable(folio))
 388                 return;
 389
 390         /* see the comment on LRU_REFS_FLAGS */
 391         if (!folio_test_referenced(folio)) {
 392                 set_mask_bits(&folio->flags, LRU_REFS_MASK, BIT(PG_referenced));
 393                 return;
 394         }
 395
 396         do {
 397                 if ((old_flags & LRU_REFS_MASK) == LRU_REFS_MASK) {
 398                         if (!folio_test_workingset(folio))
 399                                 folio_set_workingset(folio);
 400                         return;
 401                 }
 402
 403                 new_flags = old_flags + BIT(LRU_REFS_PGOFF);
 404         } while (!try_cmpxchg(&folio->flags, &old_flags, new_flags));
 405 }
 406
 407 static bool lru_gen_clear_refs(struct folio *folio)
 408 {
 409         struct lru_gen_folio *lrugen;
 410         int gen = folio_lru_gen(folio);
 411         int type = folio_is_file_lru(folio);
 412
 413         if (gen < 0)
 414                 return true;
 415
 416         set_mask_bits(&folio->flags, LRU_REFS_FLAGS | BIT(PG_workingset), 0);
 417
 418         lrugen = &folio_lruvec(folio)->lrugen;
 419         /* whether can do without shuffling under the LRU lock */
 420         return gen == lru_gen_from_seq(READ_ONCE(lrugen->min_seq[type]));
 421 }
 422
 423 #else /* !CONFIG_LRU_GEN */
 424
 425 static void lru_gen_inc_refs(struct folio *folio)
 426 {
 427 }
 428
 429 static bool lru_gen_clear_refs(struct folio *folio)
 430 {
 431         return false;
 432 }
 433
 434 #endif /* CONFIG_LRU_GEN */
 435
 436 /**
 437  * folio_mark_accessed - Mark a folio as having seen activity.
 438  * @folio: The folio to mark.
 439  *
 440  * This function will perform one of the following transitions:
 441  *
 442  * * inactive,unreferenced      ->      inactive,referenced
 443  * * inactive,referenced        ->      active,unreferenced
 444  * * active,unreferenced        ->      active,referenced
 445  *
 446  * When a newly allocated folio is not yet visible, so safe for non-atomic ops,
 447  * __folio_set_referenced() may be substituted for folio_mark_accessed().
 448  */
 449 void folio_mark_accessed(struct folio *folio)
 450 {
 451         if (folio_test_dropbehind(folio))
 452                 return;
 453         if (lru_gen_enabled()) {
 454                 lru_gen_inc_refs(folio);
 455                 return;
 456         }
 457
 458         if (!folio_test_referenced(folio)) {
 459                 folio_set_referenced(folio);
 460         } else if (folio_test_unevictable(folio)) {
 461                 /*
 462                  * Unevictable pages are on the "LRU_UNEVICTABLE" list. But,
 463                  * this list is never rotated or maintained, so marking an
 464                  * unevictable page accessed has no effect.
 465                  */
 466         } else if (!folio_test_active(folio)) {
 467                 /*
 468                  * If the folio is on the LRU, queue it for activation via
 469                  * cpu_fbatches.lru_activate. Otherwise, assume the folio is in a
 470                  * folio_batch, mark it active and it'll be moved to the active
 471                  * LRU on the next drain.
 472                  */
 473                 if (folio_test_lru(folio))
 474                         folio_activate(folio);
 475                 else
 476                         __lru_cache_activate_folio(folio);
 477                 folio_clear_referenced(folio);
 478                 workingset_activation(folio);
 479         }
 480         if (folio_test_idle(folio))
 481                 folio_clear_idle(folio);
 482 }
 483 EXPORT_SYMBOL(folio_mark_accessed);
 484
 485 /**
 486  * folio_add_lru - Add a folio to an LRU list.
 487  * @folio: The folio to be added to the LRU.
 488  *
 489  * Queue the folio for addition to the LRU. The decision on whether
 490  * to add the page to the [in]active [file|anon] list is deferred until the
 491  * folio_batch is drained. This gives a chance for the caller of folio_add_lru()
 492  * have the folio added to the active list using folio_mark_accessed().
 493  */
 494 void folio_add_lru(struct folio *folio)
 495 {
 496         VM_BUG_ON_FOLIO(folio_test_active(folio) &&
 497                         folio_test_unevictable(folio), folio);
 498         VM_BUG_ON_FOLIO(folio_test_lru(folio), folio);
 499
 500         /* see the comment in lru_gen_folio_seq() */
 501         if (lru_gen_enabled() && !folio_test_unevictable(folio) &&
 502             lru_gen_in_fault() && !(current->flags & PF_MEMALLOC))
 503                 folio_set_active(folio);
 504
 505         folio_batch_add_and_move(folio, lru_add, false);
 506 }
 507 EXPORT_SYMBOL(folio_add_lru);
 508
 509 /**
 510  * folio_add_lru_vma() - Add a folio to the appropate LRU list for this VMA.
 511  * @folio: The folio to be added to the LRU.
 512  * @vma: VMA in which the folio is mapped.
 513  *
 514  * If the VMA is mlocked, @folio is added to the unevictable list.
 515  * Otherwise, it is treated the same way as folio_add_lru().
 516  */
 517 void folio_add_lru_vma(struct folio *folio, struct vm_area_struct *vma)
 518 {
 519         VM_BUG_ON_FOLIO(folio_test_lru(folio), folio);
 520
 521         if (unlikely((vma->vm_flags & (VM_LOCKED | VM_SPECIAL)) == VM_LOCKED))
 522                 mlock_new_folio(folio);
 523         else
 524                 folio_add_lru(folio);
 525 }
 526
 527 /*
 528  * If the folio cannot be invalidated, it is moved to the
 529  * inactive list to speed up its reclaim.  It is moved to the
 530  * head of the list, rather than the tail, to give the flusher
 531  * threads some time to write it out, as this is much more
 532  * effective than the single-page writeout from reclaim.
 533  *
 534  * If the folio isn't mapped and dirty/writeback, the folio
 535  * could be reclaimed asap using the reclaim flag.
 536  *
 537  * 1. active, mapped folio -> none
 538  * 2. active, dirty/writeback folio -> inactive, head, reclaim
 539  * 3. inactive, mapped folio -> none
 540  * 4. inactive, dirty/writeback folio -> inactive, head, reclaim
 541  * 5. inactive, clean -> inactive, tail
 542  * 6. Others -> none
 543  *
 544  * In 4, it moves to the head of the inactive list so the folio is
 545  * written out by flusher threads as this is much more efficient
 546  * than the single-page writeout from reclaim.
 547  */
 548 static void lru_deactivate_file(struct lruvec *lruvec, struct folio *folio)
 549 {
 550         bool active = folio_test_active(folio) || lru_gen_enabled();
 551         long nr_pages = folio_nr_pages(folio);
 552
 553         if (folio_test_unevictable(folio))
 554                 return;
 555
 556         /* Some processes are using the folio */
 557         if (folio_mapped(folio))
 558                 return;
 559
 560         lruvec_del_folio(lruvec, folio);
 561         folio_clear_active(folio);
 562         folio_clear_referenced(folio);
 563
 564         if (folio_test_writeback(folio) || folio_test_dirty(folio)) {
 565                 /*
 566                  * Setting the reclaim flag could race with
 567                  * folio_end_writeback() and confuse readahead.  But the
 568                  * race window is _really_ small and  it's not a critical
 569                  * problem.
 570                  */
 571                 lruvec_add_folio(lruvec, folio);
 572                 folio_set_reclaim(folio);
 573         } else {
 574                 /*
 575                  * The folio's writeback ended while it was in the batch.
 576                  * We move that folio to the tail of the inactive list.
 577                  */
 578                 lruvec_add_folio_tail(lruvec, folio);
 579                 __count_vm_events(PGROTATED, nr_pages);
 580         }
 581
 582         if (active) {
 583                 __count_vm_events(PGDEACTIVATE, nr_pages);
 584                 count_memcg_events(lruvec_memcg(lruvec), PGDEACTIVATE,
 585                                      nr_pages);
 586         }
 587 }
 588
 589 static void lru_deactivate(struct lruvec *lruvec, struct folio *folio)
 590 {
 591         long nr_pages = folio_nr_pages(folio);
 592
 593         if (folio_test_unevictable(folio) || !(folio_test_active(folio) || lru_gen_enabled()))
 594                 return;
 595
 596         lruvec_del_folio(lruvec, folio);
 597         folio_clear_active(folio);
 598         folio_clear_referenced(folio);
 599         lruvec_add_folio(lruvec, folio);
 600
 601         __count_vm_events(PGDEACTIVATE, nr_pages);
 602         count_memcg_events(lruvec_memcg(lruvec), PGDEACTIVATE, nr_pages);
 603 }
 604
 605 static void lru_lazyfree(struct lruvec *lruvec, struct folio *folio)
 606 {
 607         long nr_pages = folio_nr_pages(folio);
 608
 609         if (!folio_test_anon(folio) || !folio_test_swapbacked(folio) ||
 610             folio_test_swapcache(folio) || folio_test_unevictable(folio))
 611                 return;
 612
 613         lruvec_del_folio(lruvec, folio);
 614         folio_clear_active(folio);
 615         if (lru_gen_enabled())
 616                 lru_gen_clear_refs(folio);
 617         else
 618                 folio_clear_referenced(folio);
 619         /*
 620          * Lazyfree folios are clean anonymous folios.  They have
 621          * the swapbacked flag cleared, to distinguish them from normal
 622          * anonymous folios
 623          */
 624         folio_clear_swapbacked(folio);
 625         lruvec_add_folio(lruvec, folio);
 626
 627         __count_vm_events(PGLAZYFREE, nr_pages);
 628         count_memcg_events(lruvec_memcg(lruvec), PGLAZYFREE, nr_pages);
 629 }
 630
 631 /*
 632  * Drain pages out of the cpu's folio_batch.
 633  * Either "cpu" is the current CPU, and preemption has already been
 634  * disabled; or "cpu" is being hot-unplugged, and is already dead.
 635  */
 636 void lru_add_drain_cpu(int cpu)
 637 {
 638         struct cpu_fbatches *fbatches = &per_cpu(cpu_fbatches, cpu);
 639         struct folio_batch *fbatch = &fbatches->lru_add;
 640
 641         if (folio_batch_count(fbatch))
 642                 folio_batch_move_lru(fbatch, lru_add);
 643
 644         fbatch = &fbatches->lru_move_tail;
 645         /* Disabling interrupts below acts as a compiler barrier. */
 646         if (data_race(folio_batch_count(fbatch))) {
 647                 unsigned long flags;
 648
 649                 /* No harm done if a racing interrupt already did this */
 650                 local_lock_irqsave(&cpu_fbatches.lock_irq, flags);
 651                 folio_batch_move_lru(fbatch, lru_move_tail);
 652                 local_unlock_irqrestore(&cpu_fbatches.lock_irq, flags);
 653         }
 654
 655         fbatch = &fbatches->lru_deactivate_file;
 656         if (folio_batch_count(fbatch))
 657                 folio_batch_move_lru(fbatch, lru_deactivate_file);
 658
 659         fbatch = &fbatches->lru_deactivate;
 660         if (folio_batch_count(fbatch))
 661                 folio_batch_move_lru(fbatch, lru_deactivate);
 662
 663         fbatch = &fbatches->lru_lazyfree;
 664         if (folio_batch_count(fbatch))
 665                 folio_batch_move_lru(fbatch, lru_lazyfree);
 666
 667         folio_activate_drain(cpu);
 668 }
 669
 670 /**
 671  * deactivate_file_folio() - Deactivate a file folio.
 672  * @folio: Folio to deactivate.
 673  *
 674  * This function hints to the VM that @folio is a good reclaim candidate,
 675  * for example if its invalidation fails due to the folio being dirty
 676  * or under writeback.
 677  *
 678  * Context: Caller holds a reference on the folio.
 679  */
 680 void deactivate_file_folio(struct folio *folio)
 681 {
 682         /* Deactivating an unevictable folio will not accelerate reclaim */
 683         if (folio_test_unevictable(folio))
 684                 return;
 685
 686         if (lru_gen_enabled() && lru_gen_clear_refs(folio))
 687                 return;
 688
 689         folio_batch_add_and_move(folio, lru_deactivate_file, true);
 690 }
 691
 692 /*
 693  * folio_deactivate - deactivate a folio
 694  * @folio: folio to deactivate
 695  *
 696  * folio_deactivate() moves @folio to the inactive list if @folio was on the
 697  * active list and was not unevictable. This is done to accelerate the
 698  * reclaim of @folio.
 699  */
 700 void folio_deactivate(struct folio *folio)
 701 {
 702         if (folio_test_unevictable(folio))
 703                 return;
 704
 705         if (lru_gen_enabled() ? lru_gen_clear_refs(folio) : !folio_test_active(folio))
 706                 return;
 707
 708         folio_batch_add_and_move(folio, lru_deactivate, true);
 709 }
 710
 711 /**
 712  * folio_mark_lazyfree - make an anon folio lazyfree
 713  * @folio: folio to deactivate
 714  *
 715  * folio_mark_lazyfree() moves @folio to the inactive file list.
 716  * This is done to accelerate the reclaim of @folio.
 717  */
 718 void folio_mark_lazyfree(struct folio *folio)
 719 {
 720         if (!folio_test_anon(folio) || !folio_test_swapbacked(folio) ||
 721             folio_test_swapcache(folio) || folio_test_unevictable(folio))
 722                 return;
 723
 724         folio_batch_add_and_move(folio, lru_lazyfree, true);
 725 }
 726
 727 void lru_add_drain(void)
 728 {
 729         local_lock(&cpu_fbatches.lock);
 730         lru_add_drain_cpu(smp_processor_id());
 731         local_unlock(&cpu_fbatches.lock);
 732         mlock_drain_local();
 733 }
 734
 735 /*
 736  * It's called from per-cpu workqueue context in SMP case so
 737  * lru_add_drain_cpu and invalidate_bh_lrus_cpu should run on
 738  * the same cpu. It shouldn't be a problem in !SMP case since
 739  * the core is only one and the locks will disable preemption.
 740  */
 741 static void lru_add_and_bh_lrus_drain(void)
 742 {
 743         local_lock(&cpu_fbatches.lock);
 744         lru_add_drain_cpu(smp_processor_id());
 745         local_unlock(&cpu_fbatches.lock);
 746         invalidate_bh_lrus_cpu();
 747         mlock_drain_local();
 748 }
 749
 750 void lru_add_drain_cpu_zone(struct zone *zone)
 751 {
 752         local_lock(&cpu_fbatches.lock);
 753         lru_add_drain_cpu(smp_processor_id());
 754         drain_local_pages(zone);
 755         local_unlock(&cpu_fbatches.lock);
 756         mlock_drain_local();
 757 }
 758
 759 #ifdef CONFIG_SMP
 760
 761 static DEFINE_PER_CPU(struct work_struct, lru_add_drain_work);
 762
 763 static void lru_add_drain_per_cpu(struct work_struct *dummy)
 764 {
 765         lru_add_and_bh_lrus_drain();
 766 }
 767
 768 static bool cpu_needs_drain(unsigned int cpu)
 769 {
 770         struct cpu_fbatches *fbatches = &per_cpu(cpu_fbatches, cpu);
 771
 772         /* Check these in order of likelihood that they're not zero */
 773         return folio_batch_count(&fbatches->lru_add) ||
 774                 folio_batch_count(&fbatches->lru_move_tail) ||
 775                 folio_batch_count(&fbatches->lru_deactivate_file) ||
 776                 folio_batch_count(&fbatches->lru_deactivate) ||
 777                 folio_batch_count(&fbatches->lru_lazyfree) ||
 778                 folio_batch_count(&fbatches->lru_activate) ||
 779                 need_mlock_drain(cpu) ||
 780                 has_bh_in_lru(cpu, NULL);
 781 }
 782
 783 /*
 784  * Doesn't need any cpu hotplug locking because we do rely on per-cpu
 785  * kworkers being shut down before our page_alloc_cpu_dead callback is
 786  * executed on the offlined cpu.
 787  * Calling this function with cpu hotplug locks held can actually lead
 788  * to obscure indirect dependencies via WQ context.
 789  */
 790 static inline void __lru_add_drain_all(bool force_all_cpus)
 791 {
 792         /*
 793          * lru_drain_gen - Global pages generation number
 794          *
 795          * (A) Definition: global lru_drain_gen = x implies that all generations
 796          *     0 < n <= x are already *scheduled* for draining.
 797          *
 798          * This is an optimization for the highly-contended use case where a
 799          * user space workload keeps constantly generating a flow of pages for
 800          * each CPU.
 801          */
 802         static unsigned int lru_drain_gen;
 803         static struct cpumask has_work;
 804         static DEFINE_MUTEX(lock);
 805         unsigned cpu, this_gen;
 806
 807         /*
 808          * Make sure nobody triggers this path before mm_percpu_wq is fully
 809          * initialized.
 810          */
 811         if (WARN_ON(!mm_percpu_wq))
 812                 return;
 813
 814         /*
 815          * Guarantee folio_batch counter stores visible by this CPU
 816          * are visible to other CPUs before loading the current drain
 817          * generation.
 818          */
 819         smp_mb();
 820
 821         /*
 822          * (B) Locally cache global LRU draining generation number
 823          *
 824          * The read barrier ensures that the counter is loaded before the mutex
 825          * is taken. It pairs with smp_mb() inside the mutex critical section
 826          * at (D).
 827          */
 828         this_gen = smp_load_acquire(&lru_drain_gen);
 829
 830         mutex_lock(&lock);
 831
 832         /*
 833          * (C) Exit the draining operation if a newer generation, from another
 834          * lru_add_drain_all(), was already scheduled for draining. Check (A).
 835          */
 836         if (unlikely(this_gen != lru_drain_gen && !force_all_cpus))
 837                 goto done;
 838
 839         /*
 840          * (D) Increment global generation number
 841          *
 842          * Pairs with smp_load_acquire() at (B), outside of the critical
 843          * section. Use a full memory barrier to guarantee that the
 844          * new global drain generation number is stored before loading
 845          * folio_batch counters.
 846          *
 847          * This pairing must be done here, before the for_each_online_cpu loop
 848          * below which drains the page vectors.
 849          *
 850          * Let x, y, and z represent some system CPU numbers, where x < y < z.
 851          * Assume CPU #z is in the middle of the for_each_online_cpu loop
 852          * below and has already reached CPU #y's per-cpu data. CPU #x comes
 853          * along, adds some pages to its per-cpu vectors, then calls
 854          * lru_add_drain_all().
 855          *
 856          * If the paired barrier is done at any later step, e.g. after the
 857          * loop, CPU #x will just exit at (C) and miss flushing out all of its
 858          * added pages.
 859          */
 860         WRITE_ONCE(lru_drain_gen, lru_drain_gen + 1);
 861         smp_mb();
 862
 863         cpumask_clear(&has_work);
 864         for_each_online_cpu(cpu) {
 865                 struct work_struct *work = &per_cpu(lru_add_drain_work, cpu);
 866
 867                 if (cpu_needs_drain(cpu)) {
 868                         INIT_WORK(work, lru_add_drain_per_cpu);
 869                         queue_work_on(cpu, mm_percpu_wq, work);
 870                         __cpumask_set_cpu(cpu, &has_work);
 871                 }
 872         }
 873
 874         for_each_cpu(cpu, &has_work)
 875                 flush_work(&per_cpu(lru_add_drain_work, cpu));
 876
 877 done:
 878         mutex_unlock(&lock);
 879 }
 880
 881 void lru_add_drain_all(void)
 882 {
 883         __lru_add_drain_all(false);
 884 }
 885 #else
 886 void lru_add_drain_all(void)
 887 {
 888         lru_add_drain();
 889 }
 890 #endif /* CONFIG_SMP */
 891
 892 atomic_t lru_disable_count = ATOMIC_INIT(0);
 893
 894 /*
 895  * lru_cache_disable() needs to be called before we start compiling
 896  * a list of folios to be migrated using folio_isolate_lru().
 897  * It drains folios on LRU cache and then disable on all cpus until
 898  * lru_cache_enable is called.
 899  *
 900  * Must be paired with a call to lru_cache_enable().
 901  */
 902 void lru_cache_disable(void)
 903 {
 904         atomic_inc(&lru_disable_count);
 905         /*
 906          * Readers of lru_disable_count are protected by either disabling
 907          * preemption or rcu_read_lock:
 908          *
 909          * preempt_disable, local_irq_disable  [bh_lru_lock()]
 910          * rcu_read_lock                       [rt_spin_lock CONFIG_PREEMPT_RT]
 911          * preempt_disable                     [local_lock !CONFIG_PREEMPT_RT]
 912          *
 913          * Since v5.1 kernel, synchronize_rcu() is guaranteed to wait on
 914          * preempt_disable() regions of code. So any CPU which sees
 915          * lru_disable_count = 0 will have exited the critical
 916          * section when synchronize_rcu() returns.
 917          */
 918         synchronize_rcu_expedited();
 919 #ifdef CONFIG_SMP
 920         __lru_add_drain_all(true);
 921 #else
 922         lru_add_and_bh_lrus_drain();
 923 #endif
 924 }
 925
 926 /**
 927  * folios_put_refs - Reduce the reference count on a batch of folios.
 928  * @folios: The folios.
 929  * @refs: The number of refs to subtract from each folio.
 930  *
 931  * Like folio_put(), but for a batch of folios.  This is more efficient
 932  * than writing the loop yourself as it will optimise the locks which need
 933  * to be taken if the folios are freed.  The folios batch is returned
 934  * empty and ready to be reused for another batch; there is no need
 935  * to reinitialise it.  If @refs is NULL, we subtract one from each
 936  * folio refcount.
 937  *
 938  * Context: May be called in process or interrupt context, but not in NMI
 939  * context.  May be called while holding a spinlock.
 940  */
 941 void folios_put_refs(struct folio_batch *folios, unsigned int *refs)
 942 {
 943         int i, j;
 944         struct lruvec *lruvec = NULL;
 945         unsigned long flags = 0;
 946
 947         for (i = 0, j = 0; i < folios->nr; i++) {
 948                 struct folio *folio = folios->folios[i];
 949                 unsigned int nr_refs = refs ? refs[i] : 1;
 950
 951                 if (is_huge_zero_folio(folio))
 952                         continue;
 953
 954                 if (folio_is_zone_device(folio)) {
 955                         if (lruvec) {
 956                                 unlock_page_lruvec_irqrestore(lruvec, flags);
 957                                 lruvec = NULL;
 958                         }
 959                         if (folio_ref_sub_and_test(folio, nr_refs))
 960                                 free_zone_device_folio(folio);
 961                         continue;
 962                 }
 963
 964                 if (!folio_ref_sub_and_test(folio, nr_refs))
 965                         continue;
 966
 967                 /* hugetlb has its own memcg */
 968                 if (folio_test_hugetlb(folio)) {
 969                         if (lruvec) {
 970                                 unlock_page_lruvec_irqrestore(lruvec, flags);
 971                                 lruvec = NULL;
 972                         }
 973                         free_huge_folio(folio);
 974                         continue;
 975                 }
 976                 folio_unqueue_deferred_split(folio);
 977                 __page_cache_release(folio, &lruvec, &flags);
 978
 979                 if (j != i)
 980                         folios->folios[j] = folio;
 981                 j++;
 982         }
 983         if (lruvec)
 984                 unlock_page_lruvec_irqrestore(lruvec, flags);
 985         if (!j) {
 986                 folio_batch_reinit(folios);
 987                 return;
 988         }
 989
 990         folios->nr = j;
 991         mem_cgroup_uncharge_folios(folios);
 992         free_unref_folios(folios);
 993 }
 994 EXPORT_SYMBOL(folios_put_refs);
 995
 996 /**
 997  * release_pages - batched put_page()
 998  * @arg: array of pages to release
 999  * @nr: number of pages
1000  *
1001  * Decrement the reference count on all the pages in @arg.  If it
1002  * fell to zero, remove the page from the LRU and free it.
1003  *
1004  * Note that the argument can be an array of pages, encoded pages,
1005  * or folio pointers. We ignore any encoded bits, and turn any of
1006  * them into just a folio that gets free'd.
1007  */
1008 void release_pages(release_pages_arg arg, int nr)
1009 {
1010         struct folio_batch fbatch;
1011         int refs[PAGEVEC_SIZE];
1012         struct encoded_page **encoded = arg.encoded_pages;
1013         int i;
1014
1015         folio_batch_init(&fbatch);
1016         for (i = 0; i < nr; i++) {
1017                 /* Turn any of the argument types into a folio */
1018                 struct folio *folio = page_folio(encoded_page_ptr(encoded[i]));
1019
1020                 /* Is our next entry actually "nr_pages" -> "nr_refs" ? */
1021                 refs[fbatch.nr] = 1;
1022                 if (unlikely(encoded_page_flags(encoded[i]) &
1023                              ENCODED_PAGE_BIT_NR_PAGES_NEXT))
1024                         refs[fbatch.nr] = encoded_nr_pages(encoded[++i]);
1025
1026                 if (folio_batch_add(&fbatch, folio) > 0)
1027                         continue;
1028                 folios_put_refs(&fbatch, refs);
1029         }
1030
1031         if (fbatch.nr)
1032                 folios_put_refs(&fbatch, refs);
1033 }
1034 EXPORT_SYMBOL(release_pages);
1035
1036 /*
1037  * The folios which we're about to release may be in the deferred lru-addition
1038  * queues.  That would prevent them from really being freed right now.  That's
1039  * OK from a correctness point of view but is inefficient - those folios may be
1040  * cache-warm and we want to give them back to the page allocator ASAP.
1041  *
1042  * So __folio_batch_release() will drain those queues here.
1043  * folio_batch_move_lru() calls folios_put() directly to avoid
1044  * mutual recursion.
1045  */
1046 void __folio_batch_release(struct folio_batch *fbatch)
1047 {
1048         if (!fbatch->percpu_pvec_drained) {
1049                 lru_add_drain();
1050                 fbatch->percpu_pvec_drained = true;
1051         }
1052         folios_put(fbatch);
1053 }
1054 EXPORT_SYMBOL(__folio_batch_release);
1055
1056 /**
1057  * folio_batch_remove_exceptionals() - Prune non-folios from a batch.
1058  * @fbatch: The batch to prune
1059  *
1060  * find_get_entries() fills a batch with both folios and shadow/swap/DAX
1061  * entries.  This function prunes all the non-folio entries from @fbatch
1062  * without leaving holes, so that it can be passed on to folio-only batch
1063  * operations.
1064  */
1065 void folio_batch_remove_exceptionals(struct folio_batch *fbatch)
1066 {
1067         unsigned int i, j;
1068
1069         for (i = 0, j = 0; i < folio_batch_count(fbatch); i++) {
1070                 struct folio *folio = fbatch->folios[i];
1071                 if (!xa_is_value(folio))
1072                         fbatch->folios[j++] = folio;
1073         }
1074         fbatch->nr = j;
1075 }
1076
1077 static const struct ctl_table swap_sysctl_table[] = {
1078         {
1079                 .procname       = "page-cluster",
1080                 .data           = &page_cluster,
1081                 .maxlen         = sizeof(int),
1082                 .mode           = 0644,
1083                 .proc_handler   = proc_dointvec_minmax,
1084                 .extra1         = SYSCTL_ZERO,
1085                 .extra2         = (void *)&page_cluster_max,
1086         }
1087 };
1088
1089 /*
1090  * Perform any setup for the swap system
1091  */
1092 void __init swap_setup(void)
1093 {
1094         unsigned long megs = totalram_pages() >> (20 - PAGE_SHIFT);
1095
1096         /* Use a smaller cluster for small-memory machines */
1097         if (megs < 16)
1098                 page_cluster = 2;
1099         else
1100                 page_cluster = 3;
1101         /*
1102          * Right now other parts of the system means that we
1103          * _really_ don't want to cluster much more
1104          */
1105
1106         register_sysctl_init("vm", swap_sysctl_table);
1107 }