mm/readahead: make do_page_cache_ra take a readahead_control

void force_page_cache_readahead(struct address_space *, struct file *,

		pgoff_t index, unsigned long nr_to_read);

void __do_page_cache_readahead(struct address_space *, struct file *,

		pgoff_t index, unsigned long nr_to_read,

		unsigned long lookahead_size);

void do_page_cache_ra(struct readahead_control *,

		unsigned long nr_to_read, unsigned long lookahead_size);

/*

 * Submit IO for the read-ahead request in file_ra_state.

 */

static inline void ra_submit(struct file_ra_state *ra,

		struct address_space *mapping, struct file *filp)

		struct address_space *mapping, struct file *file)

{

	__do_page_cache_readahead(mapping, filp,

			ra->start, ra->size, ra->async_size);

	DEFINE_READAHEAD(ractl, file, mapping, ra->start);

	do_page_cache_ra(&ractl, ra->size, ra->async_size);

}

struct page *find_get_entry(struct address_space *mapping, pgoff_t index);

EXPORT_SYMBOL_GPL(page_cache_ra_unbounded);

/*

 * __do_page_cache_readahead() actually reads a chunk of disk.  It allocates

 * do_page_cache_ra() actually reads a chunk of disk.  It allocates

 * the pages first, then submits them for I/O. This avoids the very bad

 * behaviour which would occur if page allocations are causing VM writeback.

 * We really don't want to intermingle reads and writes like that.

 */

void __do_page_cache_readahead(struct address_space *mapping,

		struct file *file, pgoff_t index, unsigned long nr_to_read,

		unsigned long lookahead_size)

void do_page_cache_ra(struct readahead_control *ractl,

		unsigned long nr_to_read, unsigned long lookahead_size)

{

	DEFINE_READAHEAD(ractl, file, mapping, index);

	struct inode *inode = mapping->host;

	struct inode *inode = ractl->mapping->host;

	unsigned long index = readahead_index(ractl);

	loff_t isize = i_size_read(inode);

	pgoff_t end_index;	/* The last page we want to read */

	if (nr_to_read > end_index - index)

		nr_to_read = end_index - index + 1;

	page_cache_ra_unbounded(&ractl, nr_to_read, lookahead_size);

	page_cache_ra_unbounded(ractl, nr_to_read, lookahead_size);

}

/*

 * memory at once.

 */

void force_page_cache_readahead(struct address_space *mapping,

		struct file *filp, pgoff_t index, unsigned long nr_to_read)

		struct file *file, pgoff_t index, unsigned long nr_to_read)

{

	DEFINE_READAHEAD(ractl, file, mapping, index);

	struct backing_dev_info *bdi = inode_to_bdi(mapping->host);

	struct file_ra_state *ra = &filp->f_ra;

	struct file_ra_state *ra = &file->f_ra;

	unsigned long max_pages;

	if (unlikely(!mapping->a_ops->readpage && !mapping->a_ops->readpages &&

		if (this_chunk > nr_to_read)

			this_chunk = nr_to_read;

		__do_page_cache_readahead(mapping, filp, index, this_chunk, 0);

		do_page_cache_ra(&ractl, this_chunk, 0);

		index += this_chunk;

		nr_to_read -= this_chunk;

 * A minimal readahead algorithm for trivial sequential/random reads.

 */

static void ondemand_readahead(struct address_space *mapping,

		struct file_ra_state *ra, struct file *filp,

		struct file_ra_state *ra, struct file *file,

		bool hit_readahead_marker, pgoff_t index,

		unsigned long req_size)

{

	DEFINE_READAHEAD(ractl, file, mapping, index);

	struct backing_dev_info *bdi = inode_to_bdi(mapping->host);

	unsigned long max_pages = ra->ra_pages;

	unsigned long add_pages;

	 * standalone, small random read

	 * Read as is, and do not pollute the readahead state.

	 */

	__do_page_cache_readahead(mapping, filp, index, req_size, 0);

	do_page_cache_ra(&ractl, req_size, 0);

	return;

initial_readahead:

		}

	}

	ra_submit(ra, mapping, filp);

	ractl._index = ra->start;

	do_page_cache_ra(&ractl, ra->size, ra->async_size);

}

/**