1 files changed, 19 insertions, 51 deletions

diff --git a/fs/buffer.c b/fs/buffer.c
index 49b7e9bdcd1d..1c18a22a6013 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -253,27 +253,6 @@ out:
 }
 
 /*
- * Kick the writeback threads then try to free up some ZONE_NORMAL memory.
- */
-static void free_more_memory(void)
-{
-        struct zoneref *z;
-        int nid;
-
-        wakeup_flusher_threads(1024, WB_REASON_FREE_MORE_MEM);
-        yield();
-
-        for_each_online_node(nid) {
-
-                z = first_zones_zonelist(node_zonelist(nid, GFP_NOFS),
-                                                gfp_zone(GFP_NOFS), NULL);
-                if (z->zone)
-                        try_to_free_pages(node_zonelist(nid, GFP_NOFS), 0,
-                                                GFP_NOFS, NULL);
-        }
-}
-
-/*
  * I/O completion handler for block_read_full_page() - pages
  * which come unlocked at the end of I/O.
  */
@@ -861,16 +840,19 @@ int remove_inode_buffers(struct inode *inode)
  * which may not fail from ordinary buffer allocations.
  */
 struct buffer_head *alloc_page_buffers(struct page *page, unsigned long size,
-                int retry)
+                bool retry)
 {
         struct buffer_head *bh, *head;
+        gfp_t gfp = GFP_NOFS;
         long offset;
 
-try_again:
+        if (retry)
+                gfp |= __GFP_NOFAIL;
+
         head = NULL;
         offset = PAGE_SIZE;
         while ((offset -= size) >= 0) {
-                bh = alloc_buffer_head(GFP_NOFS);
+                bh = alloc_buffer_head(gfp);
                 if (!bh)
                         goto no_grow;
 
@@ -896,23 +878,7 @@ no_grow:
                 } while (head);
         }
 
-        /*
-         * Return failure for non-async IO requests.  Async IO requests
-         * are not allowed to fail, so we have to wait until buffer heads
-         * become available.  But we don't want tasks sleeping with 
-         * partially complete buffers, so all were released above.
-         */
-        if (!retry)
-                return NULL;
-
-        /* We're _really_ low on memory. Now we just
-         * wait for old buffer heads to become free due to
-         * finishing IO.  Since this is an async request and
-         * the reserve list is empty, we're sure there are 
-         * async buffer heads in use.
-         */
-        free_more_memory();
-        goto try_again;
+        return NULL;
 }
 EXPORT_SYMBOL_GPL(alloc_page_buffers);
 
@@ -1001,8 +967,6 @@ grow_dev_page(struct block_device *bdev, sector_t block,
         gfp_mask |= __GFP_NOFAIL;
 
         page = find_or_create_page(inode->i_mapping, index, gfp_mask);
-        if (!page)
-                return ret;
 
         BUG_ON(!PageLocked(page));
 
@@ -1021,9 +985,7 @@ grow_dev_page(struct block_device *bdev, sector_t block,
         /*
          * Allocate some buffers for this page
          */
-        bh = alloc_page_buffers(page, size, 0);
-        if (!bh)
-                goto failed;
+        bh = alloc_page_buffers(page, size, true);
 
         /*
          * Link the page to the buffers and initialise them.  Take the
@@ -1103,8 +1065,6 @@ __getblk_slow(struct block_device *bdev, sector_t block,
                 ret = grow_buffers(bdev, block, size, gfp);
                 if (ret < 0)
                         return NULL;
-                if (ret == 0)
-                        free_more_memory();
         }
 }
 
@@ -1575,7 +1535,7 @@ void create_empty_buffers(struct page *page,
 {
         struct buffer_head *bh, *head, *tail;
 
-        head = alloc_page_buffers(page, blocksize, 1);
+        head = alloc_page_buffers(page, blocksize, true);
         bh = head;
         do {
                 bh->b_state |= b_state;
@@ -2639,7 +2599,7 @@ int nobh_write_begin(struct address_space *mapping,
          * Be careful: the buffer linked list is a NULL terminated one, rather
          * than the circular one we're used to.
          */
-        head = alloc_page_buffers(page, blocksize, 0);
+        head = alloc_page_buffers(page, blocksize, false);
         if (!head) {
                 ret = -ENOMEM;
                 goto out_release;
@@ -3056,8 +3016,16 @@ void guard_bio_eod(int op, struct bio *bio)
         sector_t maxsector;
         struct bio_vec *bvec = &bio->bi_io_vec[bio->bi_vcnt - 1];
         unsigned truncated_bytes;
+        struct hd_struct *part;
+
+        rcu_read_lock();
+        part = __disk_get_part(bio->bi_disk, bio->bi_partno);
+        if (part)
+                maxsector = part_nr_sects_read(part);
+        else
+                maxsector = get_capacity(bio->bi_disk);
+        rcu_read_unlock();
 
-        maxsector = get_capacity(bio->bi_disk);
         if (!maxsector)
                 return;