replace d_add_unique() with saner primitive (668d0cd5) · Commits · 戴 / test

fs/dcache.c

+50 −75

Original line number	Diff line number	Diff line
		@@ -1781,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
		@@ -2436,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

fs/nfs/nfs4proc.c

+7 −6

Original line number	Diff line number	Diff line
		@@ -2461,14 +2461,15 @@ static int _nfs4_open_and_get_state(struct nfs4_opendata *opendata,

		dentry = opendata->dentry;
		if (d_really_is_negative(dentry)) {
		/* FIXME: Is this d_drop() ever needed? */
		struct dentry *alias;
		d_drop(dentry);
		dentry = d_add_unique(dentry, igrab(state->inode));
		if (dentry == NULL) {
		dentry = opendata->dentry;
		} else if (dentry != ctx->dentry) {
		alias = d_exact_alias(dentry, state->inode);
		if (!alias)
		alias = d_splice_alias(igrab(state->inode), dentry);
		/* d_splice_alias() can't fail here - it's a non-directory */
		if (alias) {
		dput(ctx->dentry);
		ctx->dentry = dget(dentry);
		ctx->dentry = dentry = alias;
		}
		nfs_set_verifier(dentry,
		nfs_save_change_attribute(d_inode(opendata->dir)));

include/linux/dcache.h

+1 −17

Original line number	Diff line number	Diff line
		@@ -246,6 +246,7 @@ extern struct dentry * d_alloc(struct dentry , const struct qstr );
		extern struct dentry * d_alloc_pseudo(struct super_block , const struct qstr );
		extern struct dentry * d_splice_alias(struct inode , struct dentry );
		extern struct dentry * d_add_ci(struct dentry , struct inode , struct qstr *);
		extern struct dentry * d_exact_alias(struct dentry , struct inode );
		extern struct dentry d_find_any_alias(struct inode inode);
		extern struct dentry * d_obtain_alias(struct inode *);
		extern struct dentry * d_obtain_root(struct inode *);
		@@ -288,23 +289,6 @@ static inline void d_add(struct dentry entry, struct inode inode)
		d_rehash(entry);
		}

		/**
		* d_add_unique - add dentry to hash queues without aliasing
		* @entry: dentry to add
		* @inode: The inode to attach to this dentry
		*
		* This adds the entry to the hash queues and initializes @inode.
		* The entry was actually filled in earlier during d_alloc().
		*/
		static inline struct dentry d_add_unique(struct dentry entry, struct inode *inode)
		{
		struct dentry *res;

		res = d_instantiate_unique(entry, inode);
		d_rehash(res != NULL ? res : entry);
		return res;
		}

		extern void dentry_update_name_case(struct dentry , struct qstr );

		/* used for rename() and baskets */

Admin message