[Ocfs2-devel] [PATCH v5 04/13] mm: Add readahead address space operation

[Ocfs2-devel] [PATCH v5 04/13] mm: Add readahead address space operation

[Dave Chinner]

On Mon, Feb 10, 2020 at 05:03:39PM -0800, Matthew Wilcox wrote:
> From: "Matthew Wilcox (Oracle)" <willy@infradead.org>
> 
> This replaces ->readpages with a saner interface:
>  - Return void instead of an ignored error code.
>  - Pages are already in the page cache when ->readahead is called.
>  - Implementation looks up the pages in the page cache instead of
>    having them passed in a linked list.
> 
> Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>

....

>  
> +/*
> + * Readahead is of a block of consecutive pages.
> + */
> +struct readahead_control {
> +	struct file *file;
> +	struct address_space *mapping;
> +/* private: use the readahead_* accessors instead */
> +	pgoff_t start;
> +	unsigned int nr_pages;
> +	unsigned int batch_count;
> +};
> +
> +static inline struct page *readahead_page(struct readahead_control *rac)
> +{
> +	struct page *page;
> +
> +	if (!rac->nr_pages)
> +		return NULL;
> +
> +	page = xa_load(&rac->mapping->i_pages, rac->start);
> +	VM_BUG_ON_PAGE(!PageLocked(page), page);
> +	rac->batch_count = hpage_nr_pages(page);
> +	rac->start += rac->batch_count;

There's no mention of large page support in the patch description
and I don't recall this sort of large page batching in previous
iterations.

This seems like new functionality to me, not directly related to
the initial ->readahead API change? What have I missed?

Cheers,

Dave.
-- 
Dave Chinner
david at fromorbit.com

[Ocfs2-devel] [PATCH v5 04/13] mm: Add readahead address space operation

[Dave Chinner]

On Tue, Feb 11, 2020 at 04:54:13AM -0800, Matthew Wilcox wrote:
> On Tue, Feb 11, 2020 at 03:52:30PM +1100, Dave Chinner wrote:
> > > +struct readahead_control {
> > > +	struct file *file;
> > > +	struct address_space *mapping;
> > > +/* private: use the readahead_* accessors instead */
> > > +	pgoff_t start;
> > > +	unsigned int nr_pages;
> > > +	unsigned int batch_count;
> > > +};
> > > +
> > > +static inline struct page *readahead_page(struct readahead_control *rac)
> > > +{
> > > +	struct page *page;
> > > +
> > > +	if (!rac->nr_pages)
> > > +		return NULL;
> > > +
> > > +	page = xa_load(&rac->mapping->i_pages, rac->start);
> > > +	VM_BUG_ON_PAGE(!PageLocked(page), page);
> > > +	rac->batch_count = hpage_nr_pages(page);
> > > +	rac->start += rac->batch_count;
> > 
> > There's no mention of large page support in the patch description
> > and I don't recall this sort of large page batching in previous
> > iterations.
> > 
> > This seems like new functionality to me, not directly related to
> > the initial ->readahead API change? What have I missed?
> 
> I had a crisis of confidence when I was working on this -- the loop
> originally looked like this:
> 
> #define readahead_for_each(rac, page)                                   \
>         for (; (page = readahead_page(rac)); rac->nr_pages--)
> 
> and then I started thinking about what I'd need to do to support large
> pages, and that turned into
> 
> #define readahead_for_each(rac, page)                                   \
>         for (; (page = readahead_page(rac));				\
> 		rac->nr_pages -= hpage_nr_pages(page))
> 
> but I realised that was potentially a use-after-free because 'page' has
> certainly had put_page() called on it by then.  I had a brief period
> where I looked at moving put_page() away from being the filesystem's
> responsibility and into the iterator, but that would introduce more
> changes into the patchset, as well as causing problems for filesystems
> that want to break out of the loop.
> 
> By this point, I was also looking at the readahead_for_each_batch()
> iterator that btrfs uses, and so we have the batch count anyway, and we
> might as well use it to store the number of subpages of the large page.
> And so it became easier to just put the whole ball of wax into the initial
> patch set, rather than introduce the iterator now and then fix it up in
> the patch set that I'm basing on this.
> 
> So yes, there's a certain amount of excess functionality in this patch
> set ... I can remove it for the next release.

I'd say "Just document it" as that was the main reason I noticed it.
Or perhaps add the batching function as a stand-alone patch so it's
clear that the batch interface solves two problems at once - large
pages and the btrfs page batching implementation...

Cheers,

Dave.
-- 
Dave Chinner
david at fromorbit.com

[Ocfs2-devel] [PATCH v5 01/13] mm: Fix the return type of __do_page_cache_readahead

[Christoph Hellwig]

Looks good,

Reviewed-by: Christoph Hellwig <hch@lst.de>

[Ocfs2-devel] [PATCH v5 02/13] mm: Ignore return value of ->readpages

[Christoph Hellwig]

On Mon, Feb 10, 2020 at 05:03:37PM -0800, Matthew Wilcox wrote:
> From: "Matthew Wilcox (Oracle)" <willy@infradead.org>
> 
> We used to assign the return value to a variable, which we then ignored.
> Remove the pretence of caring.
> 
> Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>

Looks good,

Reviewed-by: Christoph Hellwig <hch@lst.de>

[Ocfs2-devel] [PATCH v5 04/13] mm: Add readahead address space operation

[Christoph Hellwig]

On Mon, Feb 10, 2020 at 05:03:39PM -0800, Matthew Wilcox wrote:
> +struct readahead_control {
> +	struct file *file;
> +	struct address_space *mapping;
> +/* private: use the readahead_* accessors instead */
> +	pgoff_t start;
> +	unsigned int nr_pages;
> +	unsigned int batch_count;

We often use __ prefixes for the private fields to make that a little
more clear.

[Ocfs2-devel] [PATCH v5 06/13] fs: Convert mpage_readpages to mpage_readahead

[Junxiao Bi]

On 2/10/20 5:03 PM, Matthew Wilcox wrote:
> From: "Matthew Wilcox (Oracle)" <willy@infradead.org>
>
> Implement the new readahead aop and convert all callers (block_dev,
> exfat, ext2, fat, gfs2, hpfs, isofs, jfs, nilfs2, ocfs2, omfs, qnx6,
> reiserfs & udf).  The callers are all trivial except for GFS2 & OCFS2.
>
> Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
> ---
>   drivers/staging/exfat/exfat_super.c |  7 +++---
>   fs/block_dev.c                      |  7 +++---
>   fs/ext2/inode.c                     | 10 +++-----
>   fs/fat/inode.c                      |  7 +++---
>   fs/gfs2/aops.c                      | 23 ++++++-----------
>   fs/hpfs/file.c                      |  7 +++---
>   fs/iomap/buffered-io.c              |  2 +-
>   fs/isofs/inode.c                    |  7 +++---
>   fs/jfs/inode.c                      |  7 +++---
>   fs/mpage.c                          | 38 +++++++++--------------------
>   fs/nilfs2/inode.c                   | 15 +++---------
>   fs/ocfs2/aops.c                     | 34 ++++++++++----------------
>   fs/omfs/file.c                      |  7 +++---
>   fs/qnx6/inode.c                     |  7 +++---
>   fs/reiserfs/inode.c                 |  8 +++---
>   fs/udf/inode.c                      |  7 +++---
>   include/linux/mpage.h               |  4 +--
>   mm/migrate.c                        |  2 +-
>   18 files changed, 74 insertions(+), 125 deletions(-)
>
> diff --git a/drivers/staging/exfat/exfat_super.c b/drivers/staging/exfat/exfat_super.c
> index b81d2a87b82e..96aad9b16d31 100644
> --- a/drivers/staging/exfat/exfat_super.c
> +++ b/drivers/staging/exfat/exfat_super.c
> @@ -3002,10 +3002,9 @@ static int exfat_readpage(struct file *file, struct page *page)
>   	return  mpage_readpage(page, exfat_get_block);
>   }
>   
> -static int exfat_readpages(struct file *file, struct address_space *mapping,
> -			   struct list_head *pages, unsigned int nr_pages)
> +static void exfat_readahead(struct readahead_control *rac)
>   {
> -	return  mpage_readpages(mapping, pages, nr_pages, exfat_get_block);
> +	mpage_readahead(rac, exfat_get_block);
>   }
>   
>   static int exfat_writepage(struct page *page, struct writeback_control *wbc)
> @@ -3104,7 +3103,7 @@ static sector_t _exfat_bmap(struct address_space *mapping, sector_t block)
>   
>   static const struct address_space_operations exfat_aops = {
>   	.readpage    = exfat_readpage,
> -	.readpages   = exfat_readpages,
> +	.readahead   = exfat_readahead,
>   	.writepage   = exfat_writepage,
>   	.writepages  = exfat_writepages,
>   	.write_begin = exfat_write_begin,
> diff --git a/fs/block_dev.c b/fs/block_dev.c
> index 69bf2fb6f7cd..2fd9c7bd61f6 100644
> --- a/fs/block_dev.c
> +++ b/fs/block_dev.c
> @@ -614,10 +614,9 @@ static int blkdev_readpage(struct file * file, struct page * page)
>   	return block_read_full_page(page, blkdev_get_block);
>   }
>   
> -static int blkdev_readpages(struct file *file, struct address_space *mapping,
> -			struct list_head *pages, unsigned nr_pages)
> +static void blkdev_readahead(struct readahead_control *rac)
>   {
> -	return mpage_readpages(mapping, pages, nr_pages, blkdev_get_block);
> +	mpage_readahead(rac, blkdev_get_block);
>   }
>   
>   static int blkdev_write_begin(struct file *file, struct address_space *mapping,
> @@ -2062,7 +2061,7 @@ static int blkdev_writepages(struct address_space *mapping,
>   
>   static const struct address_space_operations def_blk_aops = {
>   	.readpage	= blkdev_readpage,
> -	.readpages	= blkdev_readpages,
> +	.readahead	= blkdev_readahead,
>   	.writepage	= blkdev_writepage,
>   	.write_begin	= blkdev_write_begin,
>   	.write_end	= blkdev_write_end,
> diff --git a/fs/ext2/inode.c b/fs/ext2/inode.c
> index 119667e65890..2a65387f9b12 100644
> --- a/fs/ext2/inode.c
> +++ b/fs/ext2/inode.c
> @@ -877,11 +877,9 @@ static int ext2_readpage(struct file *file, struct page *page)
>   	return mpage_readpage(page, ext2_get_block);
>   }
>   
> -static int
> -ext2_readpages(struct file *file, struct address_space *mapping,
> -		struct list_head *pages, unsigned nr_pages)
> +static void ext2_readahead(struct readahead_control *rac)
>   {
> -	return mpage_readpages(mapping, pages, nr_pages, ext2_get_block);
> +	mpage_readahead(rac, ext2_get_block);
>   }
>   
>   static int
> @@ -966,7 +964,7 @@ ext2_dax_writepages(struct address_space *mapping, struct writeback_control *wbc
>   
>   const struct address_space_operations ext2_aops = {
>   	.readpage		= ext2_readpage,
> -	.readpages		= ext2_readpages,
> +	.readahead		= ext2_readahead,
>   	.writepage		= ext2_writepage,
>   	.write_begin		= ext2_write_begin,
>   	.write_end		= ext2_write_end,
> @@ -980,7 +978,7 @@ const struct address_space_operations ext2_aops = {
>   
>   const struct address_space_operations ext2_nobh_aops = {
>   	.readpage		= ext2_readpage,
> -	.readpages		= ext2_readpages,
> +	.readahead		= ext2_readahead,
>   	.writepage		= ext2_nobh_writepage,
>   	.write_begin		= ext2_nobh_write_begin,
>   	.write_end		= nobh_write_end,
> diff --git a/fs/fat/inode.c b/fs/fat/inode.c
> index 594b05ae16c9..3496f5fc3e6d 100644
> --- a/fs/fat/inode.c
> +++ b/fs/fat/inode.c
> @@ -210,10 +210,9 @@ static int fat_readpage(struct file *file, struct page *page)
>   	return mpage_readpage(page, fat_get_block);
>   }
>   
> -static int fat_readpages(struct file *file, struct address_space *mapping,
> -			 struct list_head *pages, unsigned nr_pages)
> +static void fat_readahead(struct readahead_control *rac)
>   {
> -	return mpage_readpages(mapping, pages, nr_pages, fat_get_block);
> +	mpage_readahead(rac, fat_get_block);
>   }
>   
>   static void fat_write_failed(struct address_space *mapping, loff_t to)
> @@ -344,7 +343,7 @@ int fat_block_truncate_page(struct inode *inode, loff_t from)
>   
>   static const struct address_space_operations fat_aops = {
>   	.readpage	= fat_readpage,
> -	.readpages	= fat_readpages,
> +	.readahead	= fat_readahead,
>   	.writepage	= fat_writepage,
>   	.writepages	= fat_writepages,
>   	.write_begin	= fat_write_begin,
> diff --git a/fs/gfs2/aops.c b/fs/gfs2/aops.c
> index ba83b49ce18c..5e63c13c12c1 100644
> --- a/fs/gfs2/aops.c
> +++ b/fs/gfs2/aops.c
> @@ -577,7 +577,7 @@ int gfs2_internal_read(struct gfs2_inode *ip, char *buf, loff_t *pos,
>   }
>   
>   /**
> - * gfs2_readpages - Read a bunch of pages at once
> + * gfs2_readahead - Read a bunch of pages at once
>    * @file: The file to read from
>    * @mapping: Address space info
>    * @pages: List of pages to read
> @@ -590,31 +590,24 @@ int gfs2_internal_read(struct gfs2_inode *ip, char *buf, loff_t *pos,
>    *    obviously not something we'd want to do on too regular a basis.
>    *    Any I/O we ignore at this time will be done via readpage later.
>    * 2. We don't handle stuffed files here we let readpage do the honours.
> - * 3. mpage_readpages() does most of the heavy lifting in the common case.
> + * 3. mpage_readahead() does most of the heavy lifting in the common case.
>    * 4. gfs2_block_map() is relied upon to set BH_Boundary in the right places.
>    */
>   
> -static int gfs2_readpages(struct file *file, struct address_space *mapping,
> -			  struct list_head *pages, unsigned nr_pages)
> +static void gfs2_readahead(struct readahead_control *rac)
>   {
> -	struct inode *inode = mapping->host;
> +	struct inode *inode = rac->mapping->host;
>   	struct gfs2_inode *ip = GFS2_I(inode);
> -	struct gfs2_sbd *sdp = GFS2_SB(inode);
>   	struct gfs2_holder gh;
> -	int ret;
>   
>   	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
> -	ret = gfs2_glock_nq(&gh);
> -	if (unlikely(ret))
> +	if (gfs2_glock_nq(&gh))
>   		goto out_uninit;
>   	if (!gfs2_is_stuffed(ip))
> -		ret = mpage_readpages(mapping, pages, nr_pages, gfs2_block_map);
> +		mpage_readahead(rac, gfs2_block_map);
>   	gfs2_glock_dq(&gh);
>   out_uninit:
>   	gfs2_holder_uninit(&gh);
> -	if (unlikely(gfs2_withdrawn(sdp)))
> -		ret = -EIO;
> -	return ret;
>   }
>   
>   /**
> @@ -828,7 +821,7 @@ static const struct address_space_operations gfs2_aops = {
>   	.writepage = gfs2_writepage,
>   	.writepages = gfs2_writepages,
>   	.readpage = gfs2_readpage,
> -	.readpages = gfs2_readpages,
> +	.readahead = gfs2_readahead,
>   	.bmap = gfs2_bmap,
>   	.invalidatepage = gfs2_invalidatepage,
>   	.releasepage = gfs2_releasepage,
> @@ -842,7 +835,7 @@ static const struct address_space_operations gfs2_jdata_aops = {
>   	.writepage = gfs2_jdata_writepage,
>   	.writepages = gfs2_jdata_writepages,
>   	.readpage = gfs2_readpage,
> -	.readpages = gfs2_readpages,
> +	.readahead = gfs2_readahead,
>   	.set_page_dirty = jdata_set_page_dirty,
>   	.bmap = gfs2_bmap,
>   	.invalidatepage = gfs2_invalidatepage,
> diff --git a/fs/hpfs/file.c b/fs/hpfs/file.c
> index b36abf9cb345..2de0d3492d15 100644
> --- a/fs/hpfs/file.c
> +++ b/fs/hpfs/file.c
> @@ -125,10 +125,9 @@ static int hpfs_writepage(struct page *page, struct writeback_control *wbc)
>   	return block_write_full_page(page, hpfs_get_block, wbc);
>   }
>   
> -static int hpfs_readpages(struct file *file, struct address_space *mapping,
> -			  struct list_head *pages, unsigned nr_pages)
> +static void hpfs_readahead(struct readahead_control *rac)
>   {
> -	return mpage_readpages(mapping, pages, nr_pages, hpfs_get_block);
> +	mpage_readahead(rac, hpfs_get_block);
>   }
>   
>   static int hpfs_writepages(struct address_space *mapping,
> @@ -198,7 +197,7 @@ static int hpfs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
>   const struct address_space_operations hpfs_aops = {
>   	.readpage = hpfs_readpage,
>   	.writepage = hpfs_writepage,
> -	.readpages = hpfs_readpages,
> +	.readahead = hpfs_readahead,
>   	.writepages = hpfs_writepages,
>   	.write_begin = hpfs_write_begin,
>   	.write_end = hpfs_write_end,
> diff --git a/fs/iomap/buffered-io.c b/fs/iomap/buffered-io.c
> index 7c84c4c027c4..cb3511eb152a 100644
> --- a/fs/iomap/buffered-io.c
> +++ b/fs/iomap/buffered-io.c
> @@ -359,7 +359,7 @@ iomap_readpage(struct page *page, const struct iomap_ops *ops)
>   	}
>   
>   	/*
> -	 * Just like mpage_readpages and block_read_full_page we always
> +	 * Just like mpage_readahead and block_read_full_page we always
>   	 * return 0 and just mark the page as PageError on errors.  This
>   	 * should be cleaned up all through the stack eventually.
>   	 */
> diff --git a/fs/isofs/inode.c b/fs/isofs/inode.c
> index 62c0462dc89f..95b1f377ad09 100644
> --- a/fs/isofs/inode.c
> +++ b/fs/isofs/inode.c
> @@ -1185,10 +1185,9 @@ static int isofs_readpage(struct file *file, struct page *page)
>   	return mpage_readpage(page, isofs_get_block);
>   }
>   
> -static int isofs_readpages(struct file *file, struct address_space *mapping,
> -			struct list_head *pages, unsigned nr_pages)
> +static void isofs_readahead(struct readahead_control *rac)
>   {
> -	return mpage_readpages(mapping, pages, nr_pages, isofs_get_block);
> +	mpage_readahead(rac, isofs_get_block);
>   }
>   
>   static sector_t _isofs_bmap(struct address_space *mapping, sector_t block)
> @@ -1198,7 +1197,7 @@ static sector_t _isofs_bmap(struct address_space *mapping, sector_t block)
>   
>   static const struct address_space_operations isofs_aops = {
>   	.readpage = isofs_readpage,
> -	.readpages = isofs_readpages,
> +	.readahead = isofs_readahead,
>   	.bmap = _isofs_bmap
>   };
>   
> diff --git a/fs/jfs/inode.c b/fs/jfs/inode.c
> index 9486afcdac76..6f65bfa9f18d 100644
> --- a/fs/jfs/inode.c
> +++ b/fs/jfs/inode.c
> @@ -296,10 +296,9 @@ static int jfs_readpage(struct file *file, struct page *page)
>   	return mpage_readpage(page, jfs_get_block);
>   }
>   
> -static int jfs_readpages(struct file *file, struct address_space *mapping,
> -		struct list_head *pages, unsigned nr_pages)
> +static void jfs_readahead(struct readahead_control *rac)
>   {
> -	return mpage_readpages(mapping, pages, nr_pages, jfs_get_block);
> +	mpage_readahead(rac, jfs_get_block);
>   }
>   
>   static void jfs_write_failed(struct address_space *mapping, loff_t to)
> @@ -358,7 +357,7 @@ static ssize_t jfs_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
>   
>   const struct address_space_operations jfs_aops = {
>   	.readpage	= jfs_readpage,
> -	.readpages	= jfs_readpages,
> +	.readahead	= jfs_readahead,
>   	.writepage	= jfs_writepage,
>   	.writepages	= jfs_writepages,
>   	.write_begin	= jfs_write_begin,
> diff --git a/fs/mpage.c b/fs/mpage.c
> index ccba3c4c4479..166a95ec1341 100644
> --- a/fs/mpage.c
> +++ b/fs/mpage.c
> @@ -91,7 +91,7 @@ mpage_alloc(struct block_device *bdev,
>   }
>   
>   /*
> - * support function for mpage_readpages.  The fs supplied get_block might
> + * support function for mpage_readahead.  The fs supplied get_block might
>    * return an up to date buffer.  This is used to map that buffer into
>    * the page, which allows readpage to avoid triggering a duplicate call
>    * to get_block.
> @@ -338,13 +338,10 @@ static struct bio *do_mpage_readpage(struct mpage_readpage_args *args)
>   }
>   
>   /**
> - * mpage_readpages - populate an address space with some pages & start reads against them
> + * mpage_readahead - start reads against pages
>    * @mapping: the address_space
> - * @pages: The address of a list_head which contains the target pages.  These
> - *   pages have their ->index populated and are otherwise uninitialised.
> - *   The page at @pages->prev has the lowest file offset, and reads should be
> - *   issued in @pages->prev to @pages->next order.
> - * @nr_pages: The number of pages at *@pages
> + * @start: The number of the first page to read.
> + * @nr_pages: The number of consecutive pages to read.
>    * @get_block: The filesystem's block mapper function.
>    *
>    * This function walks the pages and the blocks within each page, building and
> @@ -381,36 +378,25 @@ static struct bio *do_mpage_readpage(struct mpage_readpage_args *args)
>    *
>    * This all causes the disk requests to be issued in the correct order.
>    */
> -int
> -mpage_readpages(struct address_space *mapping, struct list_head *pages,
> -				unsigned nr_pages, get_block_t get_block)
> +void mpage_readahead(struct readahead_control *rac, get_block_t get_block)
>   {
> +	struct page *page;
>   	struct mpage_readpage_args args = {
>   		.get_block = get_block,
>   		.is_readahead = true,
>   	};
> -	unsigned page_idx;
> -
> -	for (page_idx = 0; page_idx < nr_pages; page_idx++) {
> -		struct page *page = lru_to_page(pages);
>   
> +	readahead_for_each(rac, page) {
>   		prefetchw(&page->flags);
> -		list_del(&page->lru);
> -		if (!add_to_page_cache_lru(page, mapping,
> -					page->index,
> -					readahead_gfp_mask(mapping))) {
> -			args.page = page;
> -			args.nr_pages = nr_pages - page_idx;
> -			args.bio = do_mpage_readpage(&args);
> -		}
> +		args.page = page;
> +		args.nr_pages = readahead_count(rac);
> +		args.bio = do_mpage_readpage(&args);
>   		put_page(page);
>   	}
> -	BUG_ON(!list_empty(pages));
>   	if (args.bio)
>   		mpage_bio_submit(REQ_OP_READ, REQ_RAHEAD, args.bio);
> -	return 0;
>   }
> -EXPORT_SYMBOL(mpage_readpages);
> +EXPORT_SYMBOL(mpage_readahead);
>   
>   /*
>    * This isn't called much at all
> @@ -563,7 +549,7 @@ static int __mpage_writepage(struct page *page, struct writeback_control *wbc,
>   		 * Page has buffers, but they are all unmapped. The page was
>   		 * created by pagein or read over a hole which was handled by
>   		 * block_read_full_page().  If this address_space is also
> -		 * using mpage_readpages then this can rarely happen.
> +		 * using mpage_readahead then this can rarely happen.
>   		 */
>   		goto confused;
>   	}
> diff --git a/fs/nilfs2/inode.c b/fs/nilfs2/inode.c
> index 671085512e0f..ceeb3b441844 100644
> --- a/fs/nilfs2/inode.c
> +++ b/fs/nilfs2/inode.c
> @@ -145,18 +145,9 @@ static int nilfs_readpage(struct file *file, struct page *page)
>   	return mpage_readpage(page, nilfs_get_block);
>   }
>   
> -/**
> - * nilfs_readpages() - implement readpages() method of nilfs_aops {}
> - * address_space_operations.
> - * @file - file struct of the file to be read
> - * @mapping - address_space struct used for reading multiple pages
> - * @pages - the pages to be read
> - * @nr_pages - number of pages to be read
> - */
> -static int nilfs_readpages(struct file *file, struct address_space *mapping,
> -			   struct list_head *pages, unsigned int nr_pages)
> +static void nilfs_readahead(struct readahead_control *rac)
>   {
> -	return mpage_readpages(mapping, pages, nr_pages, nilfs_get_block);
> +	mpage_readahead(rac, nilfs_get_block);
>   }
>   
>   static int nilfs_writepages(struct address_space *mapping,
> @@ -308,7 +299,7 @@ const struct address_space_operations nilfs_aops = {
>   	.readpage		= nilfs_readpage,
>   	.writepages		= nilfs_writepages,
>   	.set_page_dirty		= nilfs_set_page_dirty,
> -	.readpages		= nilfs_readpages,
> +	.readahead		= nilfs_readahead,
>   	.write_begin		= nilfs_write_begin,
>   	.write_end		= nilfs_write_end,
>   	/* .releasepage		= nilfs_releasepage, */
> diff --git a/fs/ocfs2/aops.c b/fs/ocfs2/aops.c
> index 3a67a6518ddf..e8137efaafec 100644
> --- a/fs/ocfs2/aops.c
> +++ b/fs/ocfs2/aops.c
> @@ -350,14 +350,11 @@ static int ocfs2_readpage(struct file *file, struct page *page)
>    * grow out to a tree. If need be, detecting boundary extents could
>    * trivially be added in a future version of ocfs2_get_block().
>    */
> -static int ocfs2_readpages(struct file *filp, struct address_space *mapping,
> -			   struct list_head *pages, unsigned nr_pages)
> +static void ocfs2_readahead(struct readahead_control *rac)
>   {
> -	int ret, err = -EIO;
> -	struct inode *inode = mapping->host;
> +	int ret;
> +	struct inode *inode = rac->mapping->host;
>   	struct ocfs2_inode_info *oi = OCFS2_I(inode);
> -	loff_t start;
> -	struct page *last;
>   
>   	/*
>   	 * Use the nonblocking flag for the dlm code to avoid page
> @@ -365,36 +362,31 @@ static int ocfs2_readpages(struct file *filp, struct address_space *mapping,
>   	 */
>   	ret = ocfs2_inode_lock_full(inode, NULL, 0, OCFS2_LOCK_NONBLOCK);
>   	if (ret)
> -		return err;
> +		return;
>   
> -	if (down_read_trylock(&oi->ip_alloc_sem) == 0) {
> -		ocfs2_inode_unlock(inode, 0);
> -		return err;
> -	}
> +	if (down_read_trylock(&oi->ip_alloc_sem) == 0)
> +		goto out_unlock;
>   
>   	/*
>   	 * Don't bother with inline-data. There isn't anything
>   	 * to read-ahead in that case anyway...
>   	 */
>   	if (oi->ip_dyn_features & OCFS2_INLINE_DATA_FL)
> -		goto out_unlock;
> +		goto out_up;
>   
>   	/*
>   	 * Check whether a remote node truncated this file - we just
>   	 * drop out in that case as it's not worth handling here.
>   	 */
> -	last = lru_to_page(pages);
> -	start = (loff_t)last->index << PAGE_SHIFT;
> -	if (start >= i_size_read(inode))
> -		goto out_unlock;
> +	if (readahead_offset(rac) >= i_size_read(inode))
> +		goto out_up;
>   
> -	err = mpage_readpages(mapping, pages, nr_pages, ocfs2_get_block);
> +	mpage_readahead(rac, ocfs2_get_block);
>   
> -out_unlock:
> +out_up:
>   	up_read(&oi->ip_alloc_sem);
> +out_unlock:
>   	ocfs2_inode_unlock(inode, 0);
> -
> -	return err;
>   }
>   
>   /* Note: Because we don't support holes, our allocation has
> @@ -2474,7 +2466,7 @@ static ssize_t ocfs2_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
>   
>   const struct address_space_operations ocfs2_aops = {
>   	.readpage		= ocfs2_readpage,
> -	.readpages		= ocfs2_readpages,
> +	.readahead		= ocfs2_readahead,
>   	.writepage		= ocfs2_writepage,
>   	.write_begin		= ocfs2_write_begin,
>   	.write_end		= ocfs2_write_end,

Looks good on ocfs2 part.

Thanks,

Junxiao.

> diff --git a/fs/omfs/file.c b/fs/omfs/file.c
> index d640b9388238..d7b5f09d298c 100644
> --- a/fs/omfs/file.c
> +++ b/fs/omfs/file.c
> @@ -289,10 +289,9 @@ static int omfs_readpage(struct file *file, struct page *page)
>   	return block_read_full_page(page, omfs_get_block);
>   }
>   
> -static int omfs_readpages(struct file *file, struct address_space *mapping,
> -		struct list_head *pages, unsigned nr_pages)
> +static void omfs_readahead(struct readahead_control *rac)
>   {
> -	return mpage_readpages(mapping, pages, nr_pages, omfs_get_block);
> +	mpage_readahead(rac, omfs_get_block);
>   }
>   
>   static int omfs_writepage(struct page *page, struct writeback_control *wbc)
> @@ -373,7 +372,7 @@ const struct inode_operations omfs_file_inops = {
>   
>   const struct address_space_operations omfs_aops = {
>   	.readpage = omfs_readpage,
> -	.readpages = omfs_readpages,
> +	.readahead = omfs_readahead,
>   	.writepage = omfs_writepage,
>   	.writepages = omfs_writepages,
>   	.write_begin = omfs_write_begin,
> diff --git a/fs/qnx6/inode.c b/fs/qnx6/inode.c
> index 345db56c98fd..755293c8c71a 100644
> --- a/fs/qnx6/inode.c
> +++ b/fs/qnx6/inode.c
> @@ -99,10 +99,9 @@ static int qnx6_readpage(struct file *file, struct page *page)
>   	return mpage_readpage(page, qnx6_get_block);
>   }
>   
> -static int qnx6_readpages(struct file *file, struct address_space *mapping,
> -		   struct list_head *pages, unsigned nr_pages)
> +static void qnx6_readahead(struct readahead_control *rac)
>   {
> -	return mpage_readpages(mapping, pages, nr_pages, qnx6_get_block);
> +	mpage_readahead(rac, qnx6_get_block);
>   }
>   
>   /*
> @@ -499,7 +498,7 @@ static sector_t qnx6_bmap(struct address_space *mapping, sector_t block)
>   }
>   static const struct address_space_operations qnx6_aops = {
>   	.readpage	= qnx6_readpage,
> -	.readpages	= qnx6_readpages,
> +	.readahead	= qnx6_readahead,
>   	.bmap		= qnx6_bmap
>   };
>   
> diff --git a/fs/reiserfs/inode.c b/fs/reiserfs/inode.c
> index 6419e6dacc39..0031070b3692 100644
> --- a/fs/reiserfs/inode.c
> +++ b/fs/reiserfs/inode.c
> @@ -1160,11 +1160,9 @@ int reiserfs_get_block(struct inode *inode, sector_t block,
>   	return retval;
>   }
>   
> -static int
> -reiserfs_readpages(struct file *file, struct address_space *mapping,
> -		   struct list_head *pages, unsigned nr_pages)
> +static void reiserfs_readahead(struct readahead_control *rac)
>   {
> -	return mpage_readpages(mapping, pages, nr_pages, reiserfs_get_block);
> +	mpage_readahead(rac, reiserfs_get_block);
>   }
>   
>   /*
> @@ -3434,7 +3432,7 @@ int reiserfs_setattr(struct dentry *dentry, struct iattr *attr)
>   const struct address_space_operations reiserfs_address_space_operations = {
>   	.writepage = reiserfs_writepage,
>   	.readpage = reiserfs_readpage,
> -	.readpages = reiserfs_readpages,
> +	.readahead = reiserfs_readahead,
>   	.releasepage = reiserfs_releasepage,
>   	.invalidatepage = reiserfs_invalidatepage,
>   	.write_begin = reiserfs_write_begin,
> diff --git a/fs/udf/inode.c b/fs/udf/inode.c
> index e875bc5668ee..adaba8e8b326 100644
> --- a/fs/udf/inode.c
> +++ b/fs/udf/inode.c
> @@ -195,10 +195,9 @@ static int udf_readpage(struct file *file, struct page *page)
>   	return mpage_readpage(page, udf_get_block);
>   }
>   
> -static int udf_readpages(struct file *file, struct address_space *mapping,
> -			struct list_head *pages, unsigned nr_pages)
> +static void udf_readahead(struct readahead_control *rac)
>   {
> -	return mpage_readpages(mapping, pages, nr_pages, udf_get_block);
> +	mpage_readahead(rac, udf_get_block);
>   }
>   
>   static int udf_write_begin(struct file *file, struct address_space *mapping,
> @@ -234,7 +233,7 @@ static sector_t udf_bmap(struct address_space *mapping, sector_t block)
>   
>   const struct address_space_operations udf_aops = {
>   	.readpage	= udf_readpage,
> -	.readpages	= udf_readpages,
> +	.readahead	= udf_readahead,
>   	.writepage	= udf_writepage,
>   	.writepages	= udf_writepages,
>   	.write_begin	= udf_write_begin,
> diff --git a/include/linux/mpage.h b/include/linux/mpage.h
> index 001f1fcf9836..f4f5e90a6844 100644
> --- a/include/linux/mpage.h
> +++ b/include/linux/mpage.h
> @@ -13,9 +13,9 @@
>   #ifdef CONFIG_BLOCK
>   
>   struct writeback_control;
> +struct readahead_control;
>   
> -int mpage_readpages(struct address_space *mapping, struct list_head *pages,
> -				unsigned nr_pages, get_block_t get_block);
> +void mpage_readahead(struct readahead_control *, get_block_t get_block);
>   int mpage_readpage(struct page *page, get_block_t get_block);
>   int mpage_writepages(struct address_space *mapping,
>   		struct writeback_control *wbc, get_block_t get_block);
> diff --git a/mm/migrate.c b/mm/migrate.c
> index b1092876e537..a32122095702 100644
> --- a/mm/migrate.c
> +++ b/mm/migrate.c
> @@ -1020,7 +1020,7 @@ static int __unmap_and_move(struct page *page, struct page *newpage,
>   		 * to the LRU. Later, when the IO completes the pages are
>   		 * marked uptodate and unlocked. However, the queueing
>   		 * could be merging multiple pages for one bio (e.g.
> -		 * mpage_readpages). If an allocation happens for the
> +		 * mpage_readahead). If an allocation happens for the
>   		 * second or third page, the process can end up locking
>   		 * the same page twice and deadlocking. Rather than
>   		 * trying to be clever about what pages can be locked,

[Ocfs2-devel] [PATCH v5 01/13] mm: Fix the return type of __do_page_cache_readahead

[John Hubbard]

On 2/10/20 5:03 PM, Matthew Wilcox wrote:
> From: "Matthew Wilcox (Oracle)" <willy@infradead.org>
> 
> ra_submit() which is a wrapper around __do_page_cache_readahead() already
> returns an unsigned long, and the 'nr_to_read' parameter is an unsigned
> long, so fix __do_page_cache_readahead() to return an unsigned long,
> even though I'm pretty sure we're not going to readahead more than 2^32
> pages ever.
> 
> Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
> ---
>  mm/internal.h  | 2 +-
>  mm/readahead.c | 4 ++--
>  2 files changed, 3 insertions(+), 3 deletions(-)
> 
> diff --git a/mm/internal.h b/mm/internal.h
> index 3cf20ab3ca01..41b93c4b3ab7 100644
> --- a/mm/internal.h
> +++ b/mm/internal.h
> @@ -49,7 +49,7 @@ void unmap_page_range(struct mmu_gather *tlb,
>  			     unsigned long addr, unsigned long end,
>  			     struct zap_details *details);
>  
> -extern unsigned int __do_page_cache_readahead(struct address_space *mapping,
> +extern unsigned long __do_page_cache_readahead(struct address_space *mapping,
>  		struct file *filp, pgoff_t offset, unsigned long nr_to_read,
>  		unsigned long lookahead_size);
>  
> diff --git a/mm/readahead.c b/mm/readahead.c
> index 2fe72cd29b47..6bf73ef33b7e 100644
> --- a/mm/readahead.c
> +++ b/mm/readahead.c
> @@ -152,7 +152,7 @@ static int read_pages(struct address_space *mapping, struct file *filp,
>   *
>   * Returns the number of pages requested, or the maximum amount of I/O allowed.
>   */
> -unsigned int __do_page_cache_readahead(struct address_space *mapping,
> +unsigned long __do_page_cache_readahead(struct address_space *mapping,
>  		struct file *filp, pgoff_t offset, unsigned long nr_to_read,
>  		unsigned long lookahead_size)
>  {
> @@ -161,7 +161,7 @@ unsigned int __do_page_cache_readahead(struct address_space *mapping,
>  	unsigned long end_index;	/* The last page we want to read */
>  	LIST_HEAD(page_pool);
>  	int page_idx;


What about page_idx, too? It should also have the same data type as nr_pages, as long as
we're trying to be consistent on this point.

Just want to ensure we're ready to handle those 2^33+ page readaheads... :)


thanks,
-- 
John Hubbard
NVIDIA
> -	unsigned int nr_pages = 0;
> +	unsigned long nr_pages = 0;
>  	loff_t isize = i_size_read(inode);
>  	gfp_t gfp_mask = readahead_gfp_mask(mapping);
>  
> 

[Ocfs2-devel] [PATCH v5 03/13] mm: Put readahead pages in cache earlier

[John Hubbard]

On 2/10/20 5:03 PM, Matthew Wilcox wrote:
> From: "Matthew Wilcox (Oracle)" <willy@infradead.org>
> 
> At allocation time, put the pages in the cache unless we're using
> ->readpages.
> 
> Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
> ---
>  mm/readahead.c | 66 ++++++++++++++++++++++++++++++++------------------
>  1 file changed, 42 insertions(+), 24 deletions(-)
> 
> diff --git a/mm/readahead.c b/mm/readahead.c
> index fc77d13af556..96c6ca68a174 100644
> --- a/mm/readahead.c
> +++ b/mm/readahead.c
> @@ -114,10 +114,10 @@ int read_cache_pages(struct address_space *mapping, struct list_head *pages,
>  EXPORT_SYMBOL(read_cache_pages);
>  
>  static void read_pages(struct address_space *mapping, struct file *filp,
> -		struct list_head *pages, unsigned int nr_pages, gfp_t gfp)
> +		struct list_head *pages, pgoff_t start,
> +		unsigned int nr_pages)
>  {
>  	struct blk_plug plug;
> -	unsigned page_idx;
>  
>  	blk_start_plug(&plug);
>  
> @@ -125,18 +125,17 @@ static void read_pages(struct address_space *mapping, struct file *filp,
>  		mapping->a_ops->readpages(filp, mapping, pages, nr_pages);
>  		/* Clean up the remaining pages */
>  		put_pages_list(pages);
> -		goto out;
> -	}
> +	} else {
> +		struct page *page;
> +		unsigned long index;
>  
> -	for (page_idx = 0; page_idx < nr_pages; page_idx++) {
> -		struct page *page = lru_to_page(pages);
> -		list_del(&page->lru);
> -		if (!add_to_page_cache_lru(page, mapping, page->index, gfp))
> +		xa_for_each_range(&mapping->i_pages, index, page, start,
> +				start + nr_pages - 1) {
>  			mapping->a_ops->readpage(filp, page);
> -		put_page(page);
> +			put_page(page);
> +		}
>  	}
>  
> -out:
>  	blk_finish_plug(&plug);
>  }
>  
> @@ -149,17 +148,18 @@ static void read_pages(struct address_space *mapping, struct file *filp,
>   * Returns the number of pages requested, or the maximum amount of I/O allowed.
>   */
>  unsigned long __do_page_cache_readahead(struct address_space *mapping,
> -		struct file *filp, pgoff_t offset, unsigned long nr_to_read,
> +		struct file *filp, pgoff_t start, unsigned long nr_to_read,
>  		unsigned long lookahead_size)
>  {
>  	struct inode *inode = mapping->host;
> -	struct page *page;
>  	unsigned long end_index;	/* The last page we want to read */
>  	LIST_HEAD(page_pool);
>  	int page_idx;
> +	pgoff_t page_offset = start;
>  	unsigned long nr_pages = 0;
>  	loff_t isize = i_size_read(inode);
>  	gfp_t gfp_mask = readahead_gfp_mask(mapping);
> +	bool use_list = mapping->a_ops->readpages;
>  
>  	if (isize == 0)
>  		goto out;
> @@ -170,7 +170,7 @@ unsigned long __do_page_cache_readahead(struct address_space *mapping,
>  	 * Preallocate as many pages as we will need.
>  	 */
>  	for (page_idx = 0; page_idx < nr_to_read; page_idx++) {
> -		pgoff_t page_offset = offset + page_idx;
> +		struct page *page;

I see two distinct things happening in this patch, and I think they want to each be
in their own patch:

1) A significant refactoring of the page loop, and

2) Changing the place where the page is added to the page cache. (Only this one is 
   mentioned in the commit description.)

We'll be more likely to spot any errors if these are teased apart.


thanks,
-- 
John Hubbard
NVIDIA

>  
>  		if (page_offset > end_index)
>  			break;
> @@ -178,25 +178,43 @@ unsigned long __do_page_cache_readahead(struct address_space *mapping,
>  		page = xa_load(&mapping->i_pages, page_offset);
>  		if (page && !xa_is_value(page)) {
>  			/*
> -			 * Page already present?  Kick off the current batch of
> -			 * contiguous pages before continuing with the next
> -			 * batch.
> +			 * Page already present?  Kick off the current batch
> +			 * of contiguous pages before continuing with the
> +			 * next batch.
> +			 * It's possible this page is the page we should
> +			 * be marking with PageReadahead.  However, we
> +			 * don't have a stable ref to this page so it might
> +			 * be reallocated to another user before we can set
> +			 * the bit.  There's probably another page in the
> +			 * cache marked with PageReadahead from the other
> +			 * process which accessed this file.
>  			 */
> -			if (nr_pages)
> -				read_pages(mapping, filp, &page_pool, nr_pages,
> -						gfp_mask);
> -			nr_pages = 0;
> -			continue;
> +			goto skip;
>  		}
>  
>  		page = __page_cache_alloc(gfp_mask);
>  		if (!page)
>  			break;
> -		page->index = page_offset;
> -		list_add(&page->lru, &page_pool);
> +		if (use_list) {
> +			page->index = page_offset;
> +			list_add(&page->lru, &page_pool);
> +		} else if (add_to_page_cache_lru(page, mapping, page_offset,
> +					gfp_mask) < 0) {
> +			put_page(page);
> +			goto skip;
> +		}
> +
>  		if (page_idx == nr_to_read - lookahead_size)
>  			SetPageReadahead(page);
>  		nr_pages++;
> +		page_offset++;
> +		continue;
> +skip:
> +		if (nr_pages)
> +			read_pages(mapping, filp, &page_pool, start, nr_pages);
> +		nr_pages = 0;
> +		page_offset++;
> +		start = page_offset;
>  	}
>  
>  	/*
> @@ -205,7 +223,7 @@ unsigned long __do_page_cache_readahead(struct address_space *mapping,
>  	 * will then handle the error.
>  	 */
>  	if (nr_pages)
> -		read_pages(mapping, filp, &page_pool, nr_pages, gfp_mask);
> +		read_pages(mapping, filp, &page_pool, start, nr_pages);
>  	BUG_ON(!list_empty(&page_pool));
>  out:
>  	return nr_pages;
> 

[Ocfs2-devel] [PATCH v5 01/13] mm: Fix the return type of __do_page_cache_readahead

[Matthew Wilcox]

On Thu, Feb 13, 2020 at 07:19:53PM -0800, John Hubbard wrote:
> On 2/10/20 5:03 PM, Matthew Wilcox wrote:
> > @@ -161,7 +161,7 @@ unsigned int __do_page_cache_readahead(struct address_space *mapping,
> >  	unsigned long end_index;	/* The last page we want to read */
> >  	LIST_HEAD(page_pool);
> >  	int page_idx;
> 
> 
> What about page_idx, too? It should also have the same data type as nr_pages, as long as
> we're trying to be consistent on this point.
> 
> Just want to ensure we're ready to handle those 2^33+ page readaheads... :)

Nah, this is just a type used internally to the function.  Getting the
API right for the callers is the important part.

[Ocfs2-devel] [PATCH v5 01/13] mm: Fix the return type of __do_page_cache_readahead

[John Hubbard]

On 2/13/20 8:21 PM, Matthew Wilcox wrote:
> On Thu, Feb 13, 2020 at 07:19:53PM -0800, John Hubbard wrote:
>> On 2/10/20 5:03 PM, Matthew Wilcox wrote:
>>> @@ -161,7 +161,7 @@ unsigned int __do_page_cache_readahead(struct address_space *mapping,
>>>  	unsigned long end_index;	/* The last page we want to read */
>>>  	LIST_HEAD(page_pool);
>>>  	int page_idx;
>>
>>
>> What about page_idx, too? It should also have the same data type as nr_pages, as long as
>> we're trying to be consistent on this point.
>>
>> Just want to ensure we're ready to handle those 2^33+ page readaheads... :)
> 
> Nah, this is just a type used internally to the function.  Getting the
> API right for the callers is the important part.
> 

Agreed that the real point of this is to match up the API, but why not finish the job
by going all the way through? It's certainly not something we need to lose sleep over,
but it does seem like you don't want to have code like this:

        for (page_idx = 0; page_idx < nr_to_read; page_idx++) {

...with the ability, technically, to overflow page_idx due to it being an int,
while nr_to_read is an unsigned long. (And the new sanitizers and checkers are
apt to complain about it, btw.)

(Apologies if there is some kernel coding idiom that I still haven't learned, about this 
sort of thing.)

thanks,
-- 
John Hubbard
NVIDIA

[Ocfs2-devel] [PATCH v5 04/13] mm: Add readahead address space operation

[John Hubbard]

On 2/10/20 5:03 PM, Matthew Wilcox wrote:
> From: "Matthew Wilcox (Oracle)" <willy@infradead.org>
> 
> This replaces ->readpages with a saner interface:
>  - Return void instead of an ignored error code.
>  - Pages are already in the page cache when ->readahead is called.
>  - Implementation looks up the pages in the page cache instead of
>    having them passed in a linked list.
> 
> Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
> ---
>  Documentation/filesystems/locking.rst |  6 ++-
>  Documentation/filesystems/vfs.rst     | 13 +++++++
>  include/linux/fs.h                    |  2 +
>  include/linux/pagemap.h               | 54 +++++++++++++++++++++++++++
>  mm/readahead.c                        | 48 ++++++++++++++----------
>  5 files changed, 102 insertions(+), 21 deletions(-)
> 

A minor question below, but either way you can add:

    Reviewed-by: John Hubbard <jhubbard@nvidia.com>



> diff --git a/Documentation/filesystems/locking.rst b/Documentation/filesystems/locking.rst
> index 5057e4d9dcd1..0ebc4491025a 100644
> --- a/Documentation/filesystems/locking.rst
> +++ b/Documentation/filesystems/locking.rst
> @@ -239,6 +239,7 @@ prototypes::
>  	int (*readpage)(struct file *, struct page *);
>  	int (*writepages)(struct address_space *, struct writeback_control *);
>  	int (*set_page_dirty)(struct page *page);
> +	void (*readahead)(struct readahead_control *);
>  	int (*readpages)(struct file *filp, struct address_space *mapping,
>  			struct list_head *pages, unsigned nr_pages);
>  	int (*write_begin)(struct file *, struct address_space *mapping,
> @@ -271,7 +272,8 @@ writepage:		yes, unlocks (see below)
>  readpage:		yes, unlocks
>  writepages:
>  set_page_dirty		no
> -readpages:
> +readahead:		yes, unlocks
> +readpages:		no
>  write_begin:		locks the page		 exclusive
>  write_end:		yes, unlocks		 exclusive
>  bmap:
> @@ -295,6 +297,8 @@ the request handler (/dev/loop).
>  ->readpage() unlocks the page, either synchronously or via I/O
>  completion.
>  
> +->readahead() unlocks the pages like ->readpage().
> +
>  ->readpages() populates the pagecache with the passed pages and starts
>  I/O against them.  They come unlocked upon I/O completion.
>  
> diff --git a/Documentation/filesystems/vfs.rst b/Documentation/filesystems/vfs.rst
> index 7d4d09dd5e6d..cabee16b7406 100644
> --- a/Documentation/filesystems/vfs.rst
> +++ b/Documentation/filesystems/vfs.rst
> @@ -706,6 +706,7 @@ cache in your filesystem.  The following members are defined:
>  		int (*readpage)(struct file *, struct page *);
>  		int (*writepages)(struct address_space *, struct writeback_control *);
>  		int (*set_page_dirty)(struct page *page);
> +		void (*readahead)(struct readahead_control *);
>  		int (*readpages)(struct file *filp, struct address_space *mapping,
>  				 struct list_head *pages, unsigned nr_pages);
>  		int (*write_begin)(struct file *, struct address_space *mapping,
> @@ -781,12 +782,24 @@ cache in your filesystem.  The following members are defined:
>  	If defined, it should set the PageDirty flag, and the
>  	PAGECACHE_TAG_DIRTY tag in the radix tree.
>  
> +``readahead``
> +	Called by the VM to read pages associated with the address_space
> +	object.  The pages are consecutive in the page cache and are
> +	locked.  The implementation should decrement the page refcount
> +	after starting I/O on each page.  Usually the page will be
> +	unlocked by the I/O completion handler.  If the function does
> +	not attempt I/O on some pages, the caller will decrement the page
> +	refcount and unlock the pages for you.	Set PageUptodate if the
> +	I/O completes successfully.  Setting PageError on any page will
> +	be ignored; simply unlock the page if an I/O error occurs.
> +
>  ``readpages``
>  	called by the VM to read pages associated with the address_space
>  	object.  This is essentially just a vector version of readpage.
>  	Instead of just one page, several pages are requested.
>  	readpages is only used for read-ahead, so read errors are
>  	ignored.  If anything goes wrong, feel free to give up.
> +        This interface is deprecated; implement readahead instead.
>  
>  ``write_begin``
>  	Called by the generic buffered write code to ask the filesystem
> diff --git a/include/linux/fs.h b/include/linux/fs.h
> index 3cd4fe6b845e..d4e2d2964346 100644
> --- a/include/linux/fs.h
> +++ b/include/linux/fs.h
> @@ -292,6 +292,7 @@ enum positive_aop_returns {
>  struct page;
>  struct address_space;
>  struct writeback_control;
> +struct readahead_control;
>  
>  /*
>   * Write life time hint values.
> @@ -375,6 +376,7 @@ struct address_space_operations {
>  	 */
>  	int (*readpages)(struct file *filp, struct address_space *mapping,
>  			struct list_head *pages, unsigned nr_pages);
> +	void (*readahead)(struct readahead_control *);
>  
>  	int (*write_begin)(struct file *, struct address_space *mapping,
>  				loff_t pos, unsigned len, unsigned flags,
> diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h
> index ccb14b6a16b5..13efafaf7e1f 100644
> --- a/include/linux/pagemap.h
> +++ b/include/linux/pagemap.h
> @@ -630,6 +630,60 @@ static inline int add_to_page_cache(struct page *page,
>  	return error;
>  }
>  
> +/*
> + * Readahead is of a block of consecutive pages.
> + */
> +struct readahead_control {
> +	struct file *file;
> +	struct address_space *mapping;
> +/* private: use the readahead_* accessors instead */
> +	pgoff_t start;
> +	unsigned int nr_pages;
> +	unsigned int batch_count;
> +};
> +
> +static inline struct page *readahead_page(struct readahead_control *rac)
> +{
> +	struct page *page;
> +
> +	if (!rac->nr_pages)
> +		return NULL;
> +
> +	page = xa_load(&rac->mapping->i_pages, rac->start);


Is it worth asserting that the page was found:

	VM_BUG_ON_PAGE(!page || xa_is_value(page), page);

? Or is that overkill here?


> +	VM_BUG_ON_PAGE(!PageLocked(page), page);
> +	rac->batch_count = hpage_nr_pages(page);
> +	rac->start += rac->batch_count;


The above was surprising, until I saw the other thread with Dave and you.
I was reviewing this patchset in order to have a chance at understanding the 
follow-on patchset ("Large pages in the page cache"), and it seems like that
feature has a solid head start here. :)  


thanks,
-- 
John Hubbard
NVIDIA

> +
> +	return page;
> +}
> +
> +#define readahead_for_each(rac, page)					\
> +	for (; (page = readahead_page(rac)); rac->nr_pages -= rac->batch_count)
> +
> +/* The byte offset into the file of this readahead block */
> +static inline loff_t readahead_offset(struct readahead_control *rac)
> +{
> +	return (loff_t)rac->start * PAGE_SIZE;
> +}
> +
> +/* The number of bytes in this readahead block */
> +static inline loff_t readahead_length(struct readahead_control *rac)
> +{
> +	return (loff_t)rac->nr_pages * PAGE_SIZE;
> +}
> +
> +/* The index of the first page in this readahead block */
> +static inline unsigned int readahead_index(struct readahead_control *rac)
> +{
> +	return rac->start;
> +}
> +
> +/* The number of pages in this readahead block */
> +static inline unsigned int readahead_count(struct readahead_control *rac)
> +{
> +	return rac->nr_pages;
> +}
> +
>  static inline unsigned long dir_pages(struct inode *inode)
>  {
>  	return (unsigned long)(inode->i_size + PAGE_SIZE - 1) >>
> diff --git a/mm/readahead.c b/mm/readahead.c
> index 96c6ca68a174..933b32e0c90a 100644
> --- a/mm/readahead.c
> +++ b/mm/readahead.c
> @@ -113,25 +113,30 @@ int read_cache_pages(struct address_space *mapping, struct list_head *pages,
>  
>  EXPORT_SYMBOL(read_cache_pages);
>  
> -static void read_pages(struct address_space *mapping, struct file *filp,
> -		struct list_head *pages, pgoff_t start,
> -		unsigned int nr_pages)
> +static void read_pages(struct readahead_control *rac, struct list_head *pages)
>  {
> +	struct page *page;
>  	struct blk_plug plug;
> +	const struct address_space_operations *aops = rac->mapping->a_ops;
> +
> +	if (rac->nr_pages == 0)
> +		return;
>  
>  	blk_start_plug(&plug);
>  
> -	if (mapping->a_ops->readpages) {
> -		mapping->a_ops->readpages(filp, mapping, pages, nr_pages);
> +	if (aops->readahead) {
> +		aops->readahead(rac);
> +		readahead_for_each(rac, page) {
> +			unlock_page(page);
> +			put_page(page);
> +		}
> +	} else if (aops->readpages) {
> +		aops->readpages(rac->file, rac->mapping, pages, rac->nr_pages);
>  		/* Clean up the remaining pages */
>  		put_pages_list(pages);
>  	} else {
> -		struct page *page;
> -		unsigned long index;
> -
> -		xa_for_each_range(&mapping->i_pages, index, page, start,
> -				start + nr_pages - 1) {
> -			mapping->a_ops->readpage(filp, page);
> +		readahead_for_each(rac, page) {
> +			aops->readpage(rac->file, page);
>  			put_page(page);
>  		}
>  	}
> @@ -156,10 +161,15 @@ unsigned long __do_page_cache_readahead(struct address_space *mapping,
>  	LIST_HEAD(page_pool);
>  	int page_idx;
>  	pgoff_t page_offset = start;
> -	unsigned long nr_pages = 0;
>  	loff_t isize = i_size_read(inode);
>  	gfp_t gfp_mask = readahead_gfp_mask(mapping);
>  	bool use_list = mapping->a_ops->readpages;
> +	struct readahead_control rac = {
> +		.mapping = mapping,
> +		.file = filp,
> +		.start = start,
> +		.nr_pages = 0,
> +	};
>  
>  	if (isize == 0)
>  		goto out;
> @@ -206,15 +216,14 @@ unsigned long __do_page_cache_readahead(struct address_space *mapping,
>  
>  		if (page_idx == nr_to_read - lookahead_size)
>  			SetPageReadahead(page);
> -		nr_pages++;
> +		rac.nr_pages++;
>  		page_offset++;
>  		continue;
>  skip:
> -		if (nr_pages)
> -			read_pages(mapping, filp, &page_pool, start, nr_pages);
> -		nr_pages = 0;
> +		read_pages(&rac, &page_pool);
> +		rac.nr_pages = 0;
>  		page_offset++;
> -		start = page_offset;
> +		rac.start = page_offset;
>  	}
>  
>  	/*
> @@ -222,11 +231,10 @@ unsigned long __do_page_cache_readahead(struct address_space *mapping,
>  	 * uptodate then the caller will launch readpage again, and
>  	 * will then handle the error.
>  	 */
> -	if (nr_pages)
> -		read_pages(mapping, filp, &page_pool, start, nr_pages);
> +	read_pages(&rac, &page_pool);
>  	BUG_ON(!list_empty(&page_pool));
>  out:
> -	return nr_pages;
> +	return rac.nr_pages;
>  }
>  
>  /*
> 

[Ocfs2-devel] [PATCH v5 01/13] mm: Fix the return type of __do_page_cache_readahead

[Matthew Wilcox]

On Mon, Feb 10, 2020 at 05:03:36PM -0800, Matthew Wilcox wrote:
> From: "Matthew Wilcox (Oracle)" <willy@infradead.org>
> 
> ra_submit() which is a wrapper around __do_page_cache_readahead() already
> returns an unsigned long, and the 'nr_to_read' parameter is an unsigned
> long, so fix __do_page_cache_readahead() to return an unsigned long,
> even though I'm pretty sure we're not going to readahead more than 2^32
> pages ever.

I was going through this and realised it's completely pointless -- the
returned value from ra_submit() and __do_page_cache_readahead() is
eventually ignored through all paths.  So I'm replacing this patch with
one that makes everything return void.

[Ocfs2-devel] [PATCH v5 04/13] mm: Add readahead address space operation

[Matthew Wilcox]

On Thu, Feb 13, 2020 at 09:36:25PM -0800, John Hubbard wrote:
> > +static inline struct page *readahead_page(struct readahead_control *rac)
> > +{
> > +	struct page *page;
> > +
> > +	if (!rac->nr_pages)
> > +		return NULL;
> > +
> > +	page = xa_load(&rac->mapping->i_pages, rac->start);
> 
> 
> Is it worth asserting that the page was found:
> 
> 	VM_BUG_ON_PAGE(!page || xa_is_value(page), page);
> 
> ? Or is that overkill here?

It shouldn't be possible since they were just added in a locked state.
If it did happen, it'll be caught by the assert below -- dereferencing
a NULL pointer or a shadow entry is not going to go well.

> > +	VM_BUG_ON_PAGE(!PageLocked(page), page);
> > +	rac->batch_count = hpage_nr_pages(page);
> > +	rac->start += rac->batch_count;
> 
> The above was surprising, until I saw the other thread with Dave and you.
> I was reviewing this patchset in order to have a chance at understanding the 
> follow-on patchset ("Large pages in the page cache"), and it seems like that
> feature has a solid head start here. :)  

Right, I'll document that.

[Ocfs2-devel] [PATCH v5 03/13] mm: Put readahead pages in cache earlier

[Matthew Wilcox]

On Thu, Feb 13, 2020 at 07:36:38PM -0800, John Hubbard wrote:
> I see two distinct things happening in this patch, and I think they want to each be
> in their own patch:
> 
> 1) A significant refactoring of the page loop, and
> 
> 2) Changing the place where the page is added to the page cache. (Only this one is 
>    mentioned in the commit description.)
> 
> We'll be more likely to spot any errors if these are teased apart.

Thanks.  I ended up splitting this patch into three, each hopefully
easier to understand.