5 files changed, 94 insertions, 5 deletions

diff --git a/mm/Kconfig b/mm/Kconfig
index 308fdcaeed77..0b23db9a8791 100644
--- a/mm/Kconfig
+++ b/mm/Kconfig
@@ -258,6 +258,19 @@ config BOUNCE
         def_bool y
         depends on BLOCK && MMU && (ZONE_DMA || HIGHMEM)
 
+# On the 'tile' arch, USB OHCI needs the bounce pool since tilegx will often
+# have more than 4GB of memory, but we don't currently use the IOTLB to present
+# a 32-bit address to OHCI.  So we need to use a bounce pool instead.
+#
+# We also use the bounce pool to provide stable page writes for jbd.  jbd
+# initiates buffer writeback without locking the page or setting PG_writeback,
+# and fixing that behavior (a second time; jbd2 doesn't have this problem) is
+# a major rework effort.  Instead, use the bounce buffer to snapshot pages
+# (until jbd goes away).  The only jbd user is ext3.
+config NEED_BOUNCE_POOL
+        bool
+        default y if (TILE && USB_OHCI_HCD) || (BLK_DEV_INTEGRITY && JBD)
+
 config NR_QUICK
         int
         depends on QUICKLIST
diff --git a/mm/backing-dev.c b/mm/backing-dev.c
index d3ca2b3ee176..41733c5dc820 100644
--- a/mm/backing-dev.c
+++ b/mm/backing-dev.c
@@ -221,12 +221,23 @@ static ssize_t max_ratio_store(struct device *dev,
 }
 BDI_SHOW(max_ratio, bdi->max_ratio)
 
+static ssize_t stable_pages_required_show(struct device *dev,
+                                          struct device_attribute *attr,
+                                          char *page)
+{
+        struct backing_dev_info *bdi = dev_get_drvdata(dev);
+
+        return snprintf(page, PAGE_SIZE-1, "%d\n",
+                        bdi_cap_stable_pages_required(bdi) ? 1 : 0);
+}
+
 #define __ATTR_RW(attr) __ATTR(attr, 0644, attr##_show, attr##_store)
 
 static struct device_attribute bdi_dev_attrs[] = {
         __ATTR_RW(read_ahead_kb),
         __ATTR_RW(min_ratio),
         __ATTR_RW(max_ratio),
+        __ATTR_RO(stable_pages_required),
         __ATTR_NULL,
 };
 
diff --git a/mm/bounce.c b/mm/bounce.c
index 042086775561..5f8901768602 100644
--- a/mm/bounce.c
+++ b/mm/bounce.c
@@ -178,8 +178,45 @@ static void bounce_end_io_read_isa(struct bio *bio, int err)
         __bounce_end_io_read(bio, isa_page_pool, err);
 }
 
+#ifdef CONFIG_NEED_BOUNCE_POOL
+static int must_snapshot_stable_pages(struct request_queue *q, struct bio *bio)
+{
+        struct page *page;
+        struct backing_dev_info *bdi;
+        struct address_space *mapping;
+        struct bio_vec *from;
+        int i;
+
+        if (bio_data_dir(bio) != WRITE)
+                return 0;
+
+        if (!bdi_cap_stable_pages_required(&q->backing_dev_info))
+                return 0;
+
+        /*
+         * Based on the first page that has a valid mapping, decide whether or
+         * not we have to employ bounce buffering to guarantee stable pages.
+         */
+        bio_for_each_segment(from, bio, i) {
+                page = from->bv_page;
+                mapping = page_mapping(page);
+                if (!mapping)
+                        continue;
+                bdi = mapping->backing_dev_info;
+                return mapping->host->i_sb->s_flags & MS_SNAP_STABLE;
+        }
+
+        return 0;
+}
+#else
+static int must_snapshot_stable_pages(struct request_queue *q, struct bio *bio)
+{
+        return 0;
+}
+#endif /* CONFIG_NEED_BOUNCE_POOL */
+
 static void __blk_queue_bounce(struct request_queue *q, struct bio **bio_orig,
-                               mempool_t *pool)
+                               mempool_t *pool, int force)
 {
         struct page *page;
         struct bio *bio = NULL;
@@ -192,7 +229,7 @@ static void __blk_queue_bounce(struct request_queue *q, struct bio **bio_orig,
                 /*
                  * is destination page below bounce pfn?
                  */
-                if (page_to_pfn(page) <= queue_bounce_pfn(q))
+                if (page_to_pfn(page) <= queue_bounce_pfn(q) && !force)
                         continue;
 
                 /*
@@ -270,6 +307,7 @@ static void __blk_queue_bounce(struct request_queue *q, struct bio **bio_orig,
 
 void blk_queue_bounce(struct request_queue *q, struct bio **bio_orig)
 {
+        int must_bounce;
         mempool_t *pool;
 
         /*
@@ -278,13 +316,15 @@ void blk_queue_bounce(struct request_queue *q, struct bio **bio_orig)
         if (!bio_has_data(*bio_orig))
                 return;
 
+        must_bounce = must_snapshot_stable_pages(q, *bio_orig);
+
         /*
          * for non-isa bounce case, just check if the bounce pfn is equal
          * to or bigger than the highest pfn in the system -- in that case,
          * don't waste time iterating over bio segments
          */
         if (!(q->bounce_gfp & GFP_DMA)) {
-                if (queue_bounce_pfn(q) >= blk_max_pfn)
+                if (queue_bounce_pfn(q) >= blk_max_pfn && !must_bounce)
                         return;
                 pool = page_pool;
         } else {
@@ -295,7 +335,7 @@ void blk_queue_bounce(struct request_queue *q, struct bio **bio_orig)
         /*
          * slow path
          */
-        __blk_queue_bounce(q, bio_orig, pool);
+        __blk_queue_bounce(q, bio_orig, pool, must_bounce);
 }
 
 EXPORT_SYMBOL(blk_queue_bounce);
diff --git a/mm/filemap.c b/mm/filemap.c
index 24a7ea583f0c..c610076c30e1 100644
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -1728,6 +1728,7 @@ int filemap_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
          * see the dirty page and writeprotect it again.
          */
         set_page_dirty(page);
+        wait_for_stable_page(page);
 out:
         sb_end_pagefault(inode->i_sb);
         return ret;
@@ -2274,7 +2275,7 @@ repeat:
                 return NULL;
         }
 found:
-        wait_on_page_writeback(page);
+        wait_for_stable_page(page);
         return page;
 }
 EXPORT_SYMBOL(grab_cache_page_write_begin);
diff --git a/mm/page-writeback.c b/mm/page-writeback.c
index 66a0024becd9..7300c9d5e1d9 100644
--- a/mm/page-writeback.c
+++ b/mm/page-writeback.c
@@ -2290,3 +2290,27 @@ int mapping_tagged(struct address_space *mapping, int tag)
         return radix_tree_tagged(&mapping->page_tree, tag);
 }
 EXPORT_SYMBOL(mapping_tagged);
+
+/**
+ * wait_for_stable_page() - wait for writeback to finish, if necessary.
+ * @page:       The page to wait on.
+ *
+ * This function determines if the given page is related to a backing device
+ * that requires page contents to be held stable during writeback.  If so, then
+ * it will wait for any pending writeback to complete.
+ */
+void wait_for_stable_page(struct page *page)
+{
+        struct address_space *mapping = page_mapping(page);
+        struct backing_dev_info *bdi = mapping->backing_dev_info;
+
+        if (!bdi_cap_stable_pages_required(bdi))
+                return;
+#ifdef CONFIG_NEED_BOUNCE_POOL
+        if (mapping->host->i_sb->s_flags & MS_SNAP_STABLE)
+                return;
+#endif /* CONFIG_NEED_BOUNCE_POOL */
+
+        wait_on_page_writeback(page);
+}
+EXPORT_SYMBOL_GPL(wait_for_stable_page);