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

Pull ext4 updates from Ted Ts'o:
 "The usual collection of bug fixes and optimizations.  Perhaps of
  greatest note is a speed up for parallel, non-allocating DIO writes,
  since we no longer take the i_mutex lock in that case.

  For bug fixes, we fix an incorrect overhead calculation which caused
  slightly incorrect results for df(1) and statfs(2).  We also fixed
  bugs in the metadata checksum feature."

* tag 'ext4_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4: (23 commits)
  ext4: undo ext4_calc_metadata_amount if we fail to claim space
  ext4: don't let i_reserved_meta_blocks go negative
  ext4: fix hole punch failure when depth is greater than 0
  ext4: remove unnecessary argument from __ext4_handle_dirty_metadata()
  ext4: weed out ext4_write_super
  ext4: remove unnecessary superblock dirtying
  ext4: convert last user of ext4_mark_super_dirty() to ext4_handle_dirty_super()
  ext4: remove useless marking of superblock dirty
  ext4: fix ext4 mismerge back in January
  ext4: remove dynamic array size in ext4_chksum()
  ext4: remove unused variable in ext4_update_super()
  ext4: make quota as first class supported feature
  ext4: don't take the i_mutex lock when doing DIO overwrites
  ext4: add a new nolock flag in ext4_map_blocks
  ext4: split ext4_file_write into buffered IO and direct IO
  ext4: remove an unused statement in ext4_mb_get_buddy_page_lock()
  ext4: fix out-of-date comments in extents.c
  ext4: use s_csum_seed instead of i_csum_seed for xattr block
  ext4: use proper csum calculation in ext4_rename
  ext4: fix overhead calculation used by ext4_statfs()
  ...

1 files changed, 98 insertions, 23 deletions

diff --git a/fs/ext4/file.c b/fs/ext4/file.c
index 782eecb57e43..3b0e3bdaabfc 100644
--- a/fs/ext4/file.c
+++ b/fs/ext4/file.c
@@ -90,11 +90,91 @@ ext4_unaligned_aio(struct inode *inode, const struct iovec *iov,
 }
 
 static ssize_t
+ext4_file_dio_write(struct kiocb *iocb, const struct iovec *iov,
+                    unsigned long nr_segs, loff_t pos)
+{
+        struct file *file = iocb->ki_filp;
+        struct inode *inode = file->f_mapping->host;
+        struct blk_plug plug;
+        int unaligned_aio = 0;
+        ssize_t ret;
+        int overwrite = 0;
+        size_t length = iov_length(iov, nr_segs);
+
+        if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS) &&
+            !is_sync_kiocb(iocb))
+                unaligned_aio = ext4_unaligned_aio(inode, iov, nr_segs, pos);
+
+        /* Unaligned direct AIO must be serialized; see comment above */
+        if (unaligned_aio) {
+                static unsigned long unaligned_warn_time;
+
+                /* Warn about this once per day */
+                if (printk_timed_ratelimit(&unaligned_warn_time, 60*60*24*HZ))
+                        ext4_msg(inode->i_sb, KERN_WARNING,
+                                 "Unaligned AIO/DIO on inode %ld by %s; "
+                                 "performance will be poor.",
+                                 inode->i_ino, current->comm);
+                mutex_lock(ext4_aio_mutex(inode));
+                ext4_aiodio_wait(inode);
+        }
+
+        BUG_ON(iocb->ki_pos != pos);
+
+        mutex_lock(&inode->i_mutex);
+        blk_start_plug(&plug);
+
+        iocb->private = &overwrite;
+
+        /* check whether we do a DIO overwrite or not */
+        if (ext4_should_dioread_nolock(inode) && !unaligned_aio &&
+            !file->f_mapping->nrpages && pos + length <= i_size_read(inode)) {
+                struct ext4_map_blocks map;
+                unsigned int blkbits = inode->i_blkbits;
+                int err, len;
+
+                map.m_lblk = pos >> blkbits;
+                map.m_len = (EXT4_BLOCK_ALIGN(pos + length, blkbits) >> blkbits)
+                        - map.m_lblk;
+                len = map.m_len;
+
+                err = ext4_map_blocks(NULL, inode, &map, 0);
+                /*
+                 * 'err==len' means that all of blocks has been preallocated no
+                 * matter they are initialized or not.  For excluding
+                 * uninitialized extents, we need to check m_flags.  There are
+                 * two conditions that indicate for initialized extents.
+                 * 1) If we hit extent cache, EXT4_MAP_MAPPED flag is returned;
+                 * 2) If we do a real lookup, non-flags are returned.
+                 * So we should check these two conditions.
+                 */
+                if (err == len && (map.m_flags & EXT4_MAP_MAPPED))
+                        overwrite = 1;
+        }
+
+        ret = __generic_file_aio_write(iocb, iov, nr_segs, &iocb->ki_pos);
+        mutex_unlock(&inode->i_mutex);
+
+        if (ret > 0 || ret == -EIOCBQUEUED) {
+                ssize_t err;
+
+                err = generic_write_sync(file, pos, ret);
+                if (err < 0 && ret > 0)
+                        ret = err;
+        }
+        blk_finish_plug(&plug);
+
+        if (unaligned_aio)
+                mutex_unlock(ext4_aio_mutex(inode));
+
+        return ret;
+}
+
+static ssize_t
 ext4_file_write(struct kiocb *iocb, const struct iovec *iov,
                 unsigned long nr_segs, loff_t pos)
 {
         struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
-        int unaligned_aio = 0;
         ssize_t ret;
 
         /*
@@ -114,29 +194,12 @@ ext4_file_write(struct kiocb *iocb, const struct iovec *iov,
                         nr_segs = iov_shorten((struct iovec *)iov, nr_segs,
                                               sbi->s_bitmap_maxbytes - pos);
                 }
-        } else if (unlikely((iocb->ki_filp->f_flags & O_DIRECT) &&
-                   !is_sync_kiocb(iocb))) {
-                unaligned_aio = ext4_unaligned_aio(inode, iov, nr_segs, pos);
         }
 
-        /* Unaligned direct AIO must be serialized; see comment above */
-        if (unaligned_aio) {
-                static unsigned long unaligned_warn_time;
-
-                /* Warn about this once per day */
-                if (printk_timed_ratelimit(&unaligned_warn_time, 60*60*24*HZ))
-                        ext4_msg(inode->i_sb, KERN_WARNING,
-                                 "Unaligned AIO/DIO on inode %ld by %s; "
-                                 "performance will be poor.",
-                                 inode->i_ino, current->comm);
-                mutex_lock(ext4_aio_mutex(inode));
-                ext4_aiodio_wait(inode);
-        }
-
-        ret = generic_file_aio_write(iocb, iov, nr_segs, pos);
-
-        if (unaligned_aio)
-                mutex_unlock(ext4_aio_mutex(inode));
+        if (unlikely(iocb->ki_filp->f_flags & O_DIRECT))
+                ret = ext4_file_dio_write(iocb, iov, nr_segs, pos);
+        else
+                ret = generic_file_aio_write(iocb, iov, nr_segs, pos);
 
         return ret;
 }
@@ -181,9 +244,21 @@ static int ext4_file_open(struct inode * inode, struct file * filp)
                 path.dentry = mnt->mnt_root;
                 cp = d_path(&path, buf, sizeof(buf));
                 if (!IS_ERR(cp)) {
+                        handle_t *handle;
+                        int err;
+
+                        handle = ext4_journal_start_sb(sb, 1);
+                        if (IS_ERR(handle))
+                                return PTR_ERR(handle);
+                        err = ext4_journal_get_write_access(handle, sbi->s_sbh);
+                        if (err) {
+                                ext4_journal_stop(handle);
+                                return err;
+                        }
                         strlcpy(sbi->s_es->s_last_mounted, cp,
                                 sizeof(sbi->s_es->s_last_mounted));
-                        ext4_mark_super_dirty(sb);
+                        ext4_handle_dirty_super(handle, sb);
+                        ext4_journal_stop(handle);
                 }
         }
         /*