From: Rusty Russell Date: Thu, 19 Jul 2007 08:48:08 +0000 (-0700) Subject: readahead: split ondemand readahead interface into two functions X-Git-Tag: v2.6.23-rc1~426 X-Git-Url: https://err.no/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=cf914a7d656e62b9dd3e0dffe4f62b953ae6048d;p=linux-2.6 readahead: split ondemand readahead interface into two functions 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 Signed-off-by: Fengguang Wu Signed-off-by: Andrew Morton Signed-off-by: Linus Torvalds --- diff --git a/fs/ext3/dir.c b/fs/ext3/dir.c index 3c6d384a2c..c00723a99f 100644 --- a/fs/ext3/dir.c +++ b/fs/ext3/dir.c @@ -139,10 +139,10 @@ static int ext3_readdir(struct file * filp, pgoff_t index = map_bh.b_blocknr >> (PAGE_CACHE_SHIFT - inode->i_blkbits); if (!ra_has_index(&filp->f_ra, index)) - page_cache_readahead_ondemand( + page_cache_sync_readahead( sb->s_bdev->bd_inode->i_mapping, &filp->f_ra, filp, - NULL, index, 1); + index, 1); filp->f_ra.prev_index = index; bh = ext3_bread(NULL, inode, blk, 0, &err); } diff --git a/fs/ext4/dir.c b/fs/ext4/dir.c index 0a872a09fe..3ab01c04e0 100644 --- a/fs/ext4/dir.c +++ b/fs/ext4/dir.c @@ -138,10 +138,10 @@ static int ext4_readdir(struct file * filp, pgoff_t index = map_bh.b_blocknr >> (PAGE_CACHE_SHIFT - inode->i_blkbits); if (!ra_has_index(&filp->f_ra, index)) - page_cache_readahead_ondemand( + page_cache_sync_readahead( sb->s_bdev->bd_inode->i_mapping, &filp->f_ra, filp, - NULL, index, 1); + index, 1); filp->f_ra.prev_index = index; bh = ext4_bread(NULL, inode, blk, 0, &err); } diff --git a/fs/splice.c b/fs/splice.c index 6ddd0329f8..22496d2a73 100644 --- a/fs/splice.c +++ b/fs/splice.c @@ -295,8 +295,8 @@ __generic_file_splice_read(struct file *in, loff_t *ppos, * readahead/allocate the rest and fill in the holes. */ if (spd.nr_pages < nr_pages) - page_cache_readahead_ondemand(mapping, &in->f_ra, in, - NULL, index, req_pages - spd.nr_pages); + page_cache_sync_readahead(mapping, &in->f_ra, in, + index, req_pages - spd.nr_pages); error = 0; while (spd.nr_pages < nr_pages) { @@ -352,7 +352,7 @@ __generic_file_splice_read(struct file *in, loff_t *ppos, page = pages[page_nr]; if (PageReadahead(page)) - page_cache_readahead_ondemand(mapping, &in->f_ra, in, + page_cache_async_readahead(mapping, &in->f_ra, in, page, index, req_pages - page_nr); /* diff --git a/include/linux/mm.h b/include/linux/mm.h index 3d0d7d2852..50a0ed1d18 100644 --- a/include/linux/mm.h +++ b/include/linux/mm.h @@ -1138,12 +1138,20 @@ int do_page_cache_readahead(struct address_space *mapping, struct file *filp, pgoff_t offset, unsigned long nr_to_read); int force_page_cache_readahead(struct address_space *mapping, struct file *filp, pgoff_t offset, unsigned long nr_to_read); -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 size); + +void page_cache_sync_readahead(struct address_space *mapping, + struct file_ra_state *ra, + struct file *filp, + pgoff_t offset, + unsigned long size); + +void page_cache_async_readahead(struct address_space *mapping, + struct file_ra_state *ra, + struct file *filp, + struct page *pg, + pgoff_t offset, + unsigned long size); + unsigned long max_sane_readahead(unsigned long nr); /* Do stack extension */ diff --git a/mm/filemap.c b/mm/filemap.c index 5eb0a6b9d6..49a6fe375d 100644 --- a/mm/filemap.c +++ b/mm/filemap.c @@ -894,15 +894,15 @@ void do_generic_mapping_read(struct address_space *mapping, find_page: page = find_get_page(mapping, index); if (!page) { - page_cache_readahead_ondemand(mapping, - &ra, filp, page, + page_cache_sync_readahead(mapping, + &ra, filp, index, last_index - index); page = find_get_page(mapping, index); if (unlikely(page == NULL)) goto no_cached_page; } if (PageReadahead(page)) { - page_cache_readahead_ondemand(mapping, + page_cache_async_readahead(mapping, &ra, filp, page, index, last_index - index); } @@ -1348,14 +1348,14 @@ retry_find: */ if (VM_SequentialReadHint(vma)) { if (!page) { - page_cache_readahead_ondemand(mapping, ra, file, page, + page_cache_sync_readahead(mapping, ra, file, vmf->pgoff, 1); page = find_lock_page(mapping, vmf->pgoff); if (!page) goto no_cached_page; } if (PageReadahead(page)) { - page_cache_readahead_ondemand(mapping, ra, file, page, + page_cache_async_readahead(mapping, ra, file, page, vmf->pgoff, 1); } } diff --git a/mm/readahead.c b/mm/readahead.c index 205a4a4315..3d262bb738 100644 --- a/mm/readahead.c +++ b/mm/readahead.c @@ -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 */ + ondemand_readahead(mapping, ra, filp, false, offset, req_size); +} +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 */ - return ondemand_readahead(mapping, ra, filp, page, - offset, req_size); + ondemand_readahead(mapping, ra, filp, true, offset, req_size); } -EXPORT_SYMBOL_GPL(page_cache_readahead_ondemand); +EXPORT_SYMBOL_GPL(page_cache_async_readahead);