Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs

Pull vfs changes from Al Viro.
 "A lot of misc stuff.  The obvious groups:
   * Miklos' atomic_open series; kills the damn abuse of
     ->d_revalidate() by NFS, which was the major stumbling block for
     all work in that area.
   * ripping security_file_mmap() and dealing with deadlocks in the
     area; sanitizing the neighborhood of vm_mmap()/vm_munmap() in
     general.
   * ->encode_fh() switched to saner API; insane fake dentry in
     mm/cleancache.c gone.
   * assorted annotations in fs (endianness, __user)
   * parts of Artem's ->s_dirty work (jff2 and reiserfs parts)
   * ->update_time() work from Josef.
   * other bits and pieces all over the place.

  Normally it would've been in two or three pull requests, but
  signal.git stuff had eaten a lot of time during this cycle ;-/"

Fix up trivial conflicts in Documentation/filesystems/vfs.txt (the
'truncate_range' inode method was removed by the VM changes, the VFS
update adds an 'update_time()' method), and in fs/btrfs/ulist.[ch] (due
to sparse fix added twice, with other changes nearby).

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs: (95 commits)
  nfs: don't open in ->d_revalidate
  vfs: retry last component if opening stale dentry
  vfs: nameidata_to_filp(): don't throw away file on error
  vfs: nameidata_to_filp(): inline __dentry_open()
  vfs: do_dentry_open(): don't put filp
  vfs: split __dentry_open()
  vfs: do_last() common post lookup
  vfs: do_last(): add audit_inode before open
  vfs: do_last(): only return EISDIR for O_CREAT
  vfs: do_last(): check LOOKUP_DIRECTORY
  vfs: do_last(): make ENOENT exit RCU safe
  vfs: make follow_link check RCU safe
  vfs: do_last(): use inode variable
  vfs: do_last(): inline walk_component()
  vfs: do_last(): make exit RCU safe
  vfs: split do_lookup()
  Btrfs: move over to use ->update_time
  fs: introduce inode operation ->update_time
  reiserfs: get rid of resierfs_sync_super
  reiserfs: mark the superblock as dirty a bit later
  ...

5 files changed, 23 insertions, 55 deletions

diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index 0151ca1ac657..0236d03c6732 100644
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -2974,7 +2974,6 @@ int btrfs_readpage(struct file *file, struct page *page);
 void btrfs_evict_inode(struct inode *inode);
 int btrfs_write_inode(struct inode *inode, struct writeback_control *wbc);
 int btrfs_dirty_inode(struct inode *inode);
-int btrfs_update_time(struct file *file);
 struct inode *btrfs_alloc_inode(struct super_block *sb);
 void btrfs_destroy_inode(struct inode *inode);
 int btrfs_drop_inode(struct inode *inode);
diff --git a/fs/btrfs/export.c b/fs/btrfs/export.c
index e887ee62b6d4..614f34a899c2 100644
--- a/fs/btrfs/export.c
+++ b/fs/btrfs/export.c
@@ -13,15 +13,14 @@
                                              parent_root_objectid) / 4)
 #define BTRFS_FID_SIZE_CONNECTABLE_ROOT (sizeof(struct btrfs_fid) / 4)
 
-static int btrfs_encode_fh(struct dentry *dentry, u32 *fh, int *max_len,
-                           int connectable)
+static int btrfs_encode_fh(struct inode *inode, u32 *fh, int *max_len,
+                           struct inode *parent)
 {
         struct btrfs_fid *fid = (struct btrfs_fid *)fh;
-        struct inode *inode = dentry->d_inode;
         int len = *max_len;
         int type;
 
-        if (connectable && (len < BTRFS_FID_SIZE_CONNECTABLE)) {
+        if (parent && (len < BTRFS_FID_SIZE_CONNECTABLE)) {
                 *max_len = BTRFS_FID_SIZE_CONNECTABLE;
                 return 255;
         } else if (len < BTRFS_FID_SIZE_NON_CONNECTABLE) {
@@ -36,19 +35,13 @@ static int btrfs_encode_fh(struct dentry *dentry, u32 *fh, int *max_len,
         fid->root_objectid = BTRFS_I(inode)->root->objectid;
         fid->gen = inode->i_generation;
 
-        if (connectable && !S_ISDIR(inode->i_mode)) {
-                struct inode *parent;
+        if (parent) {
                 u64 parent_root_id;
 
-                spin_lock(&dentry->d_lock);
-
-                parent = dentry->d_parent->d_inode;
                 fid->parent_objectid = BTRFS_I(parent)->location.objectid;
                 fid->parent_gen = parent->i_generation;
                 parent_root_id = BTRFS_I(parent)->root->objectid;
 
-                spin_unlock(&dentry->d_lock);
-
                 if (parent_root_id != fid->root_objectid) {
                         fid->parent_root_objectid = parent_root_id;
                         len = BTRFS_FID_SIZE_CONNECTABLE_ROOT;
diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index 876cddd6b2f0..70dc8ca73e25 100644
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -1433,7 +1433,7 @@ static ssize_t btrfs_file_aio_write(struct kiocb *iocb,
                 goto out;
         }
 
-        err = btrfs_update_time(file);
+        err = file_update_time(file);
         if (err) {
                 mutex_unlock(&inode->i_mutex);
                 goto out;
diff --git a/fs/btrfs/free-space-cache.c b/fs/btrfs/free-space-cache.c
index 19a0d85b451c..81296c57405a 100644
--- a/fs/btrfs/free-space-cache.c
+++ b/fs/btrfs/free-space-cache.c
@@ -77,7 +77,8 @@ static struct inode *__lookup_free_space_inode(struct btrfs_root *root,
                 return ERR_PTR(-ENOENT);
         }
 
-        inode->i_mapping->flags &= ~__GFP_FS;
+        mapping_set_gfp_mask(inode->i_mapping,
+                        mapping_gfp_mask(inode->i_mapping) & ~__GFP_FS);
 
         return inode;
 }
@@ -367,7 +368,7 @@ static int io_ctl_prepare_pages(struct io_ctl *io_ctl, struct inode *inode,
 
 static void io_ctl_set_generation(struct io_ctl *io_ctl, u64 generation)
 {
-        u64 *val;
+        __le64 *val;
 
         io_ctl_map_page(io_ctl, 1);
 
@@ -390,7 +391,7 @@ static void io_ctl_set_generation(struct io_ctl *io_ctl, u64 generation)
 
 static int io_ctl_check_generation(struct io_ctl *io_ctl, u64 generation)
 {
-        u64 *gen;
+        __le64 *gen;
 
         /*
          * Skip the crc area.  If we don't check crcs then we just have a 64bit
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index e9991adc0960..f6ab6f5e635a 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -4475,46 +4475,18 @@ int btrfs_dirty_inode(struct inode *inode)
  * This is a copy of file_update_time.  We need this so we can return error on
  * ENOSPC for updating the inode in the case of file write and mmap writes.
  */
-int btrfs_update_time(struct file *file)
+static int btrfs_update_time(struct inode *inode, struct timespec *now,
+                             int flags)
 {
-        struct inode *inode = file->f_path.dentry->d_inode;
-        struct timespec now;
-        int ret;
-        enum { S_MTIME = 1, S_CTIME = 2, S_VERSION = 4 } sync_it = 0;
-
-        /* First try to exhaust all avenues to not sync */
-        if (IS_NOCMTIME(inode))
-                return 0;
-
-        now = current_fs_time(inode->i_sb);
-        if (!timespec_equal(&inode->i_mtime, &now))
-                sync_it = S_MTIME;
-
-        if (!timespec_equal(&inode->i_ctime, &now))
-                sync_it |= S_CTIME;
-
-        if (IS_I_VERSION(inode))
-                sync_it |= S_VERSION;
-
-        if (!sync_it)
-                return 0;
-
-        /* Finally allowed to write? Takes lock. */
-        if (mnt_want_write_file(file))
-                return 0;
-
-        /* Only change inode inside the lock region */
-        if (sync_it & S_VERSION)
+        if (flags & S_VERSION)
                 inode_inc_iversion(inode);
-        if (sync_it & S_CTIME)
-                inode->i_ctime = now;
-        if (sync_it & S_MTIME)
-                inode->i_mtime = now;
-        ret = btrfs_dirty_inode(inode);
-        if (!ret)
-                mark_inode_dirty_sync(inode);
-        mnt_drop_write(file->f_path.mnt);
-        return ret;
+        if (flags & S_CTIME)
+                inode->i_ctime = *now;
+        if (flags & S_MTIME)
+                inode->i_mtime = *now;
+        if (flags & S_ATIME)
+                inode->i_atime = *now;
+        return btrfs_dirty_inode(inode);
 }
 
 /*
@@ -6565,7 +6537,7 @@ int btrfs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
 
         ret  = btrfs_delalloc_reserve_space(inode, PAGE_CACHE_SIZE);
         if (!ret) {
-                ret = btrfs_update_time(vma->vm_file);
+                ret = file_update_time(vma->vm_file);
                 reserved = 1;
         }
         if (ret) {
@@ -7635,6 +7607,7 @@ static const struct inode_operations btrfs_file_inode_operations = {
         .permission     = btrfs_permission,
         .fiemap         = btrfs_fiemap,
         .get_acl        = btrfs_get_acl,
+        .update_time    = btrfs_update_time,
 };
 static const struct inode_operations btrfs_special_inode_operations = {
         .getattr        = btrfs_getattr,
@@ -7645,6 +7618,7 @@ static const struct inode_operations btrfs_special_inode_operations = {
         .listxattr      = btrfs_listxattr,
         .removexattr    = btrfs_removexattr,
         .get_acl        = btrfs_get_acl,
+        .update_time    = btrfs_update_time,
 };
 static const struct inode_operations btrfs_symlink_inode_operations = {
         .readlink       = generic_readlink,
@@ -7658,6 +7632,7 @@ static const struct inode_operations btrfs_symlink_inode_operations = {
         .listxattr      = btrfs_listxattr,
         .removexattr    = btrfs_removexattr,
         .get_acl        = btrfs_get_acl,
+        .update_time    = btrfs_update_time,
 };
 
 const struct dentry_operations btrfs_dentry_operations = {