Merge tag 'ext4_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso...

[pandora-kernel.git] / fs / ext4 / file.c

diff --git a/fs/ext4/file.c b/fs/ext4/file.c
index b132a3c..0613c25 100644 (file)
--- a/fs/ext4/file.c
+++ b/fs/ext4/file.c
@@ -22,9 +22,9 @@
 #include <linux/fs.h>
 #include <linux/mount.h>
 #include <linux/path.h>
-#include <linux/aio.h>
 #include <linux/quotaops.h>
 #include <linux/pagevec.h>
+#include <linux/uio.h>
 #include "ext4.h"
 #include "ext4_jbd2.h"
 #include "xattr.h"
@@ -94,11 +94,9 @@ ext4_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
        struct inode *inode = file_inode(iocb->ki_filp);
        struct mutex *aio_mutex = NULL;
        struct blk_plug plug;
-       int o_direct = io_is_direct(file);
+       int o_direct = iocb->ki_flags & IOCB_DIRECT;
        int overwrite = 0;
-       size_t length = iov_iter_count(from);
        ssize_t ret;
-       loff_t pos = iocb->ki_pos;
 
        /*
         * Unaligned direct AIO must be serialized; see comment above
@@ -107,16 +105,17 @@ ext4_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
        if (o_direct &&
            ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS) &&
            !is_sync_kiocb(iocb) &&
-           (file->f_flags & O_APPEND ||
-            ext4_unaligned_aio(inode, from, pos))) {
+           (iocb->ki_flags & IOCB_APPEND ||
+            ext4_unaligned_aio(inode, from, iocb->ki_pos))) {
                aio_mutex = ext4_aio_mutex(inode);
                mutex_lock(aio_mutex);
                ext4_unwritten_wait(inode);
        }
 
        mutex_lock(&inode->i_mutex);
-       if (file->f_flags & O_APPEND)
-               iocb->ki_pos = pos = i_size_read(inode);
+       ret = generic_write_checks(iocb, from);
+       if (ret <= 0)
+               goto out;
 
        /*
         * If we have encountered a bitmap-format file, the size limit
@@ -125,22 +124,19 @@ ext4_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
        if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) {
                struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
 
-               if ((pos > sbi->s_bitmap_maxbytes) ||
-                   (pos == sbi->s_bitmap_maxbytes && length > 0)) {
-                       mutex_unlock(&inode->i_mutex);
+               if (iocb->ki_pos >= sbi->s_bitmap_maxbytes) {
                        ret = -EFBIG;
-                       goto errout;
+                       goto out;
                }
-
-               if (pos + length > sbi->s_bitmap_maxbytes)
-                       iov_iter_truncate(from, sbi->s_bitmap_maxbytes - pos);
+               iov_iter_truncate(from, sbi->s_bitmap_maxbytes - iocb->ki_pos);
        }
 
        iocb->private = &overwrite;
        if (o_direct) {
+               size_t length = iov_iter_count(from);
+               loff_t pos = iocb->ki_pos;
                blk_start_plug(&plug);
 
-
                /* check whether we do a DIO overwrite or not */
                if (ext4_should_dioread_nolock(inode) && !aio_mutex &&
                    !file->f_mapping->nrpages && pos + length <= i_size_read(inode)) {
@@ -184,7 +180,12 @@ ext4_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
        if (o_direct)
                blk_finish_plug(&plug);
 
-errout:
+       if (aio_mutex)
+               mutex_unlock(aio_mutex);
+       return ret;
+
+out:
+       mutex_unlock(&inode->i_mutex);
        if (aio_mutex)
                mutex_unlock(aio_mutex);
        return ret;
@@ -205,6 +206,7 @@ static int ext4_dax_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
 static const struct vm_operations_struct ext4_dax_vm_ops = {
        .fault          = ext4_dax_fault,
        .page_mkwrite   = ext4_dax_mkwrite,
+       .pfn_mkwrite    = dax_pfn_mkwrite,
 };
 #else
 #define ext4_dax_vm_ops        ext4_file_vm_ops
@@ -620,8 +622,6 @@ loff_t ext4_llseek(struct file *file, loff_t offset, int whence)
 
 const struct file_operations ext4_file_operations = {
        .llseek         = ext4_llseek,
-       .read           = new_sync_read,
-       .write          = new_sync_write,
        .read_iter      = generic_file_read_iter,
        .write_iter     = ext4_file_write_iter,
        .unlocked_ioctl = ext4_ioctl,
@@ -637,26 +637,6 @@ const struct file_operations ext4_file_operations = {
        .fallocate      = ext4_fallocate,
 };
 
-#ifdef CONFIG_FS_DAX
-const struct file_operations ext4_dax_file_operations = {
-       .llseek         = ext4_llseek,
-       .read           = new_sync_read,
-       .write          = new_sync_write,
-       .read_iter      = generic_file_read_iter,
-       .write_iter     = ext4_file_write_iter,
-       .unlocked_ioctl = ext4_ioctl,
-#ifdef CONFIG_COMPAT
-       .compat_ioctl   = ext4_compat_ioctl,
-#endif
-       .mmap           = ext4_file_mmap,
-       .open           = ext4_file_open,
-       .release        = ext4_release_file,
-       .fsync          = ext4_sync_file,
-       /* Splice not yet supported with DAX */
-       .fallocate      = ext4_fallocate,
-};
-#endif
-
 const struct inode_operations ext4_file_inode_operations = {
        .setattr        = ext4_setattr,
        .getattr        = ext4_getattr,