
From: Ram Pai <linuxram@us.ibm.com>



Signed-off-by: Andrew Morton <akpm@osdl.org>
---

 25-akpm/mm/readahead.c |  124 ++++++++++++++++++++++++++++++++++++-------------
 1 files changed, 92 insertions(+), 32 deletions(-)

diff -puN mm/readahead.c~readahead-congestion-control mm/readahead.c
--- 25/mm/readahead.c~readahead-congestion-control	2004-12-04 00:07:22.283187816 -0800
+++ 25-akpm/mm/readahead.c	2004-12-04 00:07:22.288187056 -0800
@@ -249,6 +249,9 @@ out:
  * We really don't want to intermingle reads and writes like that.
  *
  * Returns the number of pages requested, or the maximum amount of I/O allowed.
+ *
+ * do_page_cache_readahead() returns -1 is it encountered request queue
+ * congestion.
  */
 static inline int
 __do_page_cache_readahead(struct address_space *mapping, struct file *filp,
@@ -359,13 +362,45 @@ int check_ra_success(struct file_ra_stat
 }
 
 /*
- * Issue the I/O. If pages already in cache, increment the hit count until
- * we exceed max, then turn RA off until we start missing again.
+ * This version skips the IO if the queue is read-congested, and will tell the
+ * block layer to abandon the readahead if request allocation would block.
+ *
+ * force_page_cache_readahead() will ignore queue congestion and will block on
+ * request queues.
  */
 int do_page_cache_readahead(struct address_space *mapping, struct file *filp,
 			unsigned long offset, unsigned long nr_to_read)
 {
-	return  __do_page_cache_readahead(mapping, filp, offset, nr_to_read);
+	if (bdi_read_congested(mapping->backing_dev_info))
+		return -1;
+
+	return __do_page_cache_readahead(mapping, filp, offset, nr_to_read);
+}
+
+/*
+ * Read 'nr_to_read' pages starting at page 'offset'. If the flag 'block'
+ * is set wait till the read completes.  Otherwise attempt to read without
+ * blocking.
+ * Returns 1 meaning 'success' if read is succesfull without switching off
+ * readhaead mode. Otherwise return failure.
+ */
+static int
+blockable_page_cache_readahead(struct address_space *mapping, struct file *filp,
+			unsigned long offset, unsigned long nr_to_read,
+			struct file_ra_state *ra, int block)
+{
+	int actual;
+
+	if (block) {
+		actual = __do_page_cache_readahead(mapping, filp,
+						offset, nr_to_read);
+	} else {
+		actual = do_page_cache_readahead(mapping, filp,
+						offset, nr_to_read);
+		if (actual == -1)
+			return 0;
+	}
+	return check_ra_success(ra, nr_to_read, actual);
 }
 
 /*
@@ -379,7 +414,7 @@ page_cache_readahead(struct address_spac
 {
 	unsigned long max, min;
 	unsigned long newsize = req_size;
-	unsigned long actual=0;
+	unsigned long block;
 
 	/*
 	 * Here we detect the case where the application is performing
@@ -392,7 +427,6 @@ page_cache_readahead(struct address_spac
 
 	max = get_max_readahead(ra);
 	min = get_min_readahead(ra);
-//	maxsane = max_sane_readahead(max);
 	newsize = min(req_size, max);
 
 	if (newsize == 0 || (ra->flags & RA_FLAG_INCACHE)) {
@@ -407,12 +441,11 @@ page_cache_readahead(struct address_spac
 	if ((ra->size == 0 && offset == 0)	/* first io and start of file */
 	    || (ra->size == -1 && ra->prev_page == offset - 1)) {
 		/* First sequential */
-		ra->prev_page  = offset + newsize-1;
+		ra->prev_page  = offset + newsize - 1;
 		ra->size = get_init_ra_size(newsize, max);
 		ra->start = offset;
-		actual = do_page_cache_readahead(mapping, filp, offset,
-						ra->size);
-		if (!check_ra_success(ra, ra->size, actual))
+		if (!blockable_page_cache_readahead(mapping, filp, offset,
+							 ra->size, ra, 1))
 			goto out;
 
 		/*
@@ -427,9 +460,8 @@ page_cache_readahead(struct address_spac
 			ra->ahead_size = get_next_ra_size(ra->size, max, min,
 							  &ra->flags);
 			ra->ahead_start = ra->start + ra->size;
-			actual = do_page_cache_readahead(mapping, filp,
-					 ra->ahead_start, ra->ahead_size);
-			check_ra_success(ra, ra->ahead_size, actual);
+			blockable_page_cache_readahead(mapping, filp,
+				 ra->ahead_start, ra->ahead_size, ra, 1);
 		}
 		goto out;
 	}
@@ -441,10 +473,9 @@ page_cache_readahead(struct address_spac
 	 */
 	if ((offset != (ra->prev_page+1) || (ra->size == 0))) {
 		ra_off(ra);
-		ra->prev_page  = offset + newsize-1;
-		actual = do_page_cache_readahead(mapping, filp, offset,
-						 newsize);
-		check_ra_success(ra, newsize, actual);
+		ra->prev_page  = offset + newsize - 1;
+		blockable_page_cache_readahead(mapping, filp, offset,
+				 newsize, ra, 1);
 		goto out;
 	}
 
@@ -454,33 +485,62 @@ page_cache_readahead(struct address_spac
 	 */
 
 	if (ra->ahead_start == 0) {	 /* no ahead window yet */
-		ra->ahead_size = get_next_ra_size(max(newsize,ra->size),
-						  max, min, &ra->flags);
+		ra->ahead_size = get_next_ra_size(ra->size, max, min,
+						  &ra->flags);
 		ra->ahead_start = ra->start + ra->size;
-		newsize = min (newsize, ra->ahead_start - offset);
-		actual = do_page_cache_readahead(mapping, filp,
-					 ra->ahead_start, ra->ahead_size);
-		if (!check_ra_success(ra, ra->ahead_size, actual))
+		block = ((offset + newsize -1) >= ra->ahead_start);
+		if (!blockable_page_cache_readahead(mapping, filp,
+		    ra->ahead_start, ra->ahead_size, ra, block)) {
+			/* A read failure in blocking mode, implies pages are
+			 * all cached. So we can safely assume we have taken
+			 * care of all the pages requested in this call. A read
+			 * failure in non-blocking mode, implies we are reading
+			 * more pages than requested in this call.  So we safely
+			 * assume we have taken care of all the pages requested
+			 * in this call.
+			 *
+			 * Just reset the ahead window in case we failed due to
+			 * congestion.  The ahead window will any way be closed
+			 * in case we failed due to exessive page cache hits.
+			 */
+			ra->ahead_start = 0;
+			ra->ahead_size = 0;
 			goto out;
+		}
 	}
 	/*
-	 * Already have an ahead window, check if we crossed into it if so,
-	 * shift windows and issue a new ahead window.
-	 * Only return the #pages that are in the current window, so that we
-	 * get called back on the first page of the ahead window which will
-	 * allow us to submit more IO.
+	 * Already have an ahead window, check if we crossed into it.
+	 * If so, shift windows and issue a new ahead window.
+	 * Only return the #pages that are in the current window, so that
+	 * we get called back on the first page of the ahead window which
+	 * will allow us to submit more IO.
 	 */
-	if ((offset + newsize -1) >= ra->ahead_start) {
+	if ((offset + newsize - 1) >= ra->ahead_start) {
 		ra->start = ra->ahead_start;
 		ra->size = ra->ahead_size;
 		ra->ahead_start = ra->ahead_start + ra->ahead_size;
 		ra->ahead_size = get_next_ra_size(ra->ahead_size,
 						  max, min, &ra->flags);
-		newsize = min (newsize, ra->ahead_start - offset);
-		actual = do_page_cache_readahead(mapping, filp,
-				 ra->ahead_start, ra->ahead_size);
-		check_ra_success(ra, ra->ahead_size, actual);
+		block = ((offset + newsize - 1) >= ra->ahead_start);
+		if (!blockable_page_cache_readahead(mapping, filp,
+			ra->ahead_start, ra->ahead_size, ra, block)) {
+			/* A read failure in blocking mode, implies pages are
+			 * all cached. So we can safely assume we have taken
+			 * care of all the pages requested in this call.
+			 * A read failure in non-blocking mode, implies we are
+			 * reading more pages than requested in this call.  So
+			 * we safely assume we have taken care of all the pages
+			 * requested in this call.
+			 *
+			 * Just reset the ahead window in case we failed due to
+			 * congestion.  The ahead window will any way be closed
+			 * in case we failed due to excessive page cache hits.
+			 */
+			ra->ahead_start = 0;
+			ra->ahead_size = 0;
+		}
 	}
+
 out:
 	ra->prev_page = offset + newsize - 1;
 	return(newsize);
_
