ext4: start transaction before calling into DAX

Orabug: 22913653

Jan Kara pointed out that in the case where we are writing to a hole, we
can end up with a lock inversion between the page lock and the journal
lock.  We can avoid this by starting the transaction in ext4 before
calling into DAX.  The journal lock nests inside the superblock
pagefault lock, so we have to duplicate that code from dax_fault, like
XFS does.

Signed-off-by: Matthew Wilcox <willy@linux.intel.com>
Cc: Jan Kara <jack@suse.cz>
Cc: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
(cherry picked from commit 01a33b4ace68bc35679a347f21d5ed6e222e30dc)
Signed-off-by: Dan Duval <dan.duval@oracle.com>

diff --git a/fs/ext4/file.c b/fs/ext4/file.c
index a9f334f590753920db2b8be6ab924ead31e8aa00..b30019c7f2cd1772efd22e06e4cf76f843599768 100644 (file)
--- a/fs/ext4/file.c
+++ b/fs/ext4/file.c
@@ -207,14 +207,63 @@ static void ext4_end_io_unwritten(struct buffer_head *bh, int uptodate)
 
 static int ext4_dax_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
 {
-       return dax_fault(vma, vmf, ext4_get_block_dax, ext4_end_io_unwritten);
+       int result;
+       handle_t *handle = NULL;
+       struct super_block *sb = file_inode(vma->vm_file)->i_sb;
+       bool write = vmf->flags & FAULT_FLAG_WRITE;
+
+       if (write) {
+               sb_start_pagefault(sb);
+               file_update_time(vma->vm_file);
+               handle = ext4_journal_start_sb(sb, EXT4_HT_WRITE_PAGE,
+                                               EXT4_DATA_TRANS_BLOCKS(sb));
+       }
+
+       if (IS_ERR(handle))
+               result = VM_FAULT_SIGBUS;
+       else
+               result = __dax_fault(vma, vmf, ext4_get_block_dax,
+                                               ext4_end_io_unwritten);
+
+       if (write) {
+               if (!IS_ERR(handle))
+                       ext4_journal_stop(handle);
+               sb_end_pagefault(sb);
+       }
+
+       return result;
 }
 
 static int ext4_dax_pmd_fault(struct vm_area_struct *vma, unsigned long addr,
                                                pmd_t *pmd, unsigned int flags)
 {
-       return dax_pmd_fault(vma, addr, pmd, flags, ext4_get_block_dax,
-                               ext4_end_io_unwritten);
+       int result;
+       handle_t *handle = NULL;
+       struct inode *inode = file_inode(vma->vm_file);
+       struct super_block *sb = inode->i_sb;
+       bool write = flags & FAULT_FLAG_WRITE;
+
+       if (write) {
+               sb_start_pagefault(sb);
+               file_update_time(vma->vm_file);
+               handle = ext4_journal_start_sb(sb, EXT4_HT_WRITE_PAGE,
+                               ext4_chunk_trans_blocks(inode,
+                                                       PMD_SIZE / PAGE_SIZE));
+       }
+
+       if (IS_ERR(handle))
+               result = VM_FAULT_SIGBUS;
+       else
+               result = __dax_pmd_fault(vma, addr, pmd, flags,
+                               ext4_get_block_dax, ext4_end_io_unwritten);
+
+       if (write) {
+               if (!IS_ERR(handle))
+                       ext4_journal_stop(handle);
+               sb_end_pagefault(sb);
+       }
+
+       return result;
 }
 
 static int ext4_dax_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)