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

Pull ext4 updates from Ted Ts'o:
 "A very large number of cleanups and bug fixes --- in particular for
  the ext4 encryption patches, which is a new feature added in the last
  merge window.  Also fix a number of long-standing xfstest failures.
  (Quota writes failing due to ENOSPC, a race between truncate and
  writepage in data=journalled mode that was causing generic/068 to
  fail, and other corner cases.)

  Also add support for FALLOC_FL_INSERT_RANGE, and improve jbd2
  performance eliminating locking when a buffer is modified more than
  once during a transaction (which is very common for allocation
  bitmaps, for example), in which case the state of the journalled
  buffer head doesn't need to change"

[ I renamed "ext4_follow_link()" to "ext4_encrypted_follow_link()" in
  the merge resolution, to make it clear that that function is _only_
  used for encrypted symlinks.  The function doesn't actually work for
  non-encrypted symlinks at all, and they use the generic helpers
                                         - Linus ]

* tag 'ext4_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4: (52 commits)
  ext4: set lazytime on remount if MS_LAZYTIME is set by mount
  ext4: only call ext4_truncate when size <= isize
  ext4: make online defrag error reporting consistent
  ext4: minor cleanup of ext4_da_reserve_space()
  ext4: don't retry file block mapping on bigalloc fs with non-extent file
  ext4: prevent ext4_quota_write() from failing due to ENOSPC
  ext4: call sync_blockdev() before invalidate_bdev() in put_super()
  jbd2: speedup jbd2_journal_dirty_metadata()
  jbd2: get rid of open coded allocation retry loop
  ext4: improve warning directory handling messages
  jbd2: fix ocfs2 corrupt when updating journal superblock fails
  ext4: mballoc: avoid 20-argument function call
  ext4: wait for existing dio workers in ext4_alloc_file_blocks()
  ext4: recalculate journal credits as inode depth changes
  jbd2: use GFP_NOFS in jbd2_cleanup_journal_tail()
  ext4: use swap() in mext_page_double_lock()
  ext4: use swap() in memswap()
  ext4: fix race between truncate and __ext4_journalled_writepage()
  ext4 crypto: fail the mount if blocksize != pagesize
  ext4: Add support FALLOC_FL_INSERT_RANGE for fallocate
  ...

diff --cc fs/ext4/ext4.h
Simple merge

diff --cc fs/ext4/inode.c
Simple merge

diff --cc fs/ext4/namei.c
Simple merge

diff --cc fs/ext4/symlink.c
index ba5bd18,68e915a..c677f2c
--- 1/fs/ext4/symlink.c
--- 2/fs/ext4/symlink.c
+++ b/fs/ext4/symlink.c
@@@ -23,7 -23,7 +23,7 @@@
  #include "xattr.h"
  
  #ifdef CONFIG_EXT4_FS_ENCRYPTION
- static const char *ext4_follow_link(struct dentry *dentry, void **cookie)
 -static void *ext4_follow_link(struct dentry *dentry, struct nameidata *nd)
++static const char *ext4_encrypted_follow_link(struct dentry *dentry, void **cookie)
  {
        struct page *cpage = NULL;
        char *caddr, *paddr = NULL;
@@@ -35,19 -34,20 +34,17 @@@
        int res;
        u32 plen, max_size = inode->i_sb->s_blocksize;
  
-       ctx = ext4_get_fname_crypto_ctx(inode, inode->i_sb->s_blocksize);
-       if (IS_ERR(ctx))
-               return ERR_CAST(ctx);
 -      if (!ext4_encrypted_inode(inode))
 -              return page_follow_link_light(dentry, nd);
 -
+       res = ext4_get_encryption_info(inode);
+       if (res)
+               return ERR_PTR(res);
  
        if (ext4_inode_is_fast_symlink(inode)) {
                caddr = (char *) EXT4_I(inode)->i_data;
                max_size = sizeof(EXT4_I(inode)->i_data);
        } else {
                cpage = read_mapping_page(inode->i_mapping, 0, NULL);
-               if (IS_ERR(cpage)) {
-                       ext4_put_fname_crypto_ctx(&ctx);
+               if (IS_ERR(cpage))
 -                      return cpage;
 +                      return ERR_CAST(cpage);
-               }
                caddr = kmap(cpage);
                caddr[size] = 0;
        }
@@@ -77,14 -78,13 +75,12 @@@
        /* Null-terminate the name */
        if (res <= plen)
                paddr[res] = '\0';
-       ext4_put_fname_crypto_ctx(&ctx);
 -      nd_set_link(nd, paddr);
        if (cpage) {
                kunmap(cpage);
                page_cache_release(cpage);
        }
 -      return NULL;
 +      return *cookie = paddr;
  errout:
-       ext4_put_fname_crypto_ctx(&ctx);
        if (cpage) {
                kunmap(cpage);
                page_cache_release(cpage);
@@@ -93,22 -93,36 +89,22 @@@
        return ERR_PTR(res);
  }
  
 -static void ext4_put_link(struct dentry *dentry, struct nameidata *nd,
 -                        void *cookie)
 -{
 -      struct page *page = cookie;
 -
 -      if (!page) {
 -              kfree(nd_get_link(nd));
 -      } else {
 -              kunmap(page);
 -              page_cache_release(page);
 -      }
 -}
 +const struct inode_operations ext4_encrypted_symlink_inode_operations = {
 +      .readlink       = generic_readlink,
-       .follow_link    = ext4_follow_link,
++      .follow_link    = ext4_encrypted_follow_link,
 +      .put_link       = kfree_put_link,
 +      .setattr        = ext4_setattr,
 +      .setxattr       = generic_setxattr,
 +      .getxattr       = generic_getxattr,
 +      .listxattr      = ext4_listxattr,
 +      .removexattr    = generic_removexattr,
 +};
  #endif
  
 -static void *ext4_follow_fast_link(struct dentry *dentry, struct nameidata *nd)
 -{
 -      struct ext4_inode_info *ei = EXT4_I(d_inode(dentry));
 -      nd_set_link(nd, (char *) ei->i_data);
 -      return NULL;
 -}
 -
  const struct inode_operations ext4_symlink_inode_operations = {
        .readlink       = generic_readlink,
 -#ifdef CONFIG_EXT4_FS_ENCRYPTION
 -      .follow_link    = ext4_follow_link,
 -      .put_link       = ext4_put_link,
 -#else
        .follow_link    = page_follow_link_light,
        .put_link       = page_put_link,
 -#endif
        .setattr        = ext4_setattr,
        .setxattr       = generic_setxattr,
        .getxattr       = generic_getxattr,