LCOV - code coverage report
Current view: top level - mm - swap_state.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 28 367 7.6 %
Date: 2022-04-01 14:58:12 Functions: 4 22 18.2 %
Branches: 8 190 4.2 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  *  linux/mm/swap_state.c
       4                 :            :  *
       5                 :            :  *  Copyright (C) 1991, 1992, 1993, 1994  Linus Torvalds
       6                 :            :  *  Swap reorganised 29.12.95, Stephen Tweedie
       7                 :            :  *
       8                 :            :  *  Rewritten to use page cache, (C) 1998 Stephen Tweedie
       9                 :            :  */
      10                 :            : #include <linux/mm.h>
      11                 :            : #include <linux/gfp.h>
      12                 :            : #include <linux/kernel_stat.h>
      13                 :            : #include <linux/swap.h>
      14                 :            : #include <linux/swapops.h>
      15                 :            : #include <linux/init.h>
      16                 :            : #include <linux/pagemap.h>
      17                 :            : #include <linux/backing-dev.h>
      18                 :            : #include <linux/blkdev.h>
      19                 :            : #include <linux/pagevec.h>
      20                 :            : #include <linux/migrate.h>
      21                 :            : #include <linux/vmalloc.h>
      22                 :            : #include <linux/swap_slots.h>
      23                 :            : #include <linux/huge_mm.h>
      24                 :            : 
      25                 :            : #include <asm/pgtable.h>
      26                 :            : 
      27                 :            : /*
      28                 :            :  * swapper_space is a fiction, retained to simplify the path through
      29                 :            :  * vmscan's shrink_page_list.
      30                 :            :  */
      31                 :            : static const struct address_space_operations swap_aops = {
      32                 :            :         .writepage      = swap_writepage,
      33                 :            :         .set_page_dirty = swap_set_page_dirty,
      34                 :            : #ifdef CONFIG_MIGRATION
      35                 :            :         .migratepage    = migrate_page,
      36                 :            : #endif
      37                 :            : };
      38                 :            : 
      39                 :            : struct address_space *swapper_spaces[MAX_SWAPFILES] __read_mostly;
      40                 :            : static unsigned int nr_swapper_spaces[MAX_SWAPFILES] __read_mostly;
      41                 :            : static bool enable_vma_readahead __read_mostly = true;
      42                 :            : 
      43                 :            : #define SWAP_RA_WIN_SHIFT       (PAGE_SHIFT / 2)
      44                 :            : #define SWAP_RA_HITS_MASK       ((1UL << SWAP_RA_WIN_SHIFT) - 1)
      45                 :            : #define SWAP_RA_HITS_MAX        SWAP_RA_HITS_MASK
      46                 :            : #define SWAP_RA_WIN_MASK        (~PAGE_MASK & ~SWAP_RA_HITS_MASK)
      47                 :            : 
      48                 :            : #define SWAP_RA_HITS(v)         ((v) & SWAP_RA_HITS_MASK)
      49                 :            : #define SWAP_RA_WIN(v)          (((v) & SWAP_RA_WIN_MASK) >> SWAP_RA_WIN_SHIFT)
      50                 :            : #define SWAP_RA_ADDR(v)         ((v) & PAGE_MASK)
      51                 :            : 
      52                 :            : #define SWAP_RA_VAL(addr, win, hits)                            \
      53                 :            :         (((addr) & PAGE_MASK) |                                     \
      54                 :            :          (((win) << SWAP_RA_WIN_SHIFT) & SWAP_RA_WIN_MASK) |  \
      55                 :            :          ((hits) & SWAP_RA_HITS_MASK))
      56                 :            : 
      57                 :            : /* Initial readahead hits is 4 to start up with a small window */
      58                 :            : #define GET_SWAP_RA_VAL(vma)                                    \
      59                 :            :         (atomic_long_read(&(vma)->swap_readahead_info) ? : 4)
      60                 :            : 
      61                 :            : #define INC_CACHE_INFO(x)       do { swap_cache_info.x++; } while (0)
      62                 :            : #define ADD_CACHE_INFO(x, nr)   do { swap_cache_info.x += (nr); } while (0)
      63                 :            : 
      64                 :            : static struct {
      65                 :            :         unsigned long add_total;
      66                 :            :         unsigned long del_total;
      67                 :            :         unsigned long find_success;
      68                 :            :         unsigned long find_total;
      69                 :            : } swap_cache_info;
      70                 :            : 
      71                 :          6 : unsigned long total_swapcache_pages(void)
      72                 :            : {
      73                 :          6 :         unsigned int i, j, nr;
      74                 :          6 :         unsigned long ret = 0;
      75                 :          6 :         struct address_space *spaces;
      76                 :          6 :         struct swap_info_struct *si;
      77                 :            : 
      78         [ +  + ]:        186 :         for (i = 0; i < MAX_SWAPFILES; i++) {
      79                 :        180 :                 swp_entry_t entry = swp_entry(i, 1);
      80                 :            : 
      81                 :            :                 /* Avoid get_swap_device() to warn for bad swap entry */
      82         [ +  - ]:        180 :                 if (!swp_swap_info(entry))
      83                 :        180 :                         continue;
      84                 :            :                 /* Prevent swapoff to free swapper_spaces */
      85                 :          0 :                 si = get_swap_device(entry);
      86         [ #  # ]:          0 :                 if (!si)
      87                 :          0 :                         continue;
      88                 :          0 :                 nr = nr_swapper_spaces[i];
      89                 :          0 :                 spaces = swapper_spaces[i];
      90         [ #  # ]:          0 :                 for (j = 0; j < nr; j++)
      91                 :          0 :                         ret += spaces[j].nrpages;
      92                 :          0 :                 put_swap_device(si);
      93                 :            :         }
      94                 :          6 :         return ret;
      95                 :            : }
      96                 :            : 
      97                 :            : static atomic_t swapin_readahead_hits = ATOMIC_INIT(4);
      98                 :            : 
      99                 :          0 : void show_swap_cache_info(void)
     100                 :            : {
     101                 :          0 :         printk("%lu pages in swap cache\n", total_swapcache_pages());
     102                 :          0 :         printk("Swap cache stats: add %lu, delete %lu, find %lu/%lu\n",
     103                 :            :                 swap_cache_info.add_total, swap_cache_info.del_total,
     104                 :            :                 swap_cache_info.find_success, swap_cache_info.find_total);
     105                 :          0 :         printk("Free swap  = %ldkB\n",
     106                 :            :                 get_nr_swap_pages() << (PAGE_SHIFT - 10));
     107                 :          0 :         printk("Total swap = %lukB\n", total_swap_pages << (PAGE_SHIFT - 10));
     108                 :          0 : }
     109                 :            : 
     110                 :            : /*
     111                 :            :  * add_to_swap_cache resembles add_to_page_cache_locked on swapper_space,
     112                 :            :  * but sets SwapCache flag and private instead of mapping and index.
     113                 :            :  */
     114                 :          0 : int add_to_swap_cache(struct page *page, swp_entry_t entry, gfp_t gfp)
     115                 :            : {
     116                 :          0 :         struct address_space *address_space = swap_address_space(entry);
     117                 :          0 :         pgoff_t idx = swp_offset(entry);
     118                 :          0 :         XA_STATE_ORDER(xas, &address_space->i_pages, idx, compound_order(page));
     119                 :          0 :         unsigned long i, nr = compound_nr(page);
     120                 :            : 
     121                 :          0 :         VM_BUG_ON_PAGE(!PageLocked(page), page);
     122                 :          0 :         VM_BUG_ON_PAGE(PageSwapCache(page), page);
     123                 :          0 :         VM_BUG_ON_PAGE(!PageSwapBacked(page), page);
     124                 :            : 
     125                 :          0 :         page_ref_add(page, nr);
     126         [ #  # ]:          0 :         SetPageSwapCache(page);
     127                 :            : 
     128                 :          0 :         do {
     129                 :          0 :                 xas_lock_irq(&xas);
     130                 :          0 :                 xas_create_range(&xas);
     131   [ #  #  #  # ]:          0 :                 if (xas_error(&xas))
     132                 :          0 :                         goto unlock;
     133         [ #  # ]:          0 :                 for (i = 0; i < nr; i++) {
     134                 :          0 :                         VM_BUG_ON_PAGE(xas.xa_index != idx + i, page);
     135                 :          0 :                         set_page_private(page + i, entry.val + i);
     136                 :          0 :                         xas_store(&xas, page);
     137                 :          0 :                         xas_next(&xas);
     138                 :            :                 }
     139                 :          0 :                 address_space->nrpages += nr;
     140                 :          0 :                 __mod_node_page_state(page_pgdat(page), NR_FILE_PAGES, nr);
     141                 :          0 :                 ADD_CACHE_INFO(add_total, nr);
     142                 :          0 : unlock:
     143                 :          0 :                 xas_unlock_irq(&xas);
     144         [ #  # ]:          0 :         } while (xas_nomem(&xas, gfp));
     145                 :            : 
     146   [ #  #  #  # ]:          0 :         if (!xas_error(&xas))
     147                 :            :                 return 0;
     148                 :            : 
     149         [ #  # ]:          0 :         ClearPageSwapCache(page);
     150                 :          0 :         page_ref_sub(page, nr);
     151         [ #  # ]:          0 :         return xas_error(&xas);
     152                 :            : }
     153                 :            : 
     154                 :            : /*
     155                 :            :  * This must be called only on pages that have
     156                 :            :  * been verified to be in the swap cache.
     157                 :            :  */
     158                 :          0 : void __delete_from_swap_cache(struct page *page, swp_entry_t entry)
     159                 :            : {
     160                 :          0 :         struct address_space *address_space = swap_address_space(entry);
     161                 :          0 :         int i, nr = hpage_nr_pages(page);
     162                 :          0 :         pgoff_t idx = swp_offset(entry);
     163                 :          0 :         XA_STATE(xas, &address_space->i_pages, idx);
     164                 :            : 
     165                 :          0 :         VM_BUG_ON_PAGE(!PageLocked(page), page);
     166                 :          0 :         VM_BUG_ON_PAGE(!PageSwapCache(page), page);
     167                 :          0 :         VM_BUG_ON_PAGE(PageWriteback(page), page);
     168                 :            : 
     169         [ #  # ]:          0 :         for (i = 0; i < nr; i++) {
     170                 :          0 :                 void *entry = xas_store(&xas, NULL);
     171                 :          0 :                 VM_BUG_ON_PAGE(entry != page, entry);
     172                 :          0 :                 set_page_private(page + i, 0);
     173                 :          0 :                 xas_next(&xas);
     174                 :            :         }
     175         [ #  # ]:          0 :         ClearPageSwapCache(page);
     176                 :          0 :         address_space->nrpages -= nr;
     177                 :          0 :         __mod_node_page_state(page_pgdat(page), NR_FILE_PAGES, -nr);
     178                 :          0 :         ADD_CACHE_INFO(del_total, nr);
     179                 :          0 : }
     180                 :            : 
     181                 :            : /**
     182                 :            :  * add_to_swap - allocate swap space for a page
     183                 :            :  * @page: page we want to move to swap
     184                 :            :  *
     185                 :            :  * Allocate swap space for the page and add the page to the
     186                 :            :  * swap cache.  Caller needs to hold the page lock. 
     187                 :            :  */
     188                 :          0 : int add_to_swap(struct page *page)
     189                 :            : {
     190                 :          0 :         swp_entry_t entry;
     191                 :          0 :         int err;
     192                 :            : 
     193                 :          0 :         VM_BUG_ON_PAGE(!PageLocked(page), page);
     194                 :          0 :         VM_BUG_ON_PAGE(!PageUptodate(page), page);
     195                 :            : 
     196                 :          0 :         entry = get_swap_page(page);
     197         [ #  # ]:          0 :         if (!entry.val)
     198                 :            :                 return 0;
     199                 :            : 
     200                 :            :         /*
     201                 :            :          * XArray node allocations from PF_MEMALLOC contexts could
     202                 :            :          * completely exhaust the page allocator. __GFP_NOMEMALLOC
     203                 :            :          * stops emergency reserves from being allocated.
     204                 :            :          *
     205                 :            :          * TODO: this could cause a theoretical memory reclaim
     206                 :            :          * deadlock in the swap out path.
     207                 :            :          */
     208                 :            :         /*
     209                 :            :          * Add it to the swap cache.
     210                 :            :          */
     211                 :          0 :         err = add_to_swap_cache(page, entry,
     212                 :            :                         __GFP_HIGH|__GFP_NOMEMALLOC|__GFP_NOWARN);
     213         [ #  # ]:          0 :         if (err)
     214                 :            :                 /*
     215                 :            :                  * add_to_swap_cache() doesn't return -EEXIST, so we can safely
     216                 :            :                  * clear SWAP_HAS_CACHE flag.
     217                 :            :                  */
     218                 :          0 :                 goto fail;
     219                 :            :         /*
     220                 :            :          * Normally the page will be dirtied in unmap because its pte should be
     221                 :            :          * dirty. A special case is MADV_FREE page. The page'e pte could have
     222                 :            :          * dirty bit cleared but the page's SwapBacked bit is still set because
     223                 :            :          * clearing the dirty bit and SwapBacked bit has no lock protected. For
     224                 :            :          * such page, unmap will not set dirty bit for it, so page reclaim will
     225                 :            :          * not write the page out. This can cause data corruption when the page
     226                 :            :          * is swap in later. Always setting the dirty bit for the page solves
     227                 :            :          * the problem.
     228                 :            :          */
     229                 :          0 :         set_page_dirty(page);
     230                 :            : 
     231                 :          0 :         return 1;
     232                 :            : 
     233                 :            : fail:
     234                 :          0 :         put_swap_page(page, entry);
     235                 :          0 :         return 0;
     236                 :            : }
     237                 :            : 
     238                 :            : /*
     239                 :            :  * This must be called only on pages that have
     240                 :            :  * been verified to be in the swap cache and locked.
     241                 :            :  * It will never put the page into the free list,
     242                 :            :  * the caller has a reference on the page.
     243                 :            :  */
     244                 :          0 : void delete_from_swap_cache(struct page *page)
     245                 :            : {
     246                 :          0 :         swp_entry_t entry = { .val = page_private(page) };
     247                 :          0 :         struct address_space *address_space = swap_address_space(entry);
     248                 :            : 
     249                 :          0 :         xa_lock_irq(&address_space->i_pages);
     250                 :          0 :         __delete_from_swap_cache(page, entry);
     251                 :          0 :         xa_unlock_irq(&address_space->i_pages);
     252                 :            : 
     253                 :          0 :         put_swap_page(page, entry);
     254                 :          0 :         page_ref_sub(page, hpage_nr_pages(page));
     255                 :          0 : }
     256                 :            : 
     257                 :            : /* 
     258                 :            :  * If we are the only user, then try to free up the swap cache. 
     259                 :            :  * 
     260                 :            :  * Its ok to check for PageSwapCache without the page lock
     261                 :            :  * here because we are going to recheck again inside
     262                 :            :  * try_to_free_swap() _with_ the lock.
     263                 :            :  *                                      - Marcelo
     264                 :            :  */
     265                 :    1936220 : static inline void free_swap_cache(struct page *page)
     266                 :            : {
     267   [ -  +  -  -  :    1936220 :         if (PageSwapCache(page) && !page_mapped(page) && trylock_page(page)) {
                   -  - ]
     268                 :          0 :                 try_to_free_swap(page);
     269                 :          0 :                 unlock_page(page);
     270                 :            :         }
     271                 :    1936220 : }
     272                 :            : 
     273                 :            : /* 
     274                 :            :  * Perform a free_page(), also freeing any swap cache associated with
     275                 :            :  * this page if it is the last user of the page.
     276                 :            :  */
     277                 :          0 : void free_page_and_swap_cache(struct page *page)
     278                 :            : {
     279                 :          0 :         free_swap_cache(page);
     280                 :          0 :         if (!is_huge_zero_page(page))
     281                 :          0 :                 put_page(page);
     282                 :          0 : }
     283                 :            : 
     284                 :            : /*
     285                 :            :  * Passed an array of pages, drop them all from swapcache and then release
     286                 :            :  * them.  They are removed from the LRU and freed if this is their last use.
     287                 :            :  */
     288                 :      17376 : void free_pages_and_swap_cache(struct page **pages, int nr)
     289                 :            : {
     290                 :      17376 :         struct page **pagep = pages;
     291                 :      17376 :         int i;
     292                 :            : 
     293                 :      17376 :         lru_add_drain();
     294         [ +  + ]:    1970972 :         for (i = 0; i < nr; i++)
     295                 :    1936220 :                 free_swap_cache(pagep[i]);
     296                 :      17376 :         release_pages(pagep, nr);
     297                 :      17376 : }
     298                 :            : 
     299                 :          0 : static inline bool swap_use_vma_readahead(void)
     300                 :            : {
     301   [ #  #  #  # ]:          0 :         return READ_ONCE(enable_vma_readahead) && !atomic_read(&nr_rotate_swap);
     302                 :            : }
     303                 :            : 
     304                 :            : /*
     305                 :            :  * Lookup a swap entry in the swap cache. A found page will be returned
     306                 :            :  * unlocked and with its refcount incremented - we rely on the kernel
     307                 :            :  * lock getting page table operations atomic even if we drop the page
     308                 :            :  * lock before returning.
     309                 :            :  */
     310                 :          0 : struct page *lookup_swap_cache(swp_entry_t entry, struct vm_area_struct *vma,
     311                 :            :                                unsigned long addr)
     312                 :            : {
     313                 :          0 :         struct page *page;
     314                 :          0 :         struct swap_info_struct *si;
     315                 :            : 
     316                 :          0 :         si = get_swap_device(entry);
     317         [ #  # ]:          0 :         if (!si)
     318                 :            :                 return NULL;
     319                 :          0 :         page = find_get_page(swap_address_space(entry), swp_offset(entry));
     320                 :          0 :         put_swap_device(si);
     321                 :            : 
     322                 :          0 :         INC_CACHE_INFO(find_total);
     323         [ #  # ]:          0 :         if (page) {
     324         [ #  # ]:          0 :                 bool vma_ra = swap_use_vma_readahead();
     325                 :          0 :                 bool readahead;
     326                 :            : 
     327                 :          0 :                 INC_CACHE_INFO(find_success);
     328                 :            :                 /*
     329                 :            :                  * At the moment, we don't support PG_readahead for anon THP
     330                 :            :                  * so let's bail out rather than confusing the readahead stat.
     331                 :            :                  */
     332                 :          0 :                 if (unlikely(PageTransCompound(page)))
     333                 :            :                         return page;
     334                 :            : 
     335                 :          0 :                 readahead = TestClearPageReadahead(page);
     336         [ #  # ]:          0 :                 if (vma && vma_ra) {
     337                 :          0 :                         unsigned long ra_val;
     338                 :          0 :                         int win, hits;
     339                 :            : 
     340         [ #  # ]:          0 :                         ra_val = GET_SWAP_RA_VAL(vma);
     341                 :          0 :                         win = SWAP_RA_WIN(ra_val);
     342                 :          0 :                         hits = SWAP_RA_HITS(ra_val);
     343         [ #  # ]:          0 :                         if (readahead)
     344                 :          0 :                                 hits = min_t(int, hits + 1, SWAP_RA_HITS_MAX);
     345                 :          0 :                         atomic_long_set(&vma->swap_readahead_info,
     346                 :          0 :                                         SWAP_RA_VAL(addr, win, hits));
     347                 :            :                 }
     348                 :            : 
     349         [ #  # ]:          0 :                 if (readahead) {
     350                 :          0 :                         count_vm_event(SWAP_RA_HIT);
     351         [ #  # ]:          0 :                         if (!vma || !vma_ra)
     352                 :          0 :                                 atomic_inc(&swapin_readahead_hits);
     353                 :            :                 }
     354                 :            :         }
     355                 :            : 
     356                 :            :         return page;
     357                 :            : }
     358                 :            : 
     359                 :          0 : struct page *__read_swap_cache_async(swp_entry_t entry, gfp_t gfp_mask,
     360                 :            :                         struct vm_area_struct *vma, unsigned long addr,
     361                 :            :                         bool *new_page_allocated)
     362                 :            : {
     363                 :          0 :         struct page *found_page = NULL, *new_page = NULL;
     364                 :          0 :         struct swap_info_struct *si;
     365                 :          0 :         int err;
     366                 :          0 :         *new_page_allocated = false;
     367                 :            : 
     368                 :          0 :         do {
     369                 :            :                 /*
     370                 :            :                  * First check the swap cache.  Since this is normally
     371                 :            :                  * called after lookup_swap_cache() failed, re-calling
     372                 :            :                  * that would confuse statistics.
     373                 :            :                  */
     374                 :          0 :                 si = get_swap_device(entry);
     375         [ #  # ]:          0 :                 if (!si)
     376                 :            :                         break;
     377                 :          0 :                 found_page = find_get_page(swap_address_space(entry),
     378                 :            :                                            swp_offset(entry));
     379                 :          0 :                 put_swap_device(si);
     380         [ #  # ]:          0 :                 if (found_page)
     381                 :            :                         break;
     382                 :            : 
     383                 :            :                 /*
     384                 :            :                  * Just skip read ahead for unused swap slot.
     385                 :            :                  * During swap_off when swap_slot_cache is disabled,
     386                 :            :                  * we have to handle the race between putting
     387                 :            :                  * swap entry in swap cache and marking swap slot
     388                 :            :                  * as SWAP_HAS_CACHE.  That's done in later part of code or
     389                 :            :                  * else swap_off will be aborted if we return NULL.
     390                 :            :                  */
     391   [ #  #  #  # ]:          0 :                 if (!__swp_swapcount(entry) && swap_slot_cache_enabled)
     392                 :            :                         break;
     393                 :            : 
     394                 :            :                 /*
     395                 :            :                  * Get a new page to read into from swap.
     396                 :            :                  */
     397         [ #  # ]:          0 :                 if (!new_page) {
     398                 :          0 :                         new_page = alloc_page_vma(gfp_mask, vma, addr);
     399         [ #  # ]:          0 :                         if (!new_page)
     400                 :            :                                 break;          /* Out of memory */
     401                 :            :                 }
     402                 :            : 
     403                 :            :                 /*
     404                 :            :                  * Swap entry may have been freed since our caller observed it.
     405                 :            :                  */
     406                 :          0 :                 err = swapcache_prepare(entry);
     407         [ #  # ]:          0 :                 if (err == -EEXIST) {
     408                 :            :                         /*
     409                 :            :                          * We might race against get_swap_page() and stumble
     410                 :            :                          * across a SWAP_HAS_CACHE swap_map entry whose page
     411                 :            :                          * has not been brought into the swapcache yet.
     412                 :            :                          */
     413                 :          0 :                         cond_resched();
     414                 :          0 :                         continue;
     415         [ #  # ]:          0 :                 } else if (err)         /* swp entry is obsolete ? */
     416                 :            :                         break;
     417                 :            : 
     418                 :            :                 /* May fail (-ENOMEM) if XArray node allocation failed. */
     419         [ #  # ]:          0 :                 __SetPageLocked(new_page);
     420         [ #  # ]:          0 :                 __SetPageSwapBacked(new_page);
     421                 :          0 :                 err = add_to_swap_cache(new_page, entry, gfp_mask & GFP_KERNEL);
     422         [ #  # ]:          0 :                 if (likely(!err)) {
     423                 :            :                         /* Initiate read into locked page */
     424         [ #  # ]:          0 :                         SetPageWorkingset(new_page);
     425                 :          0 :                         lru_cache_add_anon(new_page);
     426                 :          0 :                         *new_page_allocated = true;
     427                 :          0 :                         return new_page;
     428                 :            :                 }
     429         [ #  # ]:          0 :                 __ClearPageLocked(new_page);
     430                 :            :                 /*
     431                 :            :                  * add_to_swap_cache() doesn't return -EEXIST, so we can safely
     432                 :            :                  * clear SWAP_HAS_CACHE flag.
     433                 :            :                  */
     434                 :          0 :                 put_swap_page(new_page, entry);
     435         [ #  # ]:          0 :         } while (err != -ENOMEM);
     436                 :            : 
     437         [ #  # ]:          0 :         if (new_page)
     438                 :          0 :                 put_page(new_page);
     439                 :            :         return found_page;
     440                 :            : }
     441                 :            : 
     442                 :            : /*
     443                 :            :  * Locate a page of swap in physical memory, reserving swap cache space
     444                 :            :  * and reading the disk if it is not already cached.
     445                 :            :  * A failure return means that either the page allocation failed or that
     446                 :            :  * the swap entry is no longer in use.
     447                 :            :  */
     448                 :          0 : struct page *read_swap_cache_async(swp_entry_t entry, gfp_t gfp_mask,
     449                 :            :                 struct vm_area_struct *vma, unsigned long addr, bool do_poll)
     450                 :            : {
     451                 :          0 :         bool page_was_allocated;
     452                 :          0 :         struct page *retpage = __read_swap_cache_async(entry, gfp_mask,
     453                 :            :                         vma, addr, &page_was_allocated);
     454                 :            : 
     455         [ #  # ]:          0 :         if (page_was_allocated)
     456                 :          0 :                 swap_readpage(retpage, do_poll);
     457                 :            : 
     458                 :          0 :         return retpage;
     459                 :            : }
     460                 :            : 
     461                 :          0 : static unsigned int __swapin_nr_pages(unsigned long prev_offset,
     462                 :            :                                       unsigned long offset,
     463                 :            :                                       int hits,
     464                 :            :                                       int max_pages,
     465                 :            :                                       int prev_win)
     466                 :            : {
     467                 :          0 :         unsigned int pages, last_ra;
     468                 :            : 
     469                 :            :         /*
     470                 :            :          * This heuristic has been found to work well on both sequential and
     471                 :            :          * random loads, swapping to hard disk or to SSD: please don't ask
     472                 :            :          * what the "+ 2" means, it just happens to work well, that's all.
     473                 :            :          */
     474                 :          0 :         pages = hits + 2;
     475                 :          0 :         if (pages == 2) {
     476                 :            :                 /*
     477                 :            :                  * We can have no readahead hits to judge by: but must not get
     478                 :            :                  * stuck here forever, so check for an adjacent offset instead
     479                 :            :                  * (and don't even bother to check whether swap type is same).
     480                 :            :                  */
     481   [ #  #  #  #  :          0 :                 if (offset != prev_offset + 1 && offset != prev_offset - 1)
             #  #  #  # ]
     482                 :          0 :                         pages = 1;
     483                 :            :         } else {
     484                 :            :                 unsigned int roundup = 4;
     485   [ #  #  #  # ]:          0 :                 while (roundup < pages)
     486                 :          0 :                         roundup <<= 1;
     487                 :            :                 pages = roundup;
     488                 :            :         }
     489                 :            : 
     490                 :          0 :         if (pages > max_pages)
     491                 :            :                 pages = max_pages;
     492                 :            : 
     493                 :            :         /* Don't shrink readahead too fast */
     494                 :          0 :         last_ra = prev_win / 2;
     495                 :          0 :         if (pages < last_ra)
     496                 :            :                 pages = last_ra;
     497                 :            : 
     498                 :          0 :         return pages;
     499                 :            : }
     500                 :            : 
     501                 :          0 : static unsigned long swapin_nr_pages(unsigned long offset)
     502                 :            : {
     503                 :          0 :         static unsigned long prev_offset;
     504                 :          0 :         unsigned int hits, pages, max_pages;
     505                 :          0 :         static atomic_t last_readahead_pages;
     506                 :            : 
     507         [ #  # ]:          0 :         max_pages = 1 << READ_ONCE(page_cluster);
     508         [ #  # ]:          0 :         if (max_pages <= 1)
     509                 :            :                 return 1;
     510                 :            : 
     511                 :          0 :         hits = atomic_xchg(&swapin_readahead_hits, 0);
     512         [ #  # ]:          0 :         pages = __swapin_nr_pages(prev_offset, offset, hits, max_pages,
     513                 :            :                                   atomic_read(&last_readahead_pages));
     514         [ #  # ]:          0 :         if (!hits)
     515                 :          0 :                 prev_offset = offset;
     516                 :          0 :         atomic_set(&last_readahead_pages, pages);
     517                 :            : 
     518                 :          0 :         return pages;
     519                 :            : }
     520                 :            : 
     521                 :            : /**
     522                 :            :  * swap_cluster_readahead - swap in pages in hope we need them soon
     523                 :            :  * @entry: swap entry of this memory
     524                 :            :  * @gfp_mask: memory allocation flags
     525                 :            :  * @vmf: fault information
     526                 :            :  *
     527                 :            :  * Returns the struct page for entry and addr, after queueing swapin.
     528                 :            :  *
     529                 :            :  * Primitive swap readahead code. We simply read an aligned block of
     530                 :            :  * (1 << page_cluster) entries in the swap area. This method is chosen
     531                 :            :  * because it doesn't cost us any seek time.  We also make sure to queue
     532                 :            :  * the 'original' request together with the readahead ones...
     533                 :            :  *
     534                 :            :  * This has been extended to use the NUMA policies from the mm triggering
     535                 :            :  * the readahead.
     536                 :            :  *
     537                 :            :  * Caller must hold read mmap_sem if vmf->vma is not NULL.
     538                 :            :  */
     539                 :          0 : struct page *swap_cluster_readahead(swp_entry_t entry, gfp_t gfp_mask,
     540                 :            :                                 struct vm_fault *vmf)
     541                 :            : {
     542                 :          0 :         struct page *page;
     543                 :          0 :         unsigned long entry_offset = swp_offset(entry);
     544                 :          0 :         unsigned long offset = entry_offset;
     545                 :          0 :         unsigned long start_offset, end_offset;
     546                 :          0 :         unsigned long mask;
     547                 :          0 :         struct swap_info_struct *si = swp_swap_info(entry);
     548                 :          0 :         struct blk_plug plug;
     549                 :          0 :         bool do_poll = true, page_allocated;
     550                 :          0 :         struct vm_area_struct *vma = vmf->vma;
     551                 :          0 :         unsigned long addr = vmf->address;
     552                 :            : 
     553                 :          0 :         mask = swapin_nr_pages(offset) - 1;
     554         [ #  # ]:          0 :         if (!mask)
     555                 :          0 :                 goto skip;
     556                 :            : 
     557                 :            :         /* Test swap type to make sure the dereference is safe */
     558         [ #  # ]:          0 :         if (likely(si->flags & (SWP_BLKDEV | SWP_FS))) {
     559                 :          0 :                 struct inode *inode = si->swap_file->f_mapping->host;
     560         [ #  # ]:          0 :                 if (inode_read_congested(inode))
     561                 :          0 :                         goto skip;
     562                 :            :         }
     563                 :            : 
     564                 :          0 :         do_poll = false;
     565                 :            :         /* Read a page_cluster sized and aligned cluster around offset. */
     566                 :          0 :         start_offset = offset & ~mask;
     567                 :          0 :         end_offset = offset | mask;
     568                 :          0 :         if (!start_offset)      /* First page is swap header. */
     569                 :            :                 start_offset++;
     570         [ #  # ]:          0 :         if (end_offset >= si->max)
     571                 :          0 :                 end_offset = si->max - 1;
     572                 :            : 
     573                 :          0 :         blk_start_plug(&plug);
     574         [ #  # ]:          0 :         for (offset = start_offset; offset <= end_offset ; offset++) {
     575                 :            :                 /* Ok, do the async read-ahead now */
     576                 :          0 :                 page = __read_swap_cache_async(
     577                 :            :                         swp_entry(swp_type(entry), offset),
     578                 :            :                         gfp_mask, vma, addr, &page_allocated);
     579         [ #  # ]:          0 :                 if (!page)
     580                 :          0 :                         continue;
     581         [ #  # ]:          0 :                 if (page_allocated) {
     582                 :          0 :                         swap_readpage(page, false);
     583         [ #  # ]:          0 :                         if (offset != entry_offset) {
     584                 :          0 :                                 SetPageReadahead(page);
     585                 :          0 :                                 count_vm_event(SWAP_RA);
     586                 :            :                         }
     587                 :            :                 }
     588                 :          0 :                 put_page(page);
     589                 :            :         }
     590                 :          0 :         blk_finish_plug(&plug);
     591                 :            : 
     592                 :          0 :         lru_add_drain();        /* Push any new pages onto the LRU now */
     593                 :          0 : skip:
     594                 :          0 :         return read_swap_cache_async(entry, gfp_mask, vma, addr, do_poll);
     595                 :            : }
     596                 :            : 
     597                 :          0 : int init_swap_address_space(unsigned int type, unsigned long nr_pages)
     598                 :            : {
     599                 :          0 :         struct address_space *spaces, *space;
     600                 :          0 :         unsigned int i, nr;
     601                 :            : 
     602                 :          0 :         nr = DIV_ROUND_UP(nr_pages, SWAP_ADDRESS_SPACE_PAGES);
     603                 :          0 :         spaces = kvcalloc(nr, sizeof(struct address_space), GFP_KERNEL);
     604         [ #  # ]:          0 :         if (!spaces)
     605                 :            :                 return -ENOMEM;
     606         [ #  # ]:          0 :         for (i = 0; i < nr; i++) {
     607                 :          0 :                 space = spaces + i;
     608                 :          0 :                 xa_init_flags(&space->i_pages, XA_FLAGS_LOCK_IRQ);
     609                 :          0 :                 atomic_set(&space->i_mmap_writable, 0);
     610                 :          0 :                 space->a_ops = &swap_aops;
     611                 :            :                 /* swap cache doesn't use writeback related tags */
     612                 :          0 :                 mapping_set_no_writeback_tags(space);
     613                 :            :         }
     614                 :          0 :         nr_swapper_spaces[type] = nr;
     615                 :          0 :         swapper_spaces[type] = spaces;
     616                 :            : 
     617                 :          0 :         return 0;
     618                 :            : }
     619                 :            : 
     620                 :          0 : void exit_swap_address_space(unsigned int type)
     621                 :            : {
     622                 :          0 :         kvfree(swapper_spaces[type]);
     623                 :          0 :         nr_swapper_spaces[type] = 0;
     624                 :          0 :         swapper_spaces[type] = NULL;
     625                 :          0 : }
     626                 :            : 
     627                 :          0 : static inline void swap_ra_clamp_pfn(struct vm_area_struct *vma,
     628                 :            :                                      unsigned long faddr,
     629                 :            :                                      unsigned long lpfn,
     630                 :            :                                      unsigned long rpfn,
     631                 :            :                                      unsigned long *start,
     632                 :            :                                      unsigned long *end)
     633                 :            : {
     634                 :          0 :         *start = max3(lpfn, PFN_DOWN(vma->vm_start),
     635                 :            :                       PFN_DOWN(faddr & PMD_MASK));
     636                 :          0 :         *end = min3(rpfn, PFN_DOWN(vma->vm_end),
     637                 :            :                     PFN_DOWN((faddr & PMD_MASK) + PMD_SIZE));
     638                 :          0 : }
     639                 :            : 
     640                 :          0 : static void swap_ra_info(struct vm_fault *vmf,
     641                 :            :                         struct vma_swap_readahead *ra_info)
     642                 :            : {
     643                 :          0 :         struct vm_area_struct *vma = vmf->vma;
     644                 :          0 :         unsigned long ra_val;
     645                 :          0 :         swp_entry_t entry;
     646                 :          0 :         unsigned long faddr, pfn, fpfn;
     647                 :          0 :         unsigned long start, end;
     648                 :          0 :         pte_t *pte, *orig_pte;
     649                 :          0 :         unsigned int max_win, hits, prev_win, win, left;
     650                 :            : #ifndef CONFIG_64BIT
     651                 :            :         pte_t *tpte;
     652                 :            : #endif
     653                 :            : 
     654         [ #  # ]:          0 :         max_win = 1 << min_t(unsigned int, READ_ONCE(page_cluster),
     655                 :            :                              SWAP_RA_ORDER_CEILING);
     656         [ #  # ]:          0 :         if (max_win == 1) {
     657                 :          0 :                 ra_info->win = 1;
     658                 :          0 :                 return;
     659                 :            :         }
     660                 :            : 
     661                 :          0 :         faddr = vmf->address;
     662         [ #  # ]:          0 :         orig_pte = pte = pte_offset_map(vmf->pmd, faddr);
     663         [ #  # ]:          0 :         entry = pte_to_swp_entry(*pte);
     664         [ #  # ]:          0 :         if ((unlikely(non_swap_entry(entry)))) {
     665                 :            :                 pte_unmap(orig_pte);
     666                 :            :                 return;
     667                 :            :         }
     668                 :            : 
     669                 :          0 :         fpfn = PFN_DOWN(faddr);
     670         [ #  # ]:          0 :         ra_val = GET_SWAP_RA_VAL(vma);
     671                 :          0 :         pfn = PFN_DOWN(SWAP_RA_ADDR(ra_val));
     672                 :          0 :         prev_win = SWAP_RA_WIN(ra_val);
     673                 :          0 :         hits = SWAP_RA_HITS(ra_val);
     674         [ #  # ]:          0 :         ra_info->win = win = __swapin_nr_pages(pfn, fpfn, hits,
     675                 :            :                                                max_win, prev_win);
     676                 :          0 :         atomic_long_set(&vma->swap_readahead_info,
     677                 :          0 :                         SWAP_RA_VAL(faddr, win, 0));
     678                 :            : 
     679         [ #  # ]:          0 :         if (win == 1) {
     680                 :            :                 pte_unmap(orig_pte);
     681                 :            :                 return;
     682                 :            :         }
     683                 :            : 
     684                 :            :         /* Copy the PTEs because the page table may be unmapped */
     685         [ #  # ]:          0 :         if (fpfn == pfn + 1)
     686                 :          0 :                 swap_ra_clamp_pfn(vma, faddr, fpfn, fpfn + win, &start, &end);
     687         [ #  # ]:          0 :         else if (pfn == fpfn + 1)
     688                 :          0 :                 swap_ra_clamp_pfn(vma, faddr, fpfn - win + 1, fpfn + 1,
     689                 :            :                                   &start, &end);
     690                 :            :         else {
     691                 :          0 :                 left = (win - 1) / 2;
     692                 :          0 :                 swap_ra_clamp_pfn(vma, faddr, fpfn - left, fpfn + win - left,
     693                 :            :                                   &start, &end);
     694                 :            :         }
     695                 :          0 :         ra_info->nr_pte = end - start;
     696                 :          0 :         ra_info->offset = fpfn - start;
     697                 :          0 :         pte -= ra_info->offset;
     698                 :            : #ifdef CONFIG_64BIT
     699                 :          0 :         ra_info->ptes = pte;
     700                 :            : #else
     701                 :            :         tpte = ra_info->ptes;
     702                 :            :         for (pfn = start; pfn != end; pfn++)
     703                 :            :                 *tpte++ = *pte++;
     704                 :            : #endif
     705                 :          0 :         pte_unmap(orig_pte);
     706                 :            : }
     707                 :            : 
     708                 :            : /**
     709                 :            :  * swap_vma_readahead - swap in pages in hope we need them soon
     710                 :            :  * @entry: swap entry of this memory
     711                 :            :  * @gfp_mask: memory allocation flags
     712                 :            :  * @vmf: fault information
     713                 :            :  *
     714                 :            :  * Returns the struct page for entry and addr, after queueing swapin.
     715                 :            :  *
     716                 :            :  * Primitive swap readahead code. We simply read in a few pages whoes
     717                 :            :  * virtual addresses are around the fault address in the same vma.
     718                 :            :  *
     719                 :            :  * Caller must hold read mmap_sem if vmf->vma is not NULL.
     720                 :            :  *
     721                 :            :  */
     722                 :          0 : static struct page *swap_vma_readahead(swp_entry_t fentry, gfp_t gfp_mask,
     723                 :            :                                        struct vm_fault *vmf)
     724                 :            : {
     725                 :          0 :         struct blk_plug plug;
     726                 :          0 :         struct vm_area_struct *vma = vmf->vma;
     727                 :          0 :         struct page *page;
     728                 :          0 :         pte_t *pte, pentry;
     729                 :          0 :         swp_entry_t entry;
     730                 :          0 :         unsigned int i;
     731                 :          0 :         bool page_allocated;
     732                 :          0 :         struct vma_swap_readahead ra_info = {0,};
     733                 :            : 
     734                 :          0 :         swap_ra_info(vmf, &ra_info);
     735         [ #  # ]:          0 :         if (ra_info.win == 1)
     736                 :          0 :                 goto skip;
     737                 :            : 
     738                 :          0 :         blk_start_plug(&plug);
     739         [ #  # ]:          0 :         for (i = 0, pte = ra_info.ptes; i < ra_info.nr_pte;
     740                 :          0 :              i++, pte++) {
     741                 :          0 :                 pentry = *pte;
     742         [ #  # ]:          0 :                 if (pte_none(pentry))
     743                 :          0 :                         continue;
     744         [ #  # ]:          0 :                 if (pte_present(pentry))
     745                 :          0 :                         continue;
     746         [ #  # ]:          0 :                 entry = pte_to_swp_entry(pentry);
     747         [ #  # ]:          0 :                 if (unlikely(non_swap_entry(entry)))
     748                 :          0 :                         continue;
     749                 :          0 :                 page = __read_swap_cache_async(entry, gfp_mask, vma,
     750                 :            :                                                vmf->address, &page_allocated);
     751         [ #  # ]:          0 :                 if (!page)
     752                 :          0 :                         continue;
     753         [ #  # ]:          0 :                 if (page_allocated) {
     754                 :          0 :                         swap_readpage(page, false);
     755         [ #  # ]:          0 :                         if (i != ra_info.offset) {
     756                 :          0 :                                 SetPageReadahead(page);
     757                 :          0 :                                 count_vm_event(SWAP_RA);
     758                 :            :                         }
     759                 :            :                 }
     760                 :          0 :                 put_page(page);
     761                 :            :         }
     762                 :          0 :         blk_finish_plug(&plug);
     763                 :          0 :         lru_add_drain();
     764                 :          0 : skip:
     765                 :          0 :         return read_swap_cache_async(fentry, gfp_mask, vma, vmf->address,
     766                 :          0 :                                      ra_info.win == 1);
     767                 :            : }
     768                 :            : 
     769                 :            : /**
     770                 :            :  * swapin_readahead - swap in pages in hope we need them soon
     771                 :            :  * @entry: swap entry of this memory
     772                 :            :  * @gfp_mask: memory allocation flags
     773                 :            :  * @vmf: fault information
     774                 :            :  *
     775                 :            :  * Returns the struct page for entry and addr, after queueing swapin.
     776                 :            :  *
     777                 :            :  * It's a main entry function for swap readahead. By the configuration,
     778                 :            :  * it will read ahead blocks by cluster-based(ie, physical disk based)
     779                 :            :  * or vma-based(ie, virtual address based on faulty address) readahead.
     780                 :            :  */
     781                 :          0 : struct page *swapin_readahead(swp_entry_t entry, gfp_t gfp_mask,
     782                 :            :                                 struct vm_fault *vmf)
     783                 :            : {
     784         [ #  # ]:          0 :         return swap_use_vma_readahead() ?
     785         [ #  # ]:          0 :                         swap_vma_readahead(entry, gfp_mask, vmf) :
     786                 :          0 :                         swap_cluster_readahead(entry, gfp_mask, vmf);
     787                 :            : }
     788                 :            : 
     789                 :            : #ifdef CONFIG_SYSFS
     790                 :          0 : static ssize_t vma_ra_enabled_show(struct kobject *kobj,
     791                 :            :                                      struct kobj_attribute *attr, char *buf)
     792                 :            : {
     793         [ #  # ]:          0 :         return sprintf(buf, "%s\n", enable_vma_readahead ? "true" : "false");
     794                 :            : }
     795                 :          0 : static ssize_t vma_ra_enabled_store(struct kobject *kobj,
     796                 :            :                                       struct kobj_attribute *attr,
     797                 :            :                                       const char *buf, size_t count)
     798                 :            : {
     799   [ #  #  #  # ]:          0 :         if (!strncmp(buf, "true", 4) || !strncmp(buf, "1", 1))
     800                 :          0 :                 enable_vma_readahead = true;
     801   [ #  #  #  # ]:          0 :         else if (!strncmp(buf, "false", 5) || !strncmp(buf, "0", 1))
     802                 :          0 :                 enable_vma_readahead = false;
     803                 :            :         else
     804                 :            :                 return -EINVAL;
     805                 :            : 
     806                 :          0 :         return count;
     807                 :            : }
     808                 :            : static struct kobj_attribute vma_ra_enabled_attr =
     809                 :            :         __ATTR(vma_ra_enabled, 0644, vma_ra_enabled_show,
     810                 :            :                vma_ra_enabled_store);
     811                 :            : 
     812                 :            : static struct attribute *swap_attrs[] = {
     813                 :            :         &vma_ra_enabled_attr.attr,
     814                 :            :         NULL,
     815                 :            : };
     816                 :            : 
     817                 :            : static struct attribute_group swap_attr_group = {
     818                 :            :         .attrs = swap_attrs,
     819                 :            : };
     820                 :            : 
     821                 :          3 : static int __init swap_init_sysfs(void)
     822                 :            : {
     823                 :          3 :         int err;
     824                 :          3 :         struct kobject *swap_kobj;
     825                 :            : 
     826                 :          3 :         swap_kobj = kobject_create_and_add("swap", mm_kobj);
     827         [ -  + ]:          3 :         if (!swap_kobj) {
     828                 :          0 :                 pr_err("failed to create swap kobject\n");
     829                 :          0 :                 return -ENOMEM;
     830                 :            :         }
     831                 :          3 :         err = sysfs_create_group(swap_kobj, &swap_attr_group);
     832         [ -  + ]:          3 :         if (err) {
     833                 :          0 :                 pr_err("failed to register swap group\n");
     834                 :          0 :                 goto delete_obj;
     835                 :            :         }
     836                 :            :         return 0;
     837                 :            : 
     838                 :            : delete_obj:
     839                 :          0 :         kobject_put(swap_kobj);
     840                 :          0 :         return err;
     841                 :            : }
     842                 :            : subsys_initcall(swap_init_sysfs);
     843                 :            : #endif

Generated by: LCOV version 1.14