These changes are the raw update to linux-4.4.6-rt14. Kernel sources

[kvmfornfv.git] / kernel / fs / ext4 / file.c

diff --git a/kernel/fs/ext4/file.c b/kernel/fs/ext4/file.c
index 0613c25..113837e 100644 (file)
--- a/kernel/fs/ext4/file.c
+++ b/kernel/fs/ext4/file.c
@@ -22,6 +22,7 @@
 #include <linux/fs.h>
 #include <linux/mount.h>
 #include <linux/path.h>
+#include <linux/dax.h>
 #include <linux/quotaops.h>
 #include <linux/pagevec.h>
 #include <linux/uio.h>
@@ -192,19 +193,88 @@ out:
 }
 
 #ifdef CONFIG_FS_DAX
+static void ext4_end_io_unwritten(struct buffer_head *bh, int uptodate)
+{
+       struct inode *inode = bh->b_assoc_map->host;
+       /* XXX: breaks on 32-bit > 16TB. Is that even supported? */
+       loff_t offset = (loff_t)(uintptr_t)bh->b_private << inode->i_blkbits;
+       int err;
+       if (!uptodate)
+               return;
+       WARN_ON(!buffer_unwritten(bh));
+       err = ext4_convert_unwritten_extents(NULL, inode, offset, bh->b_size);
+}
+
 static int ext4_dax_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
 {
-       return dax_fault(vma, vmf, ext4_get_block);
-                                       /* Is this the right get_block? */
+       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)
+{
+       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)
 {
-       return dax_mkwrite(vma, vmf, ext4_get_block);
+       return dax_mkwrite(vma, vmf, ext4_get_block_dax,
+                               ext4_end_io_unwritten);
 }
 
 static const struct vm_operations_struct ext4_dax_vm_ops = {
        .fault          = ext4_dax_fault,
+       .pmd_fault      = ext4_dax_pmd_fault,
        .page_mkwrite   = ext4_dax_mkwrite,
        .pfn_mkwrite    = dax_pfn_mkwrite,
 };
@@ -223,14 +293,16 @@ static int ext4_file_mmap(struct file *file, struct vm_area_struct *vma)
        struct inode *inode = file->f_mapping->host;
 
        if (ext4_encrypted_inode(inode)) {
-               int err = ext4_generate_encryption_key(inode);
+               int err = ext4_get_encryption_info(inode);
                if (err)
                        return 0;
+               if (ext4_encryption_info(inode) == NULL)
+                       return -ENOKEY;
        }
        file_accessed(file);
        if (IS_DAX(file_inode(file))) {
                vma->vm_ops = &ext4_dax_vm_ops;
-               vma->vm_flags |= VM_MIXEDMAP;
+               vma->vm_flags |= VM_MIXEDMAP | VM_HUGEPAGE;
        } else {
                vma->vm_ops = &ext4_file_vm_ops;
        }
@@ -278,6 +350,13 @@ static int ext4_file_open(struct inode * inode, struct file * filp)
                        ext4_journal_stop(handle);
                }
        }
+       if (ext4_encrypted_inode(inode)) {
+               ret = ext4_get_encryption_info(inode);
+               if (ret)
+                       return -EACCES;
+               if (ext4_encryption_info(inode) == NULL)
+                       return -ENOKEY;
+       }
        /*
         * Set up the jbd2_inode if we are opening the inode for
         * writing and the journal is present
@@ -287,13 +366,7 @@ static int ext4_file_open(struct inode * inode, struct file * filp)
                if (ret < 0)
                        return ret;
        }
-       ret = dquot_file_open(inode, filp);
-       if (!ret && ext4_encrypted_inode(inode)) {
-               ret = ext4_generate_encryption_key(inode);
-               if (ret)
-                       ret = -EACCES;
-       }
-       return ret;
+       return dquot_file_open(inode, filp);
 }
 
 /*