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

[sfrench/cifs-2.6.git] / fs / inode.c

diff --git a/fs/inode.c b/fs/inode.c
index 8c86c809ca17b30e003913e169626aa42df2e908..a06de44542325a2848a3882774df0959d1dfa17b 100644 (file)
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -804,6 +804,10 @@ repeat:
                        __wait_on_freeing_inode(inode);
                        goto 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;
                __iget(inode);
                spin_unlock(&inode->i_lock);
                return inode;


@@ -831,6 +835,10 @@ repeat:
                        __wait_on_freeing_inode(inode);
                        goto 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;
                __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));
        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);
 
        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
  *
 /**
  * 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;
 {
        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);
 
 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);
                 * 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);
                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);
        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);
 
 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 *inode = ilookup5(sb, hashval, test, data);
 
        if (!inode) {

-               struct inode *new = new_inode(sb);
+               struct inode *new = alloc_inode(sb);

 
                if (new) {
 
                if (new) {

+                       new->i_state = 0;

                        inode = inode_insert5(new, hashval, test, set, data);
                        if (unlikely(inode != new))
                        inode = inode_insert5(new, hashval, test, set, data);
                        if (unlikely(inode != new))

-                               iput(new);
+                               destroy_inode(new);

                }
        }
        return inode;
                }
        }
        return inode;


@@ -1128,6 +1155,8 @@ again:
        inode = find_inode_fast(sb, head, ino);
        spin_unlock(&inode_hash_lock);
        if (inode) {
        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);
                wait_on_inode(inode);
                if (unlikely(inode_unhashed(inode))) {
                        iput(inode);


@@ -1165,6 +1194,8 @@ again:
                 */
                spin_unlock(&inode_hash_lock);
                destroy_inode(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))) {
                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);
 
        inode = find_inode(sb, head, test, data);
        spin_unlock(&inode_hash_lock);
 

-       return inode;
+       return IS_ERR(inode) ? NULL : inode;

 }
 EXPORT_SYMBOL(ilookup5_nowait);
 
 }
 EXPORT_SYMBOL(ilookup5_nowait);
 


@@ -1338,6 +1369,8 @@ again:
        spin_unlock(&inode_hash_lock);
 
        if (inode) {
        spin_unlock(&inode_hash_lock);
 
        if (inode) {

+               if (IS_ERR(inode))
+                       return NULL;

                wait_on_inode(inode);
                if (unlikely(inode_unhashed(inode))) {
                        iput(inode);
                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);
                }
                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;
                }
                        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);
                __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)
 {
 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);
 
        if (old != inode) {
                iput(old);