4 files changed, 86 insertions, 23 deletions

diff --git a/fs/nilfs2/inode.c b/fs/nilfs2/inode.c
index 6b49f14eac8c..ba7a1da7634b 100644
--- a/fs/nilfs2/inode.c
+++ b/fs/nilfs2/inode.c
@@ -175,6 +175,11 @@ static int nilfs_writepages(struct address_space *mapping,
         struct inode *inode = mapping->host;
         int err = 0;
 
+        if (inode->i_sb->s_flags & MS_RDONLY) {
+                nilfs_clear_dirty_pages(mapping, false);
+                return -EROFS;
+        }
+
         if (wbc->sync_mode == WB_SYNC_ALL)
                 err = nilfs_construct_dsync_segment(inode->i_sb, inode,
                                                     wbc->range_start,
@@ -187,6 +192,18 @@ static int nilfs_writepage(struct page *page, struct writeback_control *wbc)
         struct inode *inode = page->mapping->host;
         int err;
 
+        if (inode && (inode->i_sb->s_flags & MS_RDONLY)) {
+                /*
+                 * It means that filesystem was remounted in read-only
+                 * mode because of error or metadata corruption. But we
+                 * have dirty pages that try to be flushed in background.
+                 * So, here we simply discard this dirty page.
+                 */
+                nilfs_clear_dirty_page(page, false);
+                unlock_page(page);
+                return -EROFS;
+        }
+
         redirty_page_for_writepage(wbc, page);
         unlock_page(page);
 
diff --git a/fs/nilfs2/mdt.c b/fs/nilfs2/mdt.c
index f9897d09c693..c4dcd1db57ee 100644
--- a/fs/nilfs2/mdt.c
+++ b/fs/nilfs2/mdt.c
@@ -375,14 +375,25 @@ int nilfs_mdt_fetch_dirty(struct inode *inode)
 static int
 nilfs_mdt_write_page(struct page *page, struct writeback_control *wbc)
 {
-        struct inode *inode;
+        struct inode *inode = page->mapping->host;
         struct super_block *sb;
         int err = 0;
 
+        if (inode && (inode->i_sb->s_flags & MS_RDONLY)) {
+                /*
+                 * It means that filesystem was remounted in read-only
+                 * mode because of error or metadata corruption. But we
+                 * have dirty pages that try to be flushed in background.
+                 * So, here we simply discard this dirty page.
+                 */
+                nilfs_clear_dirty_page(page, false);
+                unlock_page(page);
+                return -EROFS;
+        }
+
         redirty_page_for_writepage(wbc, page);
         unlock_page(page);
 
-        inode = page->mapping->host;
         if (!inode)
                 return 0;
 
@@ -561,10 +572,10 @@ void nilfs_mdt_restore_from_shadow_map(struct inode *inode)
         if (mi->mi_palloc_cache)
                 nilfs_palloc_clear_cache(inode);
 
-        nilfs_clear_dirty_pages(inode->i_mapping);
+        nilfs_clear_dirty_pages(inode->i_mapping, true);
         nilfs_copy_back_pages(inode->i_mapping, &shadow->frozen_data);
 
-        nilfs_clear_dirty_pages(&ii->i_btnode_cache);
+        nilfs_clear_dirty_pages(&ii->i_btnode_cache, true);
         nilfs_copy_back_pages(&ii->i_btnode_cache, &shadow->frozen_btnodes);
 
         nilfs_bmap_restore(ii->i_bmap, &shadow->bmap_store);
diff --git a/fs/nilfs2/page.c b/fs/nilfs2/page.c
index 07f76db04ec7..131a5841a070 100644
--- a/fs/nilfs2/page.c
+++ b/fs/nilfs2/page.c
@@ -370,7 +370,12 @@ repeat:
         goto repeat;
 }
 
-void nilfs_clear_dirty_pages(struct address_space *mapping)
+/**
+ * nilfs_clear_dirty_pages - discard dirty pages in address space
+ * @mapping: address space with dirty pages for discarding
+ * @silent: suppress [true] or print [false] warning messages
+ */
+void nilfs_clear_dirty_pages(struct address_space *mapping, bool silent)
 {
         struct pagevec pvec;
         unsigned int i;
@@ -382,25 +387,9 @@ void nilfs_clear_dirty_pages(struct address_space *mapping)
                                   PAGEVEC_SIZE)) {
                 for (i = 0; i < pagevec_count(&pvec); i++) {
                         struct page *page = pvec.pages[i];
-                        struct buffer_head *bh, *head;
 
                         lock_page(page);
-                        ClearPageUptodate(page);
-                        ClearPageMappedToDisk(page);
-                        bh = head = page_buffers(page);
-                        do {
-                                lock_buffer(bh);
-                                clear_buffer_dirty(bh);
-                                clear_buffer_nilfs_volatile(bh);
-                                clear_buffer_nilfs_checked(bh);
-                                clear_buffer_nilfs_redirected(bh);
-                                clear_buffer_uptodate(bh);
-                                clear_buffer_mapped(bh);
-                                unlock_buffer(bh);
-                                bh = bh->b_this_page;
-                        } while (bh != head);
-
-                        __nilfs_clear_page_dirty(page);
+                        nilfs_clear_dirty_page(page, silent);
                         unlock_page(page);
                 }
                 pagevec_release(&pvec);
@@ -408,6 +397,51 @@ void nilfs_clear_dirty_pages(struct address_space *mapping)
         }
 }
 
+/**
+ * nilfs_clear_dirty_page - discard dirty page
+ * @page: dirty page that will be discarded
+ * @silent: suppress [true] or print [false] warning messages
+ */
+void nilfs_clear_dirty_page(struct page *page, bool silent)
+{
+        struct inode *inode = page->mapping->host;
+        struct super_block *sb = inode->i_sb;
+
+        BUG_ON(!test_bit(PG_locked, &page->flags));
+
+        if (!silent) {
+                nilfs_warning(sb, __func__,
+                                "discard page: offset %lld, ino %lu",
+                                page_offset(page), inode->i_ino);
+        }
+
+        ClearPageUptodate(page);
+        ClearPageMappedToDisk(page);
+
+        if (page_has_buffers(page)) {
+                struct buffer_head *bh, *head;
+
+                bh = head = page_buffers(page);
+                do {
+                        lock_buffer(bh);
+                        if (!silent) {
+                                nilfs_warning(sb, __func__,
+                                        "discard block %llu, size %zu",
+                                        (u64)bh->b_blocknr, bh->b_size);
+                        }
+                        clear_buffer_dirty(bh);
+                        clear_buffer_nilfs_volatile(bh);
+                        clear_buffer_nilfs_checked(bh);
+                        clear_buffer_nilfs_redirected(bh);
+                        clear_buffer_uptodate(bh);
+                        clear_buffer_mapped(bh);
+                        unlock_buffer(bh);
+                } while (bh = bh->b_this_page, bh != head);
+        }
+
+        __nilfs_clear_page_dirty(page);
+}
+
 unsigned nilfs_page_count_clean_buffers(struct page *page,
                                         unsigned from, unsigned to)
 {
diff --git a/fs/nilfs2/page.h b/fs/nilfs2/page.h
index fb7de71605a0..ef30c5c2426f 100644
--- a/fs/nilfs2/page.h
+++ b/fs/nilfs2/page.h
@@ -55,7 +55,8 @@ void nilfs_page_bug(struct page *);
 
 int nilfs_copy_dirty_pages(struct address_space *, struct address_space *);
 void nilfs_copy_back_pages(struct address_space *, struct address_space *);
-void nilfs_clear_dirty_pages(struct address_space *);
+void nilfs_clear_dirty_page(struct page *, bool);
+void nilfs_clear_dirty_pages(struct address_space *, bool);
 void nilfs_mapping_init(struct address_space *mapping, struct inode *inode,
                         struct backing_dev_info *bdi);
 unsigned nilfs_page_count_clean_buffers(struct page *, unsigned, unsigned);