replace d_add_unique() with saner primitive
[deliverable/linux.git] / fs / dcache.c
index 8d38cd07b207b9234d0f571bb4a945e05a395c7b..4d20bf5c609ba64e31f19857839776f1db359a9c 100644 (file)
@@ -269,9 +269,6 @@ static inline int dname_external(const struct dentry *dentry)
        return dentry->d_name.name != dentry->d_iname;
 }
 
-/*
- * Make sure other CPUs see the inode attached before the type is set.
- */
 static inline void __d_set_inode_and_type(struct dentry *dentry,
                                          struct inode *inode,
                                          unsigned type_flags)
@@ -279,28 +276,18 @@ static inline void __d_set_inode_and_type(struct dentry *dentry,
        unsigned flags;
 
        dentry->d_inode = inode;
-       smp_wmb();
        flags = READ_ONCE(dentry->d_flags);
        flags &= ~(DCACHE_ENTRY_TYPE | DCACHE_FALLTHRU);
        flags |= type_flags;
        WRITE_ONCE(dentry->d_flags, flags);
 }
 
-/*
- * Ideally, we want to make sure that other CPUs see the flags cleared before
- * the inode is detached, but this is really a violation of RCU principles
- * since the ordering suggests we should always set inode before flags.
- *
- * We should instead replace or discard the entire dentry - but that sucks
- * performancewise on mass deletion/rename.
- */
 static inline void __d_clear_type_and_inode(struct dentry *dentry)
 {
        unsigned flags = READ_ONCE(dentry->d_flags);
 
        flags &= ~(DCACHE_ENTRY_TYPE | DCACHE_FALLTHRU);
        WRITE_ONCE(dentry->d_flags, flags);
-       smp_wmb();
        dentry->d_inode = NULL;
 }
 
@@ -370,9 +357,11 @@ static void dentry_unlink_inode(struct dentry * dentry)
        __releases(dentry->d_inode->i_lock)
 {
        struct inode *inode = dentry->d_inode;
+
+       raw_write_seqcount_begin(&dentry->d_seq);
        __d_clear_type_and_inode(dentry);
        hlist_del_init(&dentry->d_u.d_alias);
-       dentry_rcuwalk_invalidate(dentry);
+       raw_write_seqcount_end(&dentry->d_seq);
        spin_unlock(&dentry->d_lock);
        spin_unlock(&inode->i_lock);
        if (!inode->i_nlink)
@@ -1571,7 +1560,8 @@ struct dentry *__d_alloc(struct super_block *sb, const struct qstr *name)
        dentry->d_iname[DNAME_INLINE_LEN-1] = 0;
        if (name->len > DNAME_INLINE_LEN-1) {
                size_t size = offsetof(struct external_name, name[1]);
-               struct external_name *p = kmalloc(size + name->len, GFP_KERNEL);
+               struct external_name *p = kmalloc(size + name->len,
+                                                 GFP_KERNEL_ACCOUNT);
                if (!p) {
                        kmem_cache_free(dentry_cache, dentry); 
                        return NULL;
@@ -1757,8 +1747,9 @@ static void __d_instantiate(struct dentry *dentry, struct inode *inode)
        spin_lock(&dentry->d_lock);
        if (inode)
                hlist_add_head(&dentry->d_u.d_alias, &inode->i_dentry);
+       raw_write_seqcount_begin(&dentry->d_seq);
        __d_set_inode_and_type(dentry, inode, add_flags);
-       dentry_rcuwalk_invalidate(dentry);
+       raw_write_seqcount_end(&dentry->d_seq);
        spin_unlock(&dentry->d_lock);
        fsnotify_d_instantiate(dentry, inode);
 }
@@ -1790,81 +1781,6 @@ void d_instantiate(struct dentry *entry, struct inode * inode)
 }
 EXPORT_SYMBOL(d_instantiate);
 
-/**
- * d_instantiate_unique - instantiate a non-aliased dentry
- * @entry: dentry to instantiate
- * @inode: inode to attach to this dentry
- *
- * Fill in inode information in the entry. On success, it returns NULL.
- * If an unhashed alias of "entry" already exists, then we return the
- * aliased dentry instead and drop one reference to inode.
- *
- * Note that in order to avoid conflicts with rename() etc, the caller
- * had better be holding the parent directory semaphore.
- *
- * This also assumes that the inode count has been incremented
- * (or otherwise set) by the caller to indicate that it is now
- * in use by the dcache.
- */
-static struct dentry *__d_instantiate_unique(struct dentry *entry,
-                                            struct inode *inode)
-{
-       struct dentry *alias;
-       int len = entry->d_name.len;
-       const char *name = entry->d_name.name;
-       unsigned int hash = entry->d_name.hash;
-
-       if (!inode) {
-               __d_instantiate(entry, NULL);
-               return NULL;
-       }
-
-       hlist_for_each_entry(alias, &inode->i_dentry, d_u.d_alias) {
-               /*
-                * Don't need alias->d_lock here, because aliases with
-                * d_parent == entry->d_parent are not subject to name or
-                * parent changes, because the parent inode i_mutex is held.
-                */
-               if (alias->d_name.hash != hash)
-                       continue;
-               if (alias->d_parent != entry->d_parent)
-                       continue;
-               if (alias->d_name.len != len)
-                       continue;
-               if (dentry_cmp(alias, name, len))
-                       continue;
-               __dget(alias);
-               return alias;
-       }
-
-       __d_instantiate(entry, inode);
-       return NULL;
-}
-
-struct dentry *d_instantiate_unique(struct dentry *entry, struct inode *inode)
-{
-       struct dentry *result;
-
-       BUG_ON(!hlist_unhashed(&entry->d_u.d_alias));
-
-       if (inode)
-               spin_lock(&inode->i_lock);
-       result = __d_instantiate_unique(entry, inode);
-       if (inode)
-               spin_unlock(&inode->i_lock);
-
-       if (!result) {
-               security_d_instantiate(entry, inode);
-               return NULL;
-       }
-
-       BUG_ON(!d_unhashed(result));
-       iput(inode);
-       return result;
-}
-
-EXPORT_SYMBOL(d_instantiate_unique);
-
 /**
  * d_instantiate_no_diralias - instantiate a non-aliased dentry
  * @entry: dentry to complete
@@ -2445,6 +2361,56 @@ void d_rehash(struct dentry * entry)
 }
 EXPORT_SYMBOL(d_rehash);
 
+/**
+ * d_exact_alias - find and hash an exact unhashed alias
+ * @entry: dentry to add
+ * @inode: The inode to go with this dentry
+ *
+ * If an unhashed dentry with the same name/parent and desired
+ * inode already exists, hash and return it.  Otherwise, return
+ * NULL.
+ *
+ * Parent directory should be locked.
+ */
+struct dentry *d_exact_alias(struct dentry *entry, struct inode *inode)
+{
+       struct dentry *alias;
+       int len = entry->d_name.len;
+       const char *name = entry->d_name.name;
+       unsigned int hash = entry->d_name.hash;
+
+       spin_lock(&inode->i_lock);
+       hlist_for_each_entry(alias, &inode->i_dentry, d_u.d_alias) {
+               /*
+                * Don't need alias->d_lock here, because aliases with
+                * d_parent == entry->d_parent are not subject to name or
+                * parent changes, because the parent inode i_mutex is held.
+                */
+               if (alias->d_name.hash != hash)
+                       continue;
+               if (alias->d_parent != entry->d_parent)
+                       continue;
+               if (alias->d_name.len != len)
+                       continue;
+               if (dentry_cmp(alias, name, len))
+                       continue;
+               spin_lock(&alias->d_lock);
+               if (!d_unhashed(alias)) {
+                       spin_unlock(&alias->d_lock);
+                       alias = NULL;
+               } else {
+                       __dget_dlock(alias);
+                       _d_rehash(alias);
+                       spin_unlock(&alias->d_lock);
+               }
+               spin_unlock(&inode->i_lock);
+               return alias;
+       }
+       spin_unlock(&inode->i_lock);
+       return NULL;
+}
+EXPORT_SYMBOL(d_exact_alias);
+
 /**
  * dentry_update_name_case - update case insensitive dentry with a new name
  * @dentry: dentry to be updated
@@ -2461,7 +2427,7 @@ EXPORT_SYMBOL(d_rehash);
  */
 void dentry_update_name_case(struct dentry *dentry, struct qstr *name)
 {
-       BUG_ON(!mutex_is_locked(&dentry->d_parent->d_inode->i_mutex));
+       BUG_ON(!inode_is_locked(dentry->d_parent->d_inode));
        BUG_ON(dentry->d_name.len != name->len); /* d_lookup gives this */
 
        spin_lock(&dentry->d_lock);
@@ -2737,7 +2703,7 @@ static int __d_unalias(struct inode *inode,
        if (!mutex_trylock(&dentry->d_sb->s_vfs_rename_mutex))
                goto out_err;
        m1 = &dentry->d_sb->s_vfs_rename_mutex;
-       if (!mutex_trylock(&alias->d_parent->d_inode->i_mutex))
+       if (!inode_trylock(alias->d_parent->d_inode))
                goto out_err;
        m2 = &alias->d_parent->d_inode->i_mutex;
 out_unalias:
@@ -3415,7 +3381,7 @@ static void __init dcache_init(void)
         * of the dcache. 
         */
        dentry_cache = KMEM_CACHE(dentry,
-               SLAB_RECLAIM_ACCOUNT|SLAB_PANIC|SLAB_MEM_SPREAD);
+               SLAB_RECLAIM_ACCOUNT|SLAB_PANIC|SLAB_MEM_SPREAD|SLAB_ACCOUNT);
 
        /* Hash may have been set up in dcache_init_early */
        if (!hashdist)
This page took 0.028535 seconds and 5 git commands to generate.