Hi Andrew, I want to keep this patchset rather than wrecking. It is needed to code more neat to fix a bug James reported.
https://marc.info/?l=linux-mm&m=151493906616938 On Tue, Jan 02, 2018 at 04:23:34PM -0800, a...@linux-foundation.org wrote: > > The patch titled > Subject: mm: swap: unify cluster-based and vma-based swap readahead > has been removed from the -mm tree. Its filename was > mm-swap-unify-cluster-based-and-vma-based-swap-readahead.patch > > This patch was dropped because other changes were merged, which wrecked this > patch > > ------------------------------------------------------ > From: Minchan Kim <minc...@kernel.org> > Subject: mm: swap: unify cluster-based and vma-based swap readahead > > This patch makes do_swap_page() not need to be aware of two different swap > readahead algorithms. Just unify cluster-based and vma-based readahead > function call. > > Link: > http://lkml.kernel.org/r/1509520520-32367-3-git-send-email-minc...@kernel.org > Signed-off-by: Minchan Kim <minc...@kernel.org> > Cc: Hugh Dickins <hu...@google.com> > Cc: Huang Ying <ying.hu...@intel.com> > Signed-off-by: Andrew Morton <a...@linux-foundation.org> > --- > > include/linux/swap.h | 27 ++++++----------------- > mm/memory.c | 11 +++------ > mm/shmem.c | 5 +++- > mm/swap_state.c | 48 +++++++++++++++++++++++++++++++---------- > 4 files changed, 53 insertions(+), 38 deletions(-) > > diff -puN > include/linux/swap.h~mm-swap-unify-cluster-based-and-vma-based-swap-readahead > include/linux/swap.h > --- > a/include/linux/swap.h~mm-swap-unify-cluster-based-and-vma-based-swap-readahead > +++ a/include/linux/swap.h > @@ -401,7 +401,6 @@ int generic_swapfile_activate(struct swa > #define SWAP_ADDRESS_SPACE_SHIFT 14 > #define SWAP_ADDRESS_SPACE_PAGES (1 << SWAP_ADDRESS_SPACE_SHIFT) > extern struct address_space *swapper_spaces[]; > -extern bool swap_vma_readahead; > #define swap_address_space(entry) \ > (&swapper_spaces[swp_type(entry)][swp_offset(entry) \ > >> SWAP_ADDRESS_SPACE_SHIFT]) > @@ -423,10 +422,10 @@ extern struct page *read_swap_cache_asyn > extern struct page *__read_swap_cache_async(swp_entry_t, gfp_t, > struct vm_area_struct *vma, unsigned long addr, > bool *new_page_allocated); > -extern struct page *swapin_readahead(swp_entry_t, gfp_t, > - struct vm_area_struct *vma, unsigned long addr); > -extern struct page *do_swap_page_readahead(swp_entry_t fentry, gfp_t > gfp_mask, > - struct vm_fault *vmf); > +extern struct page *swap_cluster_readahead(swp_entry_t entry, gfp_t flag, > + struct vm_fault *vmf); > +extern struct page *swapin_readahead(swp_entry_t entry, gfp_t flag, > + struct vm_fault *vmf); > > /* linux/mm/swapfile.c */ > extern atomic_long_t nr_swap_pages; > @@ -434,11 +433,6 @@ extern long total_swap_pages; > extern atomic_t nr_rotate_swap; > extern bool has_usable_swap(void); > > -static inline bool swap_use_vma_readahead(void) > -{ > - return READ_ONCE(swap_vma_readahead) && !atomic_read(&nr_rotate_swap); > -} > - > /* Swap 50% full? Release swapcache more aggressively.. */ > static inline bool vm_swap_full(void) > { > @@ -534,19 +528,14 @@ static inline void put_swap_page(struct > { > } > > -static inline struct page *swapin_readahead(swp_entry_t swp, gfp_t gfp_mask, > - struct vm_area_struct *vma, unsigned long addr) > +static inline struct page *swap_cluster_readahead(swp_entry_t entry, > + gfp_t gfp_mask, struct vm_fault *vmf) > { > return NULL; > } > > -static inline bool swap_use_vma_readahead(void) > -{ > - return false; > -} > - > -static inline struct page *do_swap_page_readahead(swp_entry_t fentry, > - gfp_t gfp_mask, struct vm_fault *vmf) > +static inline struct page *swapin_readahead(swp_entry_t swp, gfp_t gfp_mask, > + struct vm_fault *vmf) > { > return NULL; > } > diff -puN > mm/memory.c~mm-swap-unify-cluster-based-and-vma-based-swap-readahead > mm/memory.c > --- a/mm/memory.c~mm-swap-unify-cluster-based-and-vma-based-swap-readahead > +++ a/mm/memory.c > @@ -2889,7 +2889,8 @@ int do_swap_page(struct vm_fault *vmf) > if (si->flags & SWP_SYNCHRONOUS_IO && > __swap_count(si, entry) == 1) { > /* skip swapcache */ > - page = alloc_page_vma(GFP_HIGHUSER_MOVABLE, vma, > vmf->address); > + page = alloc_page_vma(GFP_HIGHUSER_MOVABLE, vma, > + vmf->address); > if (page) { > __SetPageLocked(page); > __SetPageSwapBacked(page); > @@ -2898,12 +2899,8 @@ int do_swap_page(struct vm_fault *vmf) > swap_readpage(page, true); > } > } else { > - if (swap_use_vma_readahead()) > - page = do_swap_page_readahead(entry, > - GFP_HIGHUSER_MOVABLE, vmf); > - else > - page = swapin_readahead(entry, > - GFP_HIGHUSER_MOVABLE, vma, vmf->address); > + page = swapin_readahead(entry, GFP_HIGHUSER_MOVABLE, > + vmf); > swapcache = page; > } > > diff -puN mm/shmem.c~mm-swap-unify-cluster-based-and-vma-based-swap-readahead > mm/shmem.c > --- a/mm/shmem.c~mm-swap-unify-cluster-based-and-vma-based-swap-readahead > +++ a/mm/shmem.c > @@ -1413,9 +1413,12 @@ static struct page *shmem_swapin(swp_ent > { > struct vm_area_struct pvma; > struct page *page; > + struct vm_fault vmf; > > shmem_pseudo_vma_init(&pvma, info, index); > - page = swapin_readahead(swap, gfp, &pvma, 0); > + vmf.vma = &pvma; > + vmf.address = 0; > + page = swap_cluster_readahead(swap, gfp, &vmf); > shmem_pseudo_vma_destroy(&pvma); > > return page; > diff -puN > mm/swap_state.c~mm-swap-unify-cluster-based-and-vma-based-swap-readahead > mm/swap_state.c > --- a/mm/swap_state.c~mm-swap-unify-cluster-based-and-vma-based-swap-readahead > +++ a/mm/swap_state.c > @@ -38,7 +38,7 @@ static const struct address_space_operat > > struct address_space *swapper_spaces[MAX_SWAPFILES] __read_mostly; > static unsigned int nr_swapper_spaces[MAX_SWAPFILES] __read_mostly; > -bool swap_vma_readahead __read_mostly = true; > +bool enable_vma_readahead __read_mostly = true; > > #define SWAP_RA_WIN_SHIFT (PAGE_SHIFT / 2) > #define SWAP_RA_HITS_MASK ((1UL << SWAP_RA_WIN_SHIFT) - 1) > @@ -322,6 +322,11 @@ void free_pages_and_swap_cache(struct pa > release_pages(pagep, nr); > } > > +static inline bool swap_use_vma_readahead(void) > +{ > + return READ_ONCE(enable_vma_readahead) && !atomic_read(&nr_rotate_swap); > +} > + > /* > * Lookup a swap entry in the swap cache. A found page will be returned > * unlocked and with its refcount incremented - we rely on the kernel > @@ -539,11 +544,10 @@ static unsigned long swapin_nr_pages(uns > } > > /** > - * swapin_readahead - swap in pages in hope we need them soon > + * swap_cluster_readahead - swap in pages in hope we need them soon > * @entry: swap entry of this memory > * @gfp_mask: memory allocation flags > - * @vma: user vma this address belongs to > - * @addr: target address for mempolicy > + * @vmf: fault information > * > * Returns the struct page for entry and addr, after queueing swapin. > * > @@ -555,10 +559,10 @@ static unsigned long swapin_nr_pages(uns > * This has been extended to use the NUMA policies from the mm triggering > * the readahead. > * > - * Caller must hold down_read on the vma->vm_mm if vma is not NULL. > + * Caller must hold down_read on the vma->vm_mm if vmf->vma is not NULL. > */ > -struct page *swapin_readahead(swp_entry_t entry, gfp_t gfp_mask, > - struct vm_area_struct *vma, unsigned long addr) > +struct page *swap_cluster_readahead(swp_entry_t entry, gfp_t gfp_mask, > + struct vm_fault *vmf) > { > struct page *page; > unsigned long entry_offset = swp_offset(entry); > @@ -568,6 +572,8 @@ struct page *swapin_readahead(swp_entry_ > struct swap_info_struct *si = swp_swap_info(entry); > struct blk_plug plug; > bool do_poll = true, page_allocated; > + struct vm_area_struct *vma = vmf->vma; > + unsigned long addr = vmf->address; > > mask = swapin_nr_pages(offset) - 1; > if (!mask) > @@ -723,7 +729,7 @@ static void swap_ra_info(struct vm_fault > pte_unmap(orig_pte); > } > > -struct page *do_swap_page_readahead(swp_entry_t fentry, gfp_t gfp_mask, > +struct page *swap_vma_readahead(swp_entry_t fentry, gfp_t gfp_mask, > struct vm_fault *vmf) > { > struct blk_plug plug; > @@ -771,20 +777,40 @@ skip: > ra_info.win == 1); > } > > +/** > + * swapin_readahead - swap in pages in hope we need them soon > + * @entry: swap entry of this memory > + * @gfp_mask: memory allocation flags > + * @vmf: fault information > + * > + * Returns the struct page for entry and addr, after queueing swapin. > + * > + * It's a main entry function for swap readahead. By the configuration, > + * it will read ahead blocks by cluster-based(ie, physical disk based) > + * or vma-based(ie, virtual address based on faulty address) readahead. > + */ > +struct page *swapin_readahead(swp_entry_t entry, gfp_t gfp_mask, > + struct vm_fault *vmf) > +{ > + return swap_use_vma_readahead() ? > + swap_vma_readahead(entry, gfp_mask, vmf) : > + swap_cluster_readahead(entry, gfp_mask, vmf); > +} > + > #ifdef CONFIG_SYSFS > static ssize_t vma_ra_enabled_show(struct kobject *kobj, > struct kobj_attribute *attr, char *buf) > { > - return sprintf(buf, "%s\n", swap_vma_readahead ? "true" : "false"); > + return sprintf(buf, "%s\n", enable_vma_readahead ? "true" : "false"); > } > static ssize_t vma_ra_enabled_store(struct kobject *kobj, > struct kobj_attribute *attr, > const char *buf, size_t count) > { > if (!strncmp(buf, "true", 4) || !strncmp(buf, "1", 1)) > - swap_vma_readahead = true; > + enable_vma_readahead = true; > else if (!strncmp(buf, "false", 5) || !strncmp(buf, "0", 1)) > - swap_vma_readahead = false; > + enable_vma_readahead = false; > else > return -EINVAL; > > _ > > Patches currently in -mm which might be from minc...@kernel.org are > > mm-release-locked-page-in-do_swap_page.patch > mm-do-not-stall-register_shrinker.patch > > -- > To unsubscribe from this list: send the line "unsubscribe mm-commits" in > the body of a message to majord...@vger.kernel.org > More majordomo info at http://vger.kernel.org/majordomo-info.html
