1 files changed, 58 insertions, 2 deletions

diff --git a/mm/truncate.c b/mm/truncate.c
index a654928323d..f4edbc179d1 100644
--- a/mm/truncate.c
+++ b/mm/truncate.c
@@ -17,6 +17,32 @@
                                    do_invalidatepage */
 
 
+/**
+ * do_invalidatepage - invalidate part of all of a page
+ * @page: the page which is affected
+ * @offset: the index of the truncation point
+ *
+ * do_invalidatepage() is called when all or part of the page has become
+ * invalidated by a truncate operation.
+ *
+ * do_invalidatepage() does not have to release all buffers, but it must
+ * ensure that no dirty buffer is left outside @offset and that no I/O
+ * is underway against any of the blocks which are outside the truncation
+ * point.  Because the caller is about to free (and possibly reuse) those
+ * blocks on-disk.
+ */
+void do_invalidatepage(struct page *page, unsigned long offset)
+{
+        void (*invalidatepage)(struct page *, unsigned long);
+        invalidatepage = page->mapping->a_ops->invalidatepage;
+#ifdef CONFIG_BLOCK
+        if (!invalidatepage)
+                invalidatepage = block_invalidatepage;
+#endif
+        if (invalidatepage)
+                (*invalidatepage)(page, offset);
+}
+
 static inline void truncate_partial_page(struct page *page, unsigned partial)
 {
         memclear_highpage_flush(page, partial, PAGE_CACHE_SIZE-partial);
@@ -261,9 +287,39 @@ unsigned long invalidate_inode_pages(struct address_space *mapping)
 {
         return invalidate_mapping_pages(mapping, 0, ~0UL);
 }
-
 EXPORT_SYMBOL(invalidate_inode_pages);
 
+/*
+ * This is like invalidate_complete_page(), except it ignores the page's
+ * refcount.  We do this because invalidate_inode_pages2() needs stronger
+ * invalidation guarantees, and cannot afford to leave pages behind because
+ * shrink_list() has a temp ref on them, or because they're transiently sitting
+ * in the lru_cache_add() pagevecs.
+ */
+static int
+invalidate_complete_page2(struct address_space *mapping, struct page *page)
+{
+        if (page->mapping != mapping)
+                return 0;
+
+        if (PagePrivate(page) && !try_to_release_page(page, 0))
+                return 0;
+
+        write_lock_irq(&mapping->tree_lock);
+        if (PageDirty(page))
+                goto failed;
+
+        BUG_ON(PagePrivate(page));
+        __remove_from_page_cache(page);
+        write_unlock_irq(&mapping->tree_lock);
+        ClearPageUptodate(page);
+        page_cache_release(page);       /* pagecache ref */
+        return 1;
+failed:
+        write_unlock_irq(&mapping->tree_lock);
+        return 0;
+}
+
 /**
  * invalidate_inode_pages2_range - remove range of pages from an address_space
  * @mapping: the address_space
@@ -330,7 +386,7 @@ int invalidate_inode_pages2_range(struct address_space *mapping,
                                 }
                         }
                         was_dirty = test_clear_page_dirty(page);
-                        if (!invalidate_complete_page(mapping, page)) {
+                        if (!invalidate_complete_page2(mapping, page)) {
                                 if (was_dirty)
                                         set_page_dirty(page);
                                 ret = -EIO;