page_writeback: revive cancel_dirty_page() in a restricted form
authorTejun Heo <tj@kernel.org>
Fri, 22 May 2015 21:13:15 +0000 (17:13 -0400)
committerJens Axboe <axboe@fb.com>
Tue, 2 Jun 2015 14:33:33 +0000 (08:33 -0600)
cancel_dirty_page() had some issues and b9ea25152e56 ("page_writeback:
clean up mess around cancel_dirty_page()") replaced it with
account_page_cleaned() which makes the caller responsible for clearing
the dirty bit; unfortunately, the planned changes for cgroup writeback
support requires synchronization between dirty bit manipulation and
stat updates.  While we can open-code such synchronization in each
account_page_cleaned() callsite, that's gonna be unnecessarily awkward
and verbose.

This patch revives cancel_dirty_page() but in a more restricted form.
All it does is TestClearPageDirty() followed by account_page_cleaned()
invocation if the page was dirty.  This helper covers all
account_page_cleaned() usages except for __delete_from_page_cache()
which is a special case anyway and left alone.  As this leaves no
module user for account_page_cleaned(), EXPORT_SYMBOL() is dropped
from it.

This patch just revives cancel_dirty_page() as a trivial wrapper to
replace equivalent usages and doesn't introduce any functional
changes.

Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Konstantin Khlebnikov <khlebnikov@yandex-team.ru>
Signed-off-by: Jens Axboe <axboe@fb.com>
drivers/staging/lustre/lustre/include/linux/lustre_patchless_compat.h
fs/buffer.c
include/linux/mm.h
mm/page-writeback.c
mm/truncate.c

index d72605864b0a66adecf278a21a3ae8efc9c9255c..14562788e4e059eca40f57ee85fd74a5c9f41fa0 100644 (file)
@@ -55,9 +55,7 @@ truncate_complete_page(struct address_space *mapping, struct page *page)
        if (PagePrivate(page))
                page->mapping->a_ops->invalidatepage(page, 0, PAGE_CACHE_SIZE);
 
-       if (TestClearPageDirty(page))
-               account_page_cleaned(page, mapping);
-
+       cancel_dirty_page(page);
        ClearPageMappedToDisk(page);
        ll_delete_from_page_cache(page);
 }
index f96173ad62d90413662e5ff15b14ed0df854ba5a..f21327d1f6731c4b913edd4b471b1c17faaa4682 100644 (file)
@@ -3232,8 +3232,8 @@ int try_to_free_buffers(struct page *page)
         * to synchronise against __set_page_dirty_buffers and prevent the
         * dirty bit from being lost.
         */
-       if (ret && TestClearPageDirty(page))
-               account_page_cleaned(page, mapping);
+       if (ret)
+               cancel_dirty_page(page);
        spin_unlock(&mapping->private_lock);
 out:
        if (buffers_to_free) {
index 0755b9fd03a7d936e805efb71cfc1d371ddea0d6..a83cf3a6f78ee92445a462742cab5bb425386e20 100644 (file)
@@ -1215,6 +1215,7 @@ void account_page_dirtied(struct page *page, struct address_space *mapping);
 void account_page_cleaned(struct page *page, struct address_space *mapping);
 int set_page_dirty(struct page *page);
 int set_page_dirty_lock(struct page *page);
+void cancel_dirty_page(struct page *page);
 int clear_page_dirty_for_io(struct page *page);
 
 int get_cmdline(struct task_struct *task, char *buffer, int buflen);
index 5daf5568b9e149ea9dce0383b0452bd30ad67f84..227b867598e1bd07141a0a92a96377ae4fd60307 100644 (file)
@@ -2112,12 +2112,6 @@ EXPORT_SYMBOL(account_page_dirtied);
 
 /*
  * Helper function for deaccounting dirty page without writeback.
- *
- * Doing this should *normally* only ever be done when a page
- * is truncated, and is not actually mapped anywhere at all. However,
- * fs/buffer.c does this when it notices that somebody has cleaned
- * out all the buffers on a page without actually doing it through
- * the VM. Can you say "ext3 is horribly ugly"? Thought you could.
  */
 void account_page_cleaned(struct page *page, struct address_space *mapping)
 {
@@ -2127,7 +2121,6 @@ void account_page_cleaned(struct page *page, struct address_space *mapping)
                task_io_account_cancelled_write(PAGE_CACHE_SIZE);
        }
 }
-EXPORT_SYMBOL(account_page_cleaned);
 
 /*
  * For address_spaces which do not use buffers.  Just tag the page as dirty in
@@ -2265,6 +2258,26 @@ int set_page_dirty_lock(struct page *page)
 }
 EXPORT_SYMBOL(set_page_dirty_lock);
 
+/*
+ * This cancels just the dirty bit on the kernel page itself, it does NOT
+ * actually remove dirty bits on any mmap's that may be around. It also
+ * leaves the page tagged dirty, so any sync activity will still find it on
+ * the dirty lists, and in particular, clear_page_dirty_for_io() will still
+ * look at the dirty bits in the VM.
+ *
+ * Doing this should *normally* only ever be done when a page is truncated,
+ * and is not actually mapped anywhere at all. However, fs/buffer.c does
+ * this when it notices that somebody has cleaned out all the buffers on a
+ * page without actually doing it through the VM. Can you say "ext3 is
+ * horribly ugly"? Thought you could.
+ */
+void cancel_dirty_page(struct page *page)
+{
+       if (TestClearPageDirty(page))
+               account_page_cleaned(page, page_mapping(page));
+}
+EXPORT_SYMBOL(cancel_dirty_page);
+
 /*
  * Clear a page's dirty flag, while caring for dirty memory accounting.
  * Returns true if the page was previously dirty.
index 66af9031fae8071c6d7a8c0b7e2a3da2c90684c7..0c360259c085e6de0f52c551560a25746e763b36 100644 (file)
@@ -116,9 +116,7 @@ truncate_complete_page(struct address_space *mapping, struct page *page)
         * the VM has canceled the dirty bit (eg ext3 journaling).
         * Hence dirty accounting check is placed after invalidation.
         */
-       if (TestClearPageDirty(page))
-               account_page_cleaned(page, mapping);
-
+       cancel_dirty_page(page);
        ClearPageMappedToDisk(page);
        delete_from_page_cache(page);
        return 0;