github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-07-27 17:47:41 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

mm/readahead: no PG_readahead on EOF

Browse Source 
When readahead pulls in all the remaining pages for a file, setting the
readahead bit is counter productive.  The async readahead it would trigger
would almost certainly be a no-op.  Additionally, for mmap'd file IO, the
readahead bit limits the fault around [1], causing an extra minor fault
when the page is accessed.

This was discovered when looking at /sys/kernel/tracing/events/readahead
traces for a simple program.  With the patch applied, fewer
page_cache_ra_unbounded calls are observed.

[1] do_fault_around calls filemap_map_pages, which finds eligible pages
    by calling next_uptodate_folio [2]. next_uptodate_folio skips pages
    with PG_readahead set [3].

Link: https://github.com/torvalds/linux/blob/v7.0/mm/filemap.c#L3921-L3939 [2]
Link: https://github.com/torvalds/linux/blob/v7.0/mm/filemap.c#L3721-L3722 [3]
Link: https://lore.kernel.org/20260508181237.670645-1-fmayle@google.com
Signed-off-by: Frederick Mayle <fmayle@google.com>
Reviewed-by: Jan Kara <jack@suse.cz>
Cc: Kalesh Singh <kaleshsingh@google.com>
Cc: Suren Baghdasaryan <surenb@google.com>
Cc: Matthew Wilcox (Oracle) <willy@infradead.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
This commit is contained in:
Frederick Mayle 2026-05-08 11:12:31 -07:00 committed by Andrew Morton
parent 80eacd489a
commit de97ae6222
1 changed files with 12 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
mm/readahead.c
View File

@ -340,8 +340,11 @@ static void do_page_cache_ra(struct readahead_control *ractl,
if (index > end_index) if (index > end_index)
return; return;
/* Don't read past the page containing the last byte of the file */ /* Don't read past the page containing the last byte of the file */
if (nr_to_read > end_index - index) if (nr_to_read > end_index - index) {
nr_to_read = end_index - index + 1; nr_to_read = end_index - index + 1;
/* We've reached the end, so don't set a readahead marker. */
lookahead_size = 0;
}
filemap_invalidate_lock_shared(mapping); filemap_invalidate_lock_shared(mapping);
page_cache_ra_unbounded(ractl, nr_to_read, lookahead_size); page_cache_ra_unbounded(ractl, nr_to_read, lookahead_size);
@ -485,7 +488,7 @@ void page_cache_ra_order(struct readahead_control *ractl,
pgoff_t index = start; pgoff_t index = start;
unsigned int min_order = mapping_min_folio_order(mapping); unsigned int min_order = mapping_min_folio_order(mapping);
pgoff_t limit; pgoff_t limit;
pgoff_t mark = index + ra->size - ra->async_size; pgoff_t mark;
unsigned int nofs; unsigned int nofs;
int err = 0; int err = 0;
gfp_t gfp = readahead_gfp_mask(mapping); gfp_t gfp = readahead_gfp_mask(mapping);
@ -499,7 +502,13 @@ void page_cache_ra_order(struct readahead_control *ractl,
limit = (i_size_read(mapping->host) - 1) >> PAGE_SHIFT; limit = (i_size_read(mapping->host) - 1) >> PAGE_SHIFT;
limit = min(limit, ractl->_max_index); limit = min(limit, ractl->_max_index);
limit = min(limit, index + ra->size - 1); if (limit > index + ra->size - 1) {
limit = index + ra->size - 1;
mark = index + ra->size - ra->async_size;
} else {
/* We've reached the end, so don't set a readahead marker. */
mark = ULONG_MAX;
}
new_order = min(mapping_max_folio_order(mapping), new_order); new_order = min(mapping_max_folio_order(mapping), new_order);
new_order = min_t(unsigned int, new_order, ilog2(ra->size)); new_order = min_t(unsigned int, new_order, ilog2(ra->size));