Merge branch 'work.mkdir' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs
authorLinus Torvalds <torvalds@linux-foundation.org>
Tue, 14 Aug 2018 03:25:58 +0000 (20:25 -0700)
committerLinus Torvalds <torvalds@linux-foundation.org>
Tue, 14 Aug 2018 03:25:58 +0000 (20:25 -0700)
Pull vfs icache updates from Al Viro:

 - NFS mkdir/open_by_handle race fix

 - analogous solution for FUSE, replacing the one currently in mainline

 - new primitive to be used when discarding halfway set up inodes on
   failed object creation; gives sane warranties re icache lookups not
   returning such doomed by still not freed inodes. A bunch of
   filesystems switched to that animal.

 - Miklos' fix for last cycle regression in iget5_locked(); -stable will
   need a slightly different variant, unfortunately.

 - misc bits and pieces around things icache-related (in adfs and jfs).

* 'work.mkdir' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs:
  jfs: don't bother with make_bad_inode() in ialloc()
  adfs: don't put inodes into icache
  new helper: inode_fake_hash()
  vfs: don't evict uninitialized inode
  jfs: switch to discard_new_inode()
  ext2: make sure that partially set up inodes won't be returned by ext2_iget()
  udf: switch to discard_new_inode()
  ufs: switch to discard_new_inode()
  btrfs: switch to discard_new_inode()
  new primitive: discard_new_inode()
  kill d_instantiate_no_diralias()
  nfs_instantiate(): prevent multiple aliases for directory inode

1  2 
fs/btrfs/inode.c
fs/dcache.c
fs/fuse/dir.c
fs/inode.c
fs/jfs/super.c
fs/nfs/dir.c
fs/udf/namei.c
include/linux/fs.h

diff --combined fs/btrfs/inode.c
index eba61bcb9bb3cdd9759837b539c257aaaed1edef,9382e0881900e60f60c87cd42cff75f49796fe24..def3ada0f0b8e575723908a3f1e311c217499c10
@@@ -6335,8 -6335,10 +6335,10 @@@ static struct inode *btrfs_new_inode(st
        location->type = BTRFS_INODE_ITEM_KEY;
  
        ret = btrfs_insert_inode_locked(inode);
-       if (ret < 0)
+       if (ret < 0) {
+               iput(inode);
                goto fail;
+       }
  
        path->leave_spinning = 1;
        ret = btrfs_insert_empty_items(trans, root, path, key, sizes, nitems);
        return inode;
  
  fail_unlock:
-       unlock_new_inode(inode);
+       discard_new_inode(inode);
  fail:
        if (dir && name)
                BTRFS_I(dir)->index_cnt--;
        btrfs_free_path(path);
-       iput(inode);
        return ERR_PTR(ret);
  }
  
@@@ -6505,7 -6506,6 +6506,6 @@@ static int btrfs_mknod(struct inode *di
        struct btrfs_root *root = BTRFS_I(dir)->root;
        struct inode *inode = NULL;
        int err;
-       int drop_inode = 0;
        u64 objectid;
        u64 index = 0;
  
                        mode, &index);
        if (IS_ERR(inode)) {
                err = PTR_ERR(inode);
+               inode = NULL;
                goto out_unlock;
        }
  
  
        err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
        if (err)
-               goto out_unlock_inode;
+               goto out_unlock;
  
        err = btrfs_add_nondir(trans, BTRFS_I(dir), dentry, BTRFS_I(inode),
                        0, index);
-       if (err) {
-               goto out_unlock_inode;
-       } else {
-               btrfs_update_inode(trans, root, inode);
-               d_instantiate_new(dentry, inode);
-       }
+       if (err)
+               goto out_unlock;
+       btrfs_update_inode(trans, root, inode);
+       d_instantiate_new(dentry, inode);
  
  out_unlock:
        btrfs_end_transaction(trans);
        btrfs_btree_balance_dirty(fs_info);
-       if (drop_inode) {
+       if (err && inode) {
                inode_dec_link_count(inode);
-               iput(inode);
+               discard_new_inode(inode);
        }
        return err;
- out_unlock_inode:
-       drop_inode = 1;
-       unlock_new_inode(inode);
-       goto out_unlock;
  }
  
  static int btrfs_create(struct inode *dir, struct dentry *dentry,
        struct btrfs_trans_handle *trans;
        struct btrfs_root *root = BTRFS_I(dir)->root;
        struct inode *inode = NULL;
-       int drop_inode_on_err = 0;
        int err;
        u64 objectid;
        u64 index = 0;
                        mode, &index);
        if (IS_ERR(inode)) {
                err = PTR_ERR(inode);
+               inode = NULL;
                goto out_unlock;
        }
-       drop_inode_on_err = 1;
        /*
        * If the active LSM wants to access the inode during
        * d_instantiate it needs these. Smack checks to see
  
        err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
        if (err)
-               goto out_unlock_inode;
+               goto out_unlock;
  
        err = btrfs_update_inode(trans, root, inode);
        if (err)
-               goto out_unlock_inode;
+               goto out_unlock;
  
        err = btrfs_add_nondir(trans, BTRFS_I(dir), dentry, BTRFS_I(inode),
                        0, index);
        if (err)
-               goto out_unlock_inode;
+               goto out_unlock;
  
        BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
        d_instantiate_new(dentry, inode);
  
  out_unlock:
        btrfs_end_transaction(trans);
-       if (err && drop_inode_on_err) {
+       if (err && inode) {
                inode_dec_link_count(inode);
-               iput(inode);
+               discard_new_inode(inode);
        }
        btrfs_btree_balance_dirty(fs_info);
        return err;
- out_unlock_inode:
-       unlock_new_inode(inode);
-       goto out_unlock;
  }
  
  static int btrfs_link(struct dentry *old_dentry, struct inode *dir,
@@@ -6748,6 -6736,7 +6736,7 @@@ static int btrfs_mkdir(struct inode *di
                        S_IFDIR | mode, &index);
        if (IS_ERR(inode)) {
                err = PTR_ERR(inode);
+               inode = NULL;
                goto out_fail;
        }
  
  
        err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
        if (err)
-               goto out_fail_inode;
+               goto out_fail;
  
        btrfs_i_size_write(BTRFS_I(inode), 0);
        err = btrfs_update_inode(trans, root, inode);
        if (err)
-               goto out_fail_inode;
+               goto out_fail;
  
        err = btrfs_add_link(trans, BTRFS_I(dir), BTRFS_I(inode),
                        dentry->d_name.name,
                        dentry->d_name.len, 0, index);
        if (err)
-               goto out_fail_inode;
+               goto out_fail;
  
        d_instantiate_new(dentry, inode);
        drop_on_err = 0;
  
  out_fail:
        btrfs_end_transaction(trans);
-       if (drop_on_err) {
+       if (err && inode) {
                inode_dec_link_count(inode);
-               iput(inode);
+               discard_new_inode(inode);
        }
        btrfs_btree_balance_dirty(fs_info);
        return err;
- out_fail_inode:
-       unlock_new_inode(inode);
-       goto out_fail;
  }
  
  static noinline int uncompress_inline(struct btrfs_path *path,
@@@ -9005,14 -8990,13 +8990,14 @@@ again
  
        unlock_extent_cached(io_tree, page_start, page_end, &cached_state);
  
 -out_unlock:
        if (!ret2) {
                btrfs_delalloc_release_extents(BTRFS_I(inode), PAGE_SIZE, true);
                sb_end_pagefault(inode->i_sb);
                extent_changeset_free(data_reserved);
                return VM_FAULT_LOCKED;
        }
 +
 +out_unlock:
        unlock_page(page);
  out:
        btrfs_delalloc_release_extents(BTRFS_I(inode), PAGE_SIZE, (ret != 0));
@@@ -9444,7 -9428,6 +9429,7 @@@ static int btrfs_rename_exchange(struc
        u64 new_idx = 0;
        u64 root_objectid;
        int ret;
 +      int ret2;
        bool root_log_pinned = false;
        bool dest_log_pinned = false;
  
@@@ -9641,8 -9624,7 +9626,8 @@@ out_fail
                        dest_log_pinned = false;
                }
        }
 -      ret = btrfs_end_transaction(trans);
 +      ret2 = btrfs_end_transaction(trans);
 +      ret = ret ? ret : ret2;
  out_notrans:
        if (new_ino == BTRFS_FIRST_FREE_OBJECTID)
                up_read(&fs_info->subvol_sem);
@@@ -10115,7 -10097,6 +10100,6 @@@ static int btrfs_symlink(struct inode *
        struct btrfs_key key;
        struct inode *inode = NULL;
        int err;
-       int drop_inode = 0;
        u64 objectid;
        u64 index = 0;
        int name_len;
                                objectid, S_IFLNK|S_IRWXUGO, &index);
        if (IS_ERR(inode)) {
                err = PTR_ERR(inode);
+               inode = NULL;
                goto out_unlock;
        }
  
  
        err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
        if (err)
-               goto out_unlock_inode;
+               goto out_unlock;
  
        path = btrfs_alloc_path();
        if (!path) {
                err = -ENOMEM;
-               goto out_unlock_inode;
+               goto out_unlock;
        }
        key.objectid = btrfs_ino(BTRFS_I(inode));
        key.offset = 0;
                                      datasize);
        if (err) {
                btrfs_free_path(path);
-               goto out_unlock_inode;
+               goto out_unlock;
        }
        leaf = path->nodes[0];
        ei = btrfs_item_ptr(leaf, path->slots[0],
        if (!err)
                err = btrfs_add_nondir(trans, BTRFS_I(dir), dentry,
                                BTRFS_I(inode), 0, index);
-       if (err) {
-               drop_inode = 1;
-               goto out_unlock_inode;
-       }
+       if (err)
+               goto out_unlock;
  
        d_instantiate_new(dentry, inode);
  
  out_unlock:
        btrfs_end_transaction(trans);
-       if (drop_inode) {
+       if (err && inode) {
                inode_dec_link_count(inode);
-               iput(inode);
+               discard_new_inode(inode);
        }
        btrfs_btree_balance_dirty(fs_info);
        return err;
- out_unlock_inode:
-       drop_inode = 1;
-       unlock_new_inode(inode);
-       goto out_unlock;
  }
  
  static int __btrfs_prealloc_file_range(struct inode *inode, int mode,
@@@ -10439,14 -10414,14 +10417,14 @@@ static int btrfs_tmpfile(struct inode *
  
        ret = btrfs_init_inode_security(trans, inode, dir, NULL);
        if (ret)
-               goto out_inode;
+               goto out;
  
        ret = btrfs_update_inode(trans, root, inode);
        if (ret)
-               goto out_inode;
+               goto out;
        ret = btrfs_orphan_add(trans, BTRFS_I(inode));
        if (ret)
-               goto out_inode;
+               goto out;
  
        /*
         * We set number of links to 0 in btrfs_new_inode(), and here we set
         *    d_tmpfile() -> inode_dec_link_count() -> drop_nlink()
         */
        set_nlink(inode, 1);
-       unlock_new_inode(inode);
        d_tmpfile(dentry, inode);
+       unlock_new_inode(inode);
        mark_inode_dirty(inode);
  out:
        btrfs_end_transaction(trans);
-       if (ret)
-               iput(inode);
+       if (ret && inode)
+               discard_new_inode(inode);
        btrfs_btree_balance_dirty(fs_info);
        return ret;
- out_inode:
-       unlock_new_inode(inode);
-       goto out;
  }
  
  __attribute__((const))
diff --combined fs/dcache.c
index ceb7b491d1b9c32844b40caeab21207eabeddc68,11b753d29409d409edea980457a4039f24d8ab5a..34226c20d196cd029eab8df25d7ffc32a48a29fd
@@@ -358,11 -358,14 +358,11 @@@ static void dentry_unlink_inode(struct 
        __releases(dentry->d_inode->i_lock)
  {
        struct inode *inode = dentry->d_inode;
 -      bool hashed = !d_unhashed(dentry);
  
 -      if (hashed)
 -              raw_write_seqcount_begin(&dentry->d_seq);
 +      raw_write_seqcount_begin(&dentry->d_seq);
        __d_clear_type_and_inode(dentry);
        hlist_del_init(&dentry->d_u.d_alias);
 -      if (hashed)
 -              raw_write_seqcount_end(&dentry->d_seq);
 +      raw_write_seqcount_end(&dentry->d_seq);
        spin_unlock(&dentry->d_lock);
        spin_unlock(&inode->i_lock);
        if (!inode->i_nlink)
@@@ -1889,52 -1892,23 +1889,25 @@@ void d_instantiate_new(struct dentry *e
        spin_lock(&inode->i_lock);
        __d_instantiate(entry, inode);
        WARN_ON(!(inode->i_state & I_NEW));
-       inode->i_state &= ~I_NEW;
+       inode->i_state &= ~I_NEW & ~I_CREATING;
        smp_mb();
        wake_up_bit(&inode->i_state, __I_NEW);
        spin_unlock(&inode->i_lock);
  }
  EXPORT_SYMBOL(d_instantiate_new);
  
- /**
-  * d_instantiate_no_diralias - instantiate a non-aliased dentry
-  * @entry: dentry to complete
-  * @inode: inode to attach to this dentry
-  *
-  * Fill in inode information in the entry.  If a directory alias is found, then
-  * return an error (and drop inode).  Together with d_materialise_unique() this
-  * guarantees that a directory inode may never have more than one alias.
-  */
- int d_instantiate_no_diralias(struct dentry *entry, struct inode *inode)
- {
-       BUG_ON(!hlist_unhashed(&entry->d_u.d_alias));
-       security_d_instantiate(entry, inode);
-       spin_lock(&inode->i_lock);
-       if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry)) {
-               spin_unlock(&inode->i_lock);
-               iput(inode);
-               return -EBUSY;
-       }
-       __d_instantiate(entry, inode);
-       spin_unlock(&inode->i_lock);
-       return 0;
- }
- EXPORT_SYMBOL(d_instantiate_no_diralias);
  struct dentry *d_make_root(struct inode *root_inode)
  {
        struct dentry *res = NULL;
  
        if (root_inode) {
                res = d_alloc_anon(root_inode->i_sb);
 -              if (res)
 +              if (res) {
 +                      res->d_flags |= DCACHE_RCUACCESS;
                        d_instantiate(res, root_inode);
 -              else
 +              } else {
                        iput(root_inode);
 +              }
        }
        return res;
  }
diff --combined fs/fuse/dir.c
index c979329311c855b88d0669c34407e4fe4d12e5c2,4bbae6ac75c3cb3efb8d11d5a326e71853ea5bd9..d80aab0d59822e416af65bb0e014902615adf0ac
@@@ -399,7 -399,7 +399,7 @@@ static struct dentry *fuse_lookup(struc
   */
  static int fuse_create_open(struct inode *dir, struct dentry *entry,
                            struct file *file, unsigned flags,
 -                          umode_t mode, int *opened)
 +                          umode_t mode)
  {
        int err;
        struct inode *inode;
        d_instantiate(entry, inode);
        fuse_change_entry_timeout(entry, &outentry);
        fuse_invalidate_attr(dir);
 -      err = finish_open(file, entry, generic_file_open, opened);
 +      err = finish_open(file, entry, generic_file_open);
        if (err) {
                fuse_sync_release(ff, flags);
        } else {
@@@ -489,7 -489,7 +489,7 @@@ out_err
  static int fuse_mknod(struct inode *, struct dentry *, umode_t, dev_t);
  static int fuse_atomic_open(struct inode *dir, struct dentry *entry,
                            struct file *file, unsigned flags,
 -                          umode_t mode, int *opened)
 +                          umode_t mode)
  {
        int err;
        struct fuse_conn *fc = get_fuse_conn(dir);
                goto no_open;
  
        /* Only creates */
 -      *opened |= FILE_CREATED;
 +      file->f_mode |= FMODE_CREATED;
  
        if (fc->no_create)
                goto mknod;
  
 -      err = fuse_create_open(dir, entry, file, flags, mode, opened);
 +      err = fuse_create_open(dir, entry, file, flags, mode);
        if (err == -ENOSYS) {
                fc->no_create = 1;
                goto mknod;
@@@ -539,6 -539,7 +539,7 @@@ static int create_new_entry(struct fuse
  {
        struct fuse_entry_out outarg;
        struct inode *inode;
+       struct dentry *d;
        int err;
        struct fuse_forget_link *forget;
  
        }
        kfree(forget);
  
-       err = d_instantiate_no_diralias(entry, inode);
-       if (err)
-               return err;
+       d_drop(entry);
+       d = d_splice_alias(inode, entry);
+       if (IS_ERR(d))
+               return PTR_ERR(d);
  
-       fuse_change_entry_timeout(entry, &outarg);
+       if (d) {
+               fuse_change_entry_timeout(d, &outarg);
+               dput(d);
+       } else {
+               fuse_change_entry_timeout(entry, &outarg);
+       }
        fuse_invalidate_attr(dir);
        return 0;
  
diff --combined fs/inode.c
index 8c86c809ca17b30e003913e169626aa42df2e908,e44a975841586993058c934407ba508754dea4de..a06de44542325a2848a3882774df0959d1dfa17b
@@@ -804,6 -804,10 +804,10 @@@ repeat
                        __wait_on_freeing_inode(inode);
                        goto repeat;
                }
+               if (unlikely(inode->i_state & I_CREATING)) {
+                       spin_unlock(&inode->i_lock);
+                       return ERR_PTR(-ESTALE);
+               }
                __iget(inode);
                spin_unlock(&inode->i_lock);
                return inode;
@@@ -831,6 -835,10 +835,10 @@@ repeat
                        __wait_on_freeing_inode(inode);
                        goto repeat;
                }
+               if (unlikely(inode->i_state & I_CREATING)) {
+                       spin_unlock(&inode->i_lock);
+                       return ERR_PTR(-ESTALE);
+               }
                __iget(inode);
                spin_unlock(&inode->i_lock);
                return inode;
@@@ -961,13 -969,26 +969,26 @@@ void unlock_new_inode(struct inode *ino
        lockdep_annotate_inode_mutex_key(inode);
        spin_lock(&inode->i_lock);
        WARN_ON(!(inode->i_state & I_NEW));
-       inode->i_state &= ~I_NEW;
+       inode->i_state &= ~I_NEW & ~I_CREATING;
        smp_mb();
        wake_up_bit(&inode->i_state, __I_NEW);
        spin_unlock(&inode->i_lock);
  }
  EXPORT_SYMBOL(unlock_new_inode);
  
+ void discard_new_inode(struct inode *inode)
+ {
+       lockdep_annotate_inode_mutex_key(inode);
+       spin_lock(&inode->i_lock);
+       WARN_ON(!(inode->i_state & I_NEW));
+       inode->i_state &= ~I_NEW;
+       smp_mb();
+       wake_up_bit(&inode->i_state, __I_NEW);
+       spin_unlock(&inode->i_lock);
+       iput(inode);
+ }
+ EXPORT_SYMBOL(discard_new_inode);
  /**
   * lock_two_nondirectories - take two i_mutexes on non-directory objects
   *
@@@ -1029,6 -1050,7 +1050,7 @@@ struct inode *inode_insert5(struct inod
  {
        struct hlist_head *head = inode_hashtable + hash(inode->i_sb, hashval);
        struct inode *old;
+       bool creating = inode->i_state & I_CREATING;
  
  again:
        spin_lock(&inode_hash_lock);
                 * Use the old inode instead of the preallocated one.
                 */
                spin_unlock(&inode_hash_lock);
+               if (IS_ERR(old))
+                       return NULL;
                wait_on_inode(old);
                if (unlikely(inode_unhashed(old))) {
                        iput(old);
        inode->i_state |= I_NEW;
        hlist_add_head(&inode->i_hash, head);
        spin_unlock(&inode->i_lock);
+       if (!creating)
+               inode_sb_list_add(inode);
  unlock:
        spin_unlock(&inode_hash_lock);
  
@@@ -1094,12 -1120,13 +1120,13 @@@ struct inode *iget5_locked(struct super
        struct inode *inode = ilookup5(sb, hashval, test, data);
  
        if (!inode) {
-               struct inode *new = new_inode(sb);
+               struct inode *new = alloc_inode(sb);
  
                if (new) {
+                       new->i_state = 0;
                        inode = inode_insert5(new, hashval, test, set, data);
                        if (unlikely(inode != new))
-                               iput(new);
+                               destroy_inode(new);
                }
        }
        return inode;
@@@ -1128,6 -1155,8 +1155,8 @@@ again
        inode = find_inode_fast(sb, head, ino);
        spin_unlock(&inode_hash_lock);
        if (inode) {
+               if (IS_ERR(inode))
+                       return NULL;
                wait_on_inode(inode);
                if (unlikely(inode_unhashed(inode))) {
                        iput(inode);
                 */
                spin_unlock(&inode_hash_lock);
                destroy_inode(inode);
+               if (IS_ERR(old))
+                       return NULL;
                inode = old;
                wait_on_inode(inode);
                if (unlikely(inode_unhashed(inode))) {
@@@ -1282,7 -1313,7 +1313,7 @@@ struct inode *ilookup5_nowait(struct su
        inode = find_inode(sb, head, test, data);
        spin_unlock(&inode_hash_lock);
  
-       return inode;
+       return IS_ERR(inode) ? NULL : inode;
  }
  EXPORT_SYMBOL(ilookup5_nowait);
  
@@@ -1338,6 -1369,8 +1369,8 @@@ again
        spin_unlock(&inode_hash_lock);
  
        if (inode) {
+               if (IS_ERR(inode))
+                       return NULL;
                wait_on_inode(inode);
                if (unlikely(inode_unhashed(inode))) {
                        iput(inode);
@@@ -1421,12 -1454,17 +1454,17 @@@ int insert_inode_locked(struct inode *i
                }
                if (likely(!old)) {
                        spin_lock(&inode->i_lock);
-                       inode->i_state |= I_NEW;
+                       inode->i_state |= I_NEW | I_CREATING;
                        hlist_add_head(&inode->i_hash, head);
                        spin_unlock(&inode->i_lock);
                        spin_unlock(&inode_hash_lock);
                        return 0;
                }
+               if (unlikely(old->i_state & I_CREATING)) {
+                       spin_unlock(&old->i_lock);
+                       spin_unlock(&inode_hash_lock);
+                       return -EBUSY;
+               }
                __iget(old);
                spin_unlock(&old->i_lock);
                spin_unlock(&inode_hash_lock);
@@@ -1443,7 -1481,10 +1481,10 @@@ EXPORT_SYMBOL(insert_inode_locked)
  int insert_inode_locked4(struct inode *inode, unsigned long hashval,
                int (*test)(struct inode *, void *), void *data)
  {
-       struct inode *old = inode_insert5(inode, hashval, test, NULL, data);
+       struct inode *old;
+       inode->i_state |= I_CREATING;
+       old = inode_insert5(inode, hashval, test, NULL, data);
  
        if (old != inode) {
                iput(old);
@@@ -1999,14 -2040,8 +2040,14 @@@ void inode_init_owner(struct inode *ino
        inode->i_uid = current_fsuid();
        if (dir && dir->i_mode & S_ISGID) {
                inode->i_gid = dir->i_gid;
 +
 +              /* Directories are special, and always inherit S_ISGID */
                if (S_ISDIR(mode))
                        mode |= S_ISGID;
 +              else if ((mode & (S_ISGID | S_IXGRP)) == (S_ISGID | S_IXGRP) &&
 +                       !in_group_p(inode->i_gid) &&
 +                       !capable_wrt_inode_uidgid(dir, CAP_FSETID))
 +                      mode &= ~S_ISGID;
        } else
                inode->i_gid = current_fsgid();
        inode->i_mode = mode;
diff --combined fs/jfs/super.c
index f08571433aba2b3b78588eca8759894a39c86755,5403ece57dba285325c0c6591a9f72e0a0becc42..09da5cf14e2774022b1879eba30997a8035fc4da
@@@ -581,7 -581,7 +581,7 @@@ static int jfs_fill_super(struct super_
        inode->i_ino = 0;
        inode->i_size = i_size_read(sb->s_bdev->bd_inode);
        inode->i_mapping->a_ops = &jfs_metapage_aops;
-       hlist_add_fake(&inode->i_hash);
+       inode_fake_hash(inode);
        mapping_set_gfp_mask(inode->i_mapping, GFP_NOFS);
  
        sbi->direct_inode = inode;
@@@ -967,7 -967,8 +967,7 @@@ static int __init init_jfs_fs(void
        jfs_inode_cachep =
            kmem_cache_create_usercopy("jfs_ip", sizeof(struct jfs_inode_info),
                        0, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD|SLAB_ACCOUNT,
 -                      offsetof(struct jfs_inode_info, i_inline),
 -                      sizeof_field(struct jfs_inode_info, i_inline),
 +                      offsetof(struct jfs_inode_info, i_inline), IDATASIZE,
                        init_once);
        if (jfs_inode_cachep == NULL)
                return -ENOMEM;
diff --combined fs/nfs/dir.c
index f447b1a243505a776f637007c33272125f5a3446,df6fd4e5b068f4d0f1926e651d9b7ab533ce5e3e..d7f158c3efc8a18b78f9b592a1466dc7be28b7b6
@@@ -1434,11 -1434,12 +1434,11 @@@ static int do_open(struct inode *inode
  
  static int nfs_finish_open(struct nfs_open_context *ctx,
                           struct dentry *dentry,
 -                         struct file *file, unsigned open_flags,
 -                         int *opened)
 +                         struct file *file, unsigned open_flags)
  {
        int err;
  
 -      err = finish_open(file, dentry, do_open, opened);
 +      err = finish_open(file, dentry, do_open);
        if (err)
                goto out;
        if (S_ISREG(file->f_path.dentry->d_inode->i_mode))
@@@ -1451,7 -1452,7 +1451,7 @@@ out
  
  int nfs_atomic_open(struct inode *dir, struct dentry *dentry,
                    struct file *file, unsigned open_flags,
 -                  umode_t mode, int *opened)
 +                  umode_t mode)
  {
        DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
        struct nfs_open_context *ctx;
        struct inode *inode;
        unsigned int lookup_flags = 0;
        bool switched = false;
 +      int created = 0;
        int err;
  
        /* Expect a negative dentry */
                goto out;
  
        trace_nfs_atomic_open_enter(dir, ctx, open_flags);
 -      inode = NFS_PROTO(dir)->open_context(dir, ctx, open_flags, &attr, opened);
 +      inode = NFS_PROTO(dir)->open_context(dir, ctx, open_flags, &attr, &created);
 +      if (created)
 +              file->f_mode |= FMODE_CREATED;
        if (IS_ERR(inode)) {
                err = PTR_ERR(inode);
                trace_nfs_atomic_open_exit(dir, ctx, open_flags, err);
                goto out;
        }
  
 -      err = nfs_finish_open(ctx, ctx->dentry, file, open_flags, opened);
 +      err = nfs_finish_open(ctx, ctx->dentry, file, open_flags);
        trace_nfs_atomic_open_exit(dir, ctx, open_flags, err);
        put_nfs_open_context(ctx);
  out:
@@@ -1643,6 -1641,7 +1643,7 @@@ int nfs_instantiate(struct dentry *dent
        struct dentry *parent = dget_parent(dentry);
        struct inode *dir = d_inode(parent);
        struct inode *inode;
+       struct dentry *d;
        int error = -EACCES;
  
        d_drop(dentry);
                        goto out_error;
        }
        inode = nfs_fhget(dentry->d_sb, fhandle, fattr, label);
-       error = PTR_ERR(inode);
-       if (IS_ERR(inode))
+       d = d_splice_alias(inode, dentry);
+       if (IS_ERR(d)) {
+               error = PTR_ERR(d);
                goto out_error;
-       d_add(dentry, inode);
+       }
+       dput(d);
  out:
        dput(parent);
        return 0;
diff --combined fs/udf/namei.c
index 06f37ddd2997f4894859722fb7f801994e91239d,061d049c26201b4ac679a50f88711b5287904b13..58cc2414992b673296ff2d9408c62f3bd07b6f35
@@@ -351,6 -351,8 +351,6 @@@ static struct fileIdentDesc *udf_add_en
        loff_t f_pos;
        loff_t size = udf_ext0_offset(dir) + dir->i_size;
        int nfidlen;
 -      uint8_t lfi;
 -      uint16_t liu;
        udf_pblk_t block;
        struct kernel_lb_addr eloc;
        uint32_t elen = 0;
                namelen = 0;
        }
  
 -      nfidlen = (sizeof(struct fileIdentDesc) + namelen + 3) & ~3;
 +      nfidlen = ALIGN(sizeof(struct fileIdentDesc) + namelen, UDF_NAME_PAD);
  
        f_pos = udf_ext0_offset(dir);
  
                        goto out_err;
                }
  
 -              liu = le16_to_cpu(cfi->lengthOfImpUse);
 -              lfi = cfi->lengthFileIdent;
 -
                if ((cfi->fileCharacteristics & FID_FILE_CHAR_DELETED) != 0) {
 -                      if (((sizeof(struct fileIdentDesc) +
 -                                      liu + lfi + 3) & ~3) == nfidlen) {
 +                      if (udf_dir_entry_len(cfi) == nfidlen) {
                                cfi->descTag.tagSerialNum = cpu_to_le16(1);
                                cfi->fileVersionNum = cpu_to_le16(1);
                                cfi->fileCharacteristics = 0;
@@@ -602,8 -608,7 +602,7 @@@ static int udf_add_nondir(struct dentr
        fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err);
        if (unlikely(!fi)) {
                inode_dec_link_count(inode);
-               unlock_new_inode(inode);
-               iput(inode);
+               discard_new_inode(inode);
                return err;
        }
        cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
@@@ -694,8 -699,7 +693,7 @@@ static int udf_mkdir(struct inode *dir
        fi = udf_add_entry(inode, NULL, &fibh, &cfi, &err);
        if (!fi) {
                inode_dec_link_count(inode);
-               unlock_new_inode(inode);
-               iput(inode);
+               discard_new_inode(inode);
                goto out;
        }
        set_nlink(inode, 2);
        if (!fi) {
                clear_nlink(inode);
                mark_inode_dirty(inode);
-               unlock_new_inode(inode);
-               iput(inode);
+               discard_new_inode(inode);
                goto out;
        }
        cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
@@@ -1041,8 -1044,7 +1038,7 @@@ out
  out_no_entry:
        up_write(&iinfo->i_data_sem);
        inode_dec_link_count(inode);
-       unlock_new_inode(inode);
-       iput(inode);
+       discard_new_inode(inode);
        goto out;
  }
  
@@@ -1195,7 -1197,9 +1191,7 @@@ static int udf_rename(struct inode *old
  
        if (dir_fi) {
                dir_fi->icb.extLocation = cpu_to_lelb(UDF_I(new_dir)->i_location);
 -              udf_update_tag((char *)dir_fi,
 -                              (sizeof(struct fileIdentDesc) +
 -                              le16_to_cpu(dir_fi->lengthOfImpUse) + 3) & ~3);
 +              udf_update_tag((char *)dir_fi, udf_dir_entry_len(dir_fi));
                if (old_iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
                        mark_inode_dirty(old_inode);
                else
diff --combined include/linux/fs.h
index 7899737a9a3e68734ce9c608b7c78aea16986bcd,43941e230e2b80be8843745f5d2e2f1f8f9f3342..1803347105967024c7678eb4225e360471620c30
@@@ -148,9 -148,6 +148,9 @@@ typedef int (dio_iodone_t)(struct kioc
  /* Has write method(s) */
  #define FMODE_CAN_WRITE         ((__force fmode_t)0x40000)
  
 +#define FMODE_OPENED          ((__force fmode_t)0x80000)
 +#define FMODE_CREATED         ((__force fmode_t)0x100000)
 +
  /* File was opened by fanotify and shouldn't generate fanotify events */
  #define FMODE_NONOTIFY                ((__force fmode_t)0x4000000)
  
@@@ -687,6 -684,17 +687,17 @@@ static inline int inode_unhashed(struc
        return hlist_unhashed(&inode->i_hash);
  }
  
+ /*
+  * __mark_inode_dirty expects inodes to be hashed.  Since we don't
+  * want special inodes in the fileset inode space, we make them
+  * appear hashed, but do not put on any lists.  hlist_del()
+  * will work fine and require no locking.
+  */
+ static inline void inode_fake_hash(struct inode *inode)
+ {
+       hlist_add_fake(&inode->i_hash);
+ }
  /*
   * inode->i_mutex nesting subclasses for the lock validator:
   *
@@@ -1723,6 -1731,8 +1734,6 @@@ struct file_operations 
        int (*iterate) (struct file *, struct dir_context *);
        int (*iterate_shared) (struct file *, struct dir_context *);
        __poll_t (*poll) (struct file *, struct poll_table_struct *);
 -      struct wait_queue_head * (*get_poll_head)(struct file *, __poll_t);
 -      __poll_t (*poll_mask) (struct file *, __poll_t);
        long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
        long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
        int (*mmap) (struct file *, struct vm_area_struct *);
@@@ -1779,7 -1789,7 +1790,7 @@@ struct inode_operations 
        int (*update_time)(struct inode *, struct timespec64 *, int);
        int (*atomic_open)(struct inode *, struct dentry *,
                           struct file *, unsigned open_flag,
 -                         umode_t create_mode, int *opened);
 +                         umode_t create_mode);
        int (*tmpfile) (struct inode *, struct dentry *, umode_t);
        int (*set_acl)(struct inode *, struct posix_acl *, int);
  } ____cacheline_aligned;
@@@ -2017,6 -2027,8 +2028,8 @@@ static inline void init_sync_kiocb(stru
   * I_OVL_INUSE                Used by overlayfs to get exclusive ownership on upper
   *                    and work dirs among overlayfs mounts.
   *
+  * I_CREATING         New object's inode in the middle of setting up.
+  *
   * Q: What is the difference between I_WILL_FREE and I_FREEING?
   */
  #define I_DIRTY_SYNC          (1 << 0)
  #define __I_DIRTY_TIME_EXPIRED        12
  #define I_DIRTY_TIME_EXPIRED  (1 << __I_DIRTY_TIME_EXPIRED)
  #define I_WB_SWITCH           (1 << 13)
- #define I_OVL_INUSE                   (1 << 14)
+ #define I_OVL_INUSE           (1 << 14)
+ #define I_CREATING            (1 << 15)
  
  #define I_DIRTY_INODE (I_DIRTY_SYNC | I_DIRTY_DATASYNC)
  #define I_DIRTY (I_DIRTY_INODE | I_DIRTY_PAGES)
@@@ -2423,10 -2436,6 +2437,10 @@@ extern struct file *filp_open(const cha
  extern struct file *file_open_root(struct dentry *, struct vfsmount *,
                                   const char *, int, umode_t);
  extern struct file * dentry_open(const struct path *, int, const struct cred *);
 +static inline struct file *file_clone_open(struct file *file)
 +{
 +      return dentry_open(&file->f_path, file->f_flags, file->f_cred);
 +}
  extern int filp_close(struct file *, fl_owner_t id);
  
  extern struct filename *getname_flags(const char __user *, int, int *);
@@@ -2434,8 -2443,13 +2448,8 @@@ extern struct filename *getname(const c
  extern struct filename *getname_kernel(const char *);
  extern void putname(struct filename *name);
  
 -enum {
 -      FILE_CREATED = 1,
 -      FILE_OPENED = 2
 -};
  extern int finish_open(struct file *file, struct dentry *dentry,
 -                      int (*open)(struct inode *, struct file *),
 -                      int *opened);
 +                      int (*open)(struct inode *, struct file *));
  extern int finish_no_open(struct file *file, struct dentry *dentry);
  
  /* fs/ioctl.c */
@@@ -2919,6 -2933,7 +2933,7 @@@ extern void lockdep_annotate_inode_mute
  static inline void lockdep_annotate_inode_mutex_key(struct inode *inode) { };
  #endif
  extern void unlock_new_inode(struct inode *);
+ extern void discard_new_inode(struct inode *);
  extern unsigned int get_next_ino(void);
  extern void evict_inodes(struct super_block *sb);