summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--include/linux/fs.h61
-rw-r--r--mm/readahead.c68
2 files changed, 31 insertions, 98 deletions
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 29cb32d3a849..d33beadd9a43 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -695,16 +695,12 @@ struct fown_struct {
/*
* Track a single file's readahead state
- *
- * ================#============|==================#==================|
- * ^ ^ ^ ^
- * file_ra_state.la_index .ra_index .lookahead_index .readahead_index
*/
struct file_ra_state {
- pgoff_t la_index; /* enqueue time */
- pgoff_t ra_index; /* begin offset */
- pgoff_t lookahead_index; /* time to do next readahead */
- pgoff_t readahead_index; /* end offset */
+ pgoff_t start; /* where readahead started */
+ unsigned long size; /* # of readahead pages */
+ unsigned long async_size; /* do asynchronous readahead when
+ there are only # of pages ahead */
unsigned long ra_pages; /* Maximum readahead window */
unsigned long mmap_hit; /* Cache hit stat for mmap accesses */
@@ -714,59 +710,14 @@ struct file_ra_state {
};
/*
- * Measuring read-ahead sizes.
- *
- * |----------- readahead size ------------>|
- * ===#============|==================#=====================|
- * |------- invoke interval ------>|-- lookahead size -->|
- */
-static inline unsigned long ra_readahead_size(struct file_ra_state *ra)
-{
- return ra->readahead_index - ra->ra_index;
-}
-
-static inline unsigned long ra_lookahead_size(struct file_ra_state *ra)
-{
- return ra->readahead_index - ra->lookahead_index;
-}
-
-static inline unsigned long ra_invoke_interval(struct file_ra_state *ra)
-{
- return ra->lookahead_index - ra->la_index;
-}
-
-/*
* Check if @index falls in the readahead windows.
*/
static inline int ra_has_index(struct file_ra_state *ra, pgoff_t index)
{
- return (index >= ra->la_index &&
- index < ra->readahead_index);
-}
-
-/*
- * Where is the old read-ahead and look-ahead?
- */
-static inline void ra_set_index(struct file_ra_state *ra,
- pgoff_t la_index, pgoff_t ra_index)
-{
- ra->la_index = la_index;
- ra->ra_index = ra_index;
+ return (index >= ra->start &&
+ index < ra->start + ra->size);
}
-/*
- * Where is the new read-ahead and look-ahead?
- */
-static inline void ra_set_size(struct file_ra_state *ra,
- unsigned long ra_size, unsigned long la_size)
-{
- ra->readahead_index = ra->ra_index + ra_size;
- ra->lookahead_index = ra->ra_index + ra_size - la_size;
-}
-
-unsigned long ra_submit(struct file_ra_state *ra,
- struct address_space *mapping, struct file *filp);
-
struct file {
/*
* fu_list becomes invalid after file_free is called and queued via
diff --git a/mm/readahead.c b/mm/readahead.c
index 3d262bb738a9..39bf45d43320 100644
--- a/mm/readahead.c
+++ b/mm/readahead.c
@@ -253,21 +253,16 @@ unsigned long max_sane_readahead(unsigned long nr)
/*
* Submit IO for the read-ahead request in file_ra_state.
*/
-unsigned long ra_submit(struct file_ra_state *ra,
+static unsigned long ra_submit(struct file_ra_state *ra,
struct address_space *mapping, struct file *filp)
{
- unsigned long ra_size;
- unsigned long la_size;
int actual;
- ra_size = ra_readahead_size(ra);
- la_size = ra_lookahead_size(ra);
actual = __do_page_cache_readahead(mapping, filp,
- ra->ra_index, ra_size, la_size);
+ ra->start, ra->size, ra->async_size);
return actual;
}
-EXPORT_SYMBOL_GPL(ra_submit);
/*
* Set the initial window size, round to next power of 2 and square
@@ -296,7 +291,7 @@ static unsigned long get_init_ra_size(unsigned long size, unsigned long max)
static unsigned long get_next_ra_size(struct file_ra_state *ra,
unsigned long max)
{
- unsigned long cur = ra->readahead_index - ra->ra_index;
+ unsigned long cur = ra->size;
unsigned long newsize;
if (cur < max / 16)
@@ -313,28 +308,21 @@ static unsigned long get_next_ra_size(struct file_ra_state *ra,
* The fields in struct file_ra_state represent the most-recently-executed
* readahead attempt:
*
- * |-------- last readahead window -------->|
- * |-- application walking here -->|
- * ======#============|==================#=====================|
- * ^la_index ^ra_index ^lookahead_index ^readahead_index
- *
- * [ra_index, readahead_index) represents the last readahead window.
- *
- * [la_index, lookahead_index] is where the application would be walking(in
- * the common case of cache-cold sequential reads): the last window was
- * established when the application was at la_index, and the next window will
- * be bring in when the application reaches lookahead_index.
+ * |<----- async_size ---------|
+ * |------------------- size -------------------->|
+ * |==================#===========================|
+ * ^start ^page marked with PG_readahead
*
* To overlap application thinking time and disk I/O time, we do
* `readahead pipelining': Do not wait until the application consumed all
* readahead pages and stalled on the missing page at readahead_index;
- * Instead, submit an asynchronous readahead I/O as early as the application
- * reads on the page at lookahead_index. Normally lookahead_index will be
- * equal to ra_index, for maximum pipelining.
+ * Instead, submit an asynchronous readahead I/O as soon as there are
+ * only async_size pages left in the readahead window. Normally async_size
+ * will be equal to size, for maximum pipelining.
*
* In interleaved sequential reads, concurrent streams on the same fd can
* be invalidating each other's readahead state. So we flag the new readahead
- * page at lookahead_index with PG_readahead, and use it as readahead
+ * page at (start+size-async_size) with PG_readahead, and use it as readahead
* indicator. The flag won't be set on already cached pages, to avoid the
* readahead-for-nothing fuss, saving pointless page cache lookups.
*
@@ -363,24 +351,21 @@ ondemand_readahead(struct address_space *mapping,
unsigned long req_size)
{
unsigned long max; /* max readahead pages */
- pgoff_t ra_index; /* readahead index */
- unsigned long ra_size; /* readahead size */
- unsigned long la_size; /* lookahead size */
int sequential;
max = ra->ra_pages;
sequential = (offset - ra->prev_index <= 1UL) || (req_size > max);
/*
- * Lookahead/readahead hit, assume sequential access.
+ * It's the expected callback offset, assume sequential access.
* Ramp up sizes, and push forward the readahead window.
*/
- if (offset && (offset == ra->lookahead_index ||
- offset == ra->readahead_index)) {
- ra_index = ra->readahead_index;
- ra_size = get_next_ra_size(ra, max);
- la_size = ra_size;
- goto fill_ra;
+ if (offset && (offset == (ra->start + ra->size - ra->async_size) ||
+ offset == (ra->start + ra->size))) {
+ ra->start += ra->size;
+ ra->size = get_next_ra_size(ra, max);
+ ra->async_size = ra->size;
+ goto readit;
}
/*
@@ -399,24 +384,21 @@ ondemand_readahead(struct address_space *mapping,
* - oversize random read
* Start readahead for it.
*/
- ra_index = offset;
- ra_size = get_init_ra_size(req_size, max);
- la_size = ra_size > req_size ? ra_size - req_size : ra_size;
+ ra->start = offset;
+ ra->size = get_init_ra_size(req_size, max);
+ ra->async_size = ra->size > req_size ? ra->size - req_size : ra->size;
/*
- * Hit on a lookahead page without valid readahead state.
+ * Hit on a marked page without valid readahead state.
* E.g. interleaved reads.
* Not knowing its readahead pos/size, bet on the minimal possible one.
*/
if (hit_readahead_marker) {
- ra_index++;
- ra_size = min(4 * ra_size, max);
+ ra->start++;
+ ra->size = get_next_ra_size(ra, max);
}
-fill_ra:
- ra_set_index(ra, offset, ra_index);
- ra_set_size(ra, ra_size, la_size);
-
+readit:
return ra_submit(ra, mapping, filp);
}