6 files changed, 85 insertions, 56 deletions

diff --git a/fs/ext3/dir.c b/fs/ext3/dir.c
index 3c6d384a2c66..c00723a99f44 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 0a872a09fed8..3ab01c04e00c 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 6ddd0329f866..22496d2a73fa 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 3d0d7d285237..50a0ed1d1806 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 5eb0a6b9d607..49a6fe375d01 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 205a4a431516..3d262bb738a9 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);