lk/linux-kernel-test
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

readahead: split ondemand readahead interface into two functions

Browse Source 
Split ondemand readahead interface into two functions.  I think this makes it
a little clearer for non-readahead experts (like Rusty).

Internally they both call ondemand_readahead(), but the page argument is
changed to an obvious boolean flag.

Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
Signed-off-by: Fengguang Wu <wfg@mail.ustc.edu.cn>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Rusty Russell
2007-07-19 01:48:08 -07:00
committed by Linus Torvalds
parent fe3cba17c4
commit cf914a7d65
6 changed files with 85 additions and 56 deletions
Download Patch File Download Diff File Expand all files Collapse all files

97
mm/readahead.c
View File

@ -359,7 +359,7 @@ static unsigned long get_next_ra_size(struct file_ra_state *ra,
static unsigned long
ondemand_readahead(struct address_space *mapping,
struct file_ra_state *ra, struct file *filp,
struct page *page, pgoff_t offset,
bool hit_readahead_marker, pgoff_t offset,
unsigned long req_size)
{
unsigned long max; /* max readahead pages */
@ -387,7 +387,7 @@ ondemand_readahead(struct address_space *mapping,
* Standalone, small read.
* Read as is, and do not pollute the readahead state.
*/
if (!page && !sequential) {
if (!hit_readahead_marker && !sequential) {
return __do_page_cache_readahead(mapping, filp,
offset, req_size, 0);
}
@ -408,7 +408,7 @@ ondemand_readahead(struct address_space *mapping,
* E.g. interleaved reads.
* Not knowing its readahead pos/size, bet on the minimal possible one.
*/
if (page) {
if (hit_readahead_marker) {
ra_index++;
ra_size = min(4 * ra_size, max);
}
@ -421,50 +421,71 @@ fill_ra:
}
/**
* page_cache_readahead_ondemand - generic file readahead
* page_cache_sync_readahead - generic file readahead
* @mapping: address_space which holds the pagecache and I/O vectors
* @ra: file_ra_state which holds the readahead state
* @filp: passed on to ->readpage() and ->readpages()
* @page: the page at @offset, or NULL if non-present
* @offset: start offset into @mapping, in PAGE_CACHE_SIZE units
* @offset: start offset into @mapping, in pagecache page-sized units
* @req_size: hint: total size of the read which the caller is performing in
* PAGE_CACHE_SIZE units
* pagecache pages
*
* page_cache_readahead_ondemand() is the entry point of readahead logic.
* This function should be called when it is time to perform readahead:
* 1) @page == NULL
* A cache miss happened, time for synchronous readahead.
* 2) @page != NULL && PageReadahead(@page)
* A look-ahead hit occured, time for asynchronous readahead.
* page_cache_sync_readahead() should be called when a cache miss happened:
* it will submit the read. The readahead logic may decide to piggyback more
* pages onto the read request if access patterns suggest it will improve
* performance.
*/
unsigned long
page_cache_readahead_ondemand(struct address_space *mapping,
struct file_ra_state *ra, struct file *filp,
struct page *page, pgoff_t offset,
unsigned long req_size)
void page_cache_sync_readahead(struct address_space *mapping,
struct file_ra_state *ra, struct file *filp,
pgoff_t offset, unsigned long req_size)
{
/* no read-ahead */
if (!ra->ra_pages)
return 0;
if (page) {
/*
* It can be PG_reclaim.
*/
if (PageWriteback(page))
return 0;
ClearPageReadahead(page);
/*
* Defer asynchronous read-ahead on IO congestion.
*/
if (bdi_read_congested(mapping->backing_dev_info))
return 0;
}
return;
/* do read-ahead */
return ondemand_readahead(mapping, ra, filp, page,
offset, req_size);
ondemand_readahead(mapping, ra, filp, false, offset, req_size);
}
EXPORT_SYMBOL_GPL(page_cache_readahead_ondemand);
EXPORT_SYMBOL_GPL(page_cache_sync_readahead);
/**
* page_cache_async_readahead - file readahead for marked pages
* @mapping: address_space which holds the pagecache and I/O vectors
* @ra: file_ra_state which holds the readahead state
* @filp: passed on to ->readpage() and ->readpages()
* @page: the page at @offset which has the PG_readahead flag set
* @offset: start offset into @mapping, in pagecache page-sized units
* @req_size: hint: total size of the read which the caller is performing in
* pagecache pages
*
* page_cache_async_ondemand() should be called when a page is used which
* has the PG_readahead flag: this is a marker to suggest that the application
* has used up enough of the readahead window that we should start pulling in
* more pages. */
void
page_cache_async_readahead(struct address_space *mapping,
struct file_ra_state *ra, struct file *filp,
struct page *page, pgoff_t offset,
unsigned long req_size)
{
/* no read-ahead */
if (!ra->ra_pages)
return;
/*
* Same bit is used for PG_readahead and PG_reclaim.
*/
if (PageWriteback(page))
return;
ClearPageReadahead(page);
/*
* Defer asynchronous read-ahead on IO congestion.
*/
if (bdi_read_congested(mapping->backing_dev_info))
return;
/* do read-ahead */
ondemand_readahead(mapping, ra, filp, true, offset, req_size);
}
EXPORT_SYMBOL_GPL(page_cache_async_readahead);