Merge branch 'work.mkdir' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs

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 files changed, 47 insertions, 6 deletions

diff --git a/fs/inode.c b/fs/inode.c
index 8c86c809ca17..a06de4454232 100644
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -804,6 +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 @@ 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 @@ void unlock_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;
+        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 @@ struct inode *inode_insert5(struct inode *inode, unsigned long hashval,
 {
         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);
@@ -1039,6 +1061,8 @@ again:
                  * 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);
@@ -1060,6 +1084,8 @@ again:
         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 @@ struct inode *iget5_locked(struct super_block *sb, unsigned long hashval,
         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 @@ 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);
@@ -1165,6 +1194,8 @@ again:
                  */
                 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 @@ struct inode *ilookup5_nowait(struct super_block *sb, unsigned long hashval,
         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 @@ 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 @@ int insert_inode_locked(struct inode *inode)
                 }
                 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 @@ 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);