Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs (8169d300) · Commits · 戴 / test

fs/dcache.c

+102 −216

Original line number	Original line	Diff line number	Diff line
	@@ -246,16 +246,8 @@ static void __d_free(struct rcu_head *head)
	kmem_cache_free(dentry_cache, dentry);		kmem_cache_free(dentry_cache, dentry);
	}		}

	/*		static void dentry_free(struct dentry *dentry)
	* no locks, please.
	*/
	static void d_free(struct dentry *dentry)
	{		{
	BUG_ON((int)dentry->d_lockref.count > 0);
	this_cpu_dec(nr_dentry);
	if (dentry->d_op && dentry->d_op->d_release)
	dentry->d_op->d_release(dentry);

	/* if dentry was never visible to RCU, immediate free is OK */		/* if dentry was never visible to RCU, immediate free is OK */
	if (!(dentry->d_flags & DCACHE_RCUACCESS))		if (!(dentry->d_flags & DCACHE_RCUACCESS))
	__d_free(&dentry->d_u.d_rcu);		__d_free(&dentry->d_u.d_rcu);
	@@ -403,56 +395,6 @@ static void dentry_lru_add(struct dentry *dentry)
	d_lru_add(dentry);		d_lru_add(dentry);
	}		}

	/*
	* Remove a dentry with references from the LRU.
	*
	* If we are on the shrink list, then we can get to try_prune_one_dentry() and
	* lose our last reference through the parent walk. In this case, we need to
	* remove ourselves from the shrink list, not the LRU.
	*/
	static void dentry_lru_del(struct dentry *dentry)
	{
	if (dentry->d_flags & DCACHE_LRU_LIST) {
	if (dentry->d_flags & DCACHE_SHRINK_LIST)
	return d_shrink_del(dentry);
	d_lru_del(dentry);
	}
	}

	/**
	* d_kill - kill dentry and return parent
	* @dentry: dentry to kill
	* @parent: parent dentry
	*
	* The dentry must already be unhashed and removed from the LRU.
	*
	* If this is the root of the dentry tree, return NULL.
	*
	* dentry->d_lock and parent->d_lock must be held by caller, and are dropped by
	* d_kill.
	*/
	static struct dentry d_kill(struct dentry dentry, struct dentry *parent)
	__releases(dentry->d_lock)
	__releases(parent->d_lock)
	__releases(dentry->d_inode->i_lock)
	{
	list_del(&dentry->d_u.d_child);
	/*
	* Inform d_walk() that we are no longer attached to the
	* dentry tree
	*/
	dentry->d_flags \|= DCACHE_DENTRY_KILLED;
	if (parent)
	spin_unlock(&parent->d_lock);
	dentry_iput(dentry);
	/*
	* dentry_iput drops the locks, at which point nobody (except
	* transient RCU lookups) can reach this dentry.
	*/
	d_free(dentry);
	return parent;
	}

	/**		/**
	* d_drop - drop a dentry		* d_drop - drop a dentry
	* @dentry: dentry to drop		* @dentry: dentry to drop
	@@ -510,7 +452,14 @@ dentry_kill(struct dentry *dentry, int unlock_on_failure)
	__releases(dentry->d_lock)		__releases(dentry->d_lock)
	{		{
	struct inode *inode;		struct inode *inode;
	struct dentry *parent;		struct dentry *parent = NULL;
			bool can_free = true;

			if (unlikely(dentry->d_flags & DCACHE_DENTRY_KILLED)) {
			can_free = dentry->d_flags & DCACHE_MAY_FREE;
			spin_unlock(&dentry->d_lock);
			goto out;
			}

	inode = dentry->d_inode;		inode = dentry->d_inode;
	if (inode && !spin_trylock(&inode->i_lock)) {		if (inode && !spin_trylock(&inode->i_lock)) {
	@@ -521,9 +470,7 @@ relock:
	}		}
	return dentry; /* try again with same dentry */		return dentry; /* try again with same dentry */
	}		}
	if (IS_ROOT(dentry))		if (!IS_ROOT(dentry))
	parent = NULL;
	else
	parent = dentry->d_parent;		parent = dentry->d_parent;
	if (parent && !spin_trylock(&parent->d_lock)) {		if (parent && !spin_trylock(&parent->d_lock)) {
	if (inode)		if (inode)
	@@ -543,10 +490,40 @@ relock:
	if ((dentry->d_flags & DCACHE_OP_PRUNE) && !d_unhashed(dentry))		if ((dentry->d_flags & DCACHE_OP_PRUNE) && !d_unhashed(dentry))
	dentry->d_op->d_prune(dentry);		dentry->d_op->d_prune(dentry);

	dentry_lru_del(dentry);		if (dentry->d_flags & DCACHE_LRU_LIST) {
			if (!(dentry->d_flags & DCACHE_SHRINK_LIST))
			d_lru_del(dentry);
			}
	/* if it was on the hash then remove it */		/* if it was on the hash then remove it */
	__d_drop(dentry);		__d_drop(dentry);
	return d_kill(dentry, parent);		list_del(&dentry->d_u.d_child);
			/*
			* Inform d_walk() that we are no longer attached to the
			* dentry tree
			*/
			dentry->d_flags \|= DCACHE_DENTRY_KILLED;
			if (parent)
			spin_unlock(&parent->d_lock);
			dentry_iput(dentry);
			/*
			* dentry_iput drops the locks, at which point nobody (except
			* transient RCU lookups) can reach this dentry.
			*/
			BUG_ON((int)dentry->d_lockref.count > 0);
			this_cpu_dec(nr_dentry);
			if (dentry->d_op && dentry->d_op->d_release)
			dentry->d_op->d_release(dentry);

			spin_lock(&dentry->d_lock);
			if (dentry->d_flags & DCACHE_SHRINK_LIST) {
			dentry->d_flags \|= DCACHE_MAY_FREE;
			can_free = false;
			}
			spin_unlock(&dentry->d_lock);
			out:
			if (likely(can_free))
			dentry_free(dentry);
			return parent;
	}		}

	/*		/*
	@@ -815,65 +792,13 @@ restart:
	}		}
	EXPORT_SYMBOL(d_prune_aliases);		EXPORT_SYMBOL(d_prune_aliases);

	/*
	* Try to throw away a dentry - free the inode, dput the parent.
	* Requires dentry->d_lock is held, and dentry->d_count == 0.
	* Releases dentry->d_lock.
	*
	* This may fail if locks cannot be acquired no problem, just try again.
	*/
	static struct dentry * try_prune_one_dentry(struct dentry *dentry)
	__releases(dentry->d_lock)
	{
	struct dentry *parent;

	parent = dentry_kill(dentry, 0);
	/*
	* If dentry_kill returns NULL, we have nothing more to do.
	* if it returns the same dentry, trylocks failed. In either
	* case, just loop again.
	*
	* Otherwise, we need to prune ancestors too. This is necessary
	* to prevent quadratic behavior of shrink_dcache_parent(), but
	* is also expected to be beneficial in reducing dentry cache
	* fragmentation.
	*/
	if (!parent)
	return NULL;
	if (parent == dentry)
	return dentry;

	/* Prune ancestors. */
	dentry = parent;
	while (dentry) {
	if (lockref_put_or_lock(&dentry->d_lockref))
	return NULL;
	dentry = dentry_kill(dentry, 1);
	}
	return NULL;
	}

	static void shrink_dentry_list(struct list_head *list)		static void shrink_dentry_list(struct list_head *list)
	{		{
	struct dentry *dentry;		struct dentry dentry, parent;

	rcu_read_lock();
	for (;;) {
	dentry = list_entry_rcu(list->prev, struct dentry, d_lru);
	if (&dentry->d_lru == list)
	break; /* empty */

	/*		while (!list_empty(list)) {
	* Get the dentry lock, and re-verify that the dentry is		dentry = list_entry(list->prev, struct dentry, d_lru);
	* this on the shrinking list. If it is, we know that
	* DCACHE_SHRINK_LIST and DCACHE_LRU_LIST are set.
	*/
	spin_lock(&dentry->d_lock);		spin_lock(&dentry->d_lock);
	if (dentry != list_entry(list->prev, struct dentry, d_lru)) {
	spin_unlock(&dentry->d_lock);
	continue;
	}

	/*		/*
	* The dispose list is isolated and dentries are not accounted		* The dispose list is isolated and dentries are not accounted
	* to the LRU here, so we can simply remove it from the list		* to the LRU here, so we can simply remove it from the list
	@@ -885,30 +810,38 @@ static void shrink_dentry_list(struct list_head *list)
	* We found an inuse dentry which was not removed from		* We found an inuse dentry which was not removed from
	* the LRU because of laziness during lookup. Do not free it.		* the LRU because of laziness during lookup. Do not free it.
	*/		*/
	if (dentry->d_lockref.count) {		if ((int)dentry->d_lockref.count > 0) {
	spin_unlock(&dentry->d_lock);		spin_unlock(&dentry->d_lock);
	continue;		continue;
	}		}
	rcu_read_unlock();

			parent = dentry_kill(dentry, 0);
	/*		/*
	* If 'try_to_prune()' returns a dentry, it will		* If dentry_kill returns NULL, we have nothing more to do.
	* be the same one we passed in, and d_lock will
	* have been held the whole time, so it will not
	* have been added to any other lists. We failed
	* to get the inode lock.
	*
	* We just add it back to the shrink list.
	*/		*/
	dentry = try_prune_one_dentry(dentry);		if (!parent)
			continue;

	rcu_read_lock();		if (unlikely(parent == dentry)) {
	if (dentry) {		/*
			* trylocks have failed and d_lock has been held the
			* whole time, so it could not have been added to any
			* other lists. Just add it back to the shrink list.
			*/
	d_shrink_add(dentry, list);		d_shrink_add(dentry, list);
	spin_unlock(&dentry->d_lock);		spin_unlock(&dentry->d_lock);
			continue;
	}		}
			/*
			* We need to prune ancestors too. This is necessary to prevent
			* quadratic behavior of shrink_dcache_parent(), but is also
			* expected to be beneficial in reducing dentry cache
			* fragmentation.
			*/
			dentry = parent;
			while (dentry && !lockref_put_or_lock(&dentry->d_lockref))
			dentry = dentry_kill(dentry, 1);
	}		}
	rcu_read_unlock();
	}		}

	static enum lru_status		static enum lru_status
	@@ -1261,34 +1194,23 @@ static enum d_walk_ret select_collect(void _data, struct dentry dentry)
	if (data->start == dentry)		if (data->start == dentry)
	goto out;		goto out;

	/*		if (dentry->d_flags & DCACHE_SHRINK_LIST) {
	* move only zero ref count dentries to the dispose list.		data->found++;
	*		} else {
	* Those which are presently on the shrink list, being processed		if (dentry->d_flags & DCACHE_LRU_LIST)
	* by shrink_dentry_list(), shouldn't be moved. Otherwise the
	* loop in shrink_dcache_parent() might not make any progress
	* and loop forever.
	*/
	if (dentry->d_lockref.count) {
	dentry_lru_del(dentry);
	} else if (!(dentry->d_flags & DCACHE_SHRINK_LIST)) {
	/*
	* We can't use d_lru_shrink_move() because we
	* need to get the global LRU lock and do the
	* LRU accounting.
	*/
	d_lru_del(dentry);		d_lru_del(dentry);
			if (!dentry->d_lockref.count) {
	d_shrink_add(dentry, &data->dispose);		d_shrink_add(dentry, &data->dispose);
	data->found++;		data->found++;
	ret = D_WALK_NORETRY;		}
	}		}
	/*		/*
	* We can return to the caller if we have found some (this		* We can return to the caller if we have found some (this
	* ensures forward progress). We'll be coming back to find		* ensures forward progress). We'll be coming back to find
	* the rest.		* the rest.
	*/		*/
	if (data->found && need_resched())		if (!list_empty(&data->dispose))
	ret = D_WALK_QUIT;		ret = need_resched() ? D_WALK_QUIT : D_WALK_NORETRY;
	out:		out:
	return ret;		return ret;
	}		}
	@@ -1318,45 +1240,35 @@ void shrink_dcache_parent(struct dentry *parent)
	}		}
	EXPORT_SYMBOL(shrink_dcache_parent);		EXPORT_SYMBOL(shrink_dcache_parent);

	static enum d_walk_ret umount_collect(void _data, struct dentry dentry)		static enum d_walk_ret umount_check(void _data, struct dentry dentry)
	{		{
	struct select_data *data = _data;		/* it has busy descendents; complain about those instead */
	enum d_walk_ret ret = D_WALK_CONTINUE;		if (!list_empty(&dentry->d_subdirs))
			return D_WALK_CONTINUE;

	if (dentry->d_lockref.count) {		/* root with refcount 1 is fine */
	dentry_lru_del(dentry);		if (dentry == _data && dentry->d_lockref.count == 1)
	if (likely(!list_empty(&dentry->d_subdirs)))		return D_WALK_CONTINUE;
	goto out;
	if (dentry == data->start && dentry->d_lockref.count == 1)		printk(KERN_ERR "BUG: Dentry %p{i=%lx,n=%pd} "
	goto out;		" still in use (%d) [unmount of %s %s]\n",
	printk(KERN_ERR
	"BUG: Dentry %p{i=%lx,n=%s}"
	" still in use (%d)"
	" [unmount of %s %s]\n",
	dentry,		dentry,
	dentry->d_inode ?		dentry->d_inode ?
	dentry->d_inode->i_ino : 0UL,		dentry->d_inode->i_ino : 0UL,
	dentry->d_name.name,		dentry,
	dentry->d_lockref.count,		dentry->d_lockref.count,
	dentry->d_sb->s_type->name,		dentry->d_sb->s_type->name,
	dentry->d_sb->s_id);		dentry->d_sb->s_id);
	BUG();		WARN_ON(1);
	} else if (!(dentry->d_flags & DCACHE_SHRINK_LIST)) {		return D_WALK_CONTINUE;
	/*
	* We can't use d_lru_shrink_move() because we
	* need to get the global LRU lock and do the
	* LRU accounting.
	*/
	if (dentry->d_flags & DCACHE_LRU_LIST)
	d_lru_del(dentry);
	d_shrink_add(dentry, &data->dispose);
	data->found++;
	ret = D_WALK_NORETRY;
	}		}
	out:
	if (data->found && need_resched())		static void do_one_tree(struct dentry *dentry)
	ret = D_WALK_QUIT;		{
	return ret;		shrink_dcache_parent(dentry);
			d_walk(dentry, dentry, umount_check, NULL);
			d_drop(dentry);
			dput(dentry);
	}		}

	/*		/*
	@@ -1366,40 +1278,15 @@ void shrink_dcache_for_umount(struct super_block *sb)
	{		{
	struct dentry *dentry;		struct dentry *dentry;

	if (down_read_trylock(&sb->s_umount))		WARN(down_read_trylock(&sb->s_umount), "s_umount should've been locked");
	BUG();

	dentry = sb->s_root;		dentry = sb->s_root;
	sb->s_root = NULL;		sb->s_root = NULL;
	for (;;) {		do_one_tree(dentry);
	struct select_data data;

	INIT_LIST_HEAD(&data.dispose);
	data.start = dentry;
	data.found = 0;

	d_walk(dentry, &data, umount_collect, NULL);
	if (!data.found)
	break;

	shrink_dentry_list(&data.dispose);
	cond_resched();
	}
	d_drop(dentry);
	dput(dentry);

	while (!hlist_bl_empty(&sb->s_anon)) {		while (!hlist_bl_empty(&sb->s_anon)) {
	struct select_data data;		dentry = dget(hlist_bl_entry(hlist_bl_first(&sb->s_anon), struct dentry, d_hash));
	dentry = hlist_bl_entry(hlist_bl_first(&sb->s_anon), struct dentry, d_hash);		do_one_tree(dentry);

	INIT_LIST_HEAD(&data.dispose);
	data.start = NULL;
	data.found = 0;

	d_walk(dentry, &data, umount_collect, NULL);
	if (data.found)
	shrink_dentry_list(&data.dispose);
	cond_resched();
	}		}
	}		}

	@@ -1647,8 +1534,7 @@ static void __d_instantiate(struct dentry dentry, struct inode inode)
	unsigned add_flags = d_flags_for_inode(inode);		unsigned add_flags = d_flags_for_inode(inode);

	spin_lock(&dentry->d_lock);		spin_lock(&dentry->d_lock);
	dentry->d_flags &= ~DCACHE_ENTRY_TYPE;		__d_set_type(dentry, add_flags);
	dentry->d_flags \|= add_flags;
	if (inode)		if (inode)
	hlist_add_head(&dentry->d_alias, &inode->i_dentry);		hlist_add_head(&dentry->d_alias, &inode->i_dentry);
	dentry->d_inode = inode;		dentry->d_inode = inode;

fs/namei.c

+3 −3

Original line number	Original line	Diff line number	Diff line
	@@ -1542,7 +1542,7 @@ static inline int walk_component(struct nameidata nd, struct path path,
	inode = path->dentry->d_inode;		inode = path->dentry->d_inode;
	}		}
	err = -ENOENT;		err = -ENOENT;
	if (!inode)		if (!inode \|\| d_is_negative(path->dentry))
	goto out_path_put;		goto out_path_put;

	if (should_follow_link(path->dentry, follow)) {		if (should_follow_link(path->dentry, follow)) {
	@@ -2249,7 +2249,7 @@ mountpoint_last(struct nameidata nd, struct path path)
	mutex_unlock(&dir->d_inode->i_mutex);		mutex_unlock(&dir->d_inode->i_mutex);

	done:		done:
	if (!dentry->d_inode) {		if (!dentry->d_inode \|\| d_is_negative(dentry)) {
	error = -ENOENT;		error = -ENOENT;
	dput(dentry);		dput(dentry);
	goto out;		goto out;
	@@ -2994,7 +2994,7 @@ retry_lookup:
	finish_lookup:		finish_lookup:
	/* we _can_ be in RCU mode here */		/* we _can_ be in RCU mode here */
	error = -ENOENT;		error = -ENOENT;
	if (d_is_negative(path->dentry)) {		if (!inode \|\| d_is_negative(path->dentry)) {
	path_to_nameidata(path, nd);		path_to_nameidata(path, nd);
	goto out;		goto out;
	}		}

fs/posix_acl.c

+6 −0

Original line number	Original line	Diff line number	Diff line
	@@ -246,6 +246,12 @@ posix_acl_equiv_mode(const struct posix_acl acl, umode_t mode_p)
	umode_t mode = 0;		umode_t mode = 0;
	int not_equiv = 0;		int not_equiv = 0;

			/*
			* A null ACL can always be presented as mode bits.
			*/
			if (!acl)
			return 0;

	FOREACH_ACL_ENTRY(pa, acl, pe) {		FOREACH_ACL_ENTRY(pa, acl, pe) {
	switch (pa->e_tag) {		switch (pa->e_tag) {
	case ACL_USER_OBJ:		case ACL_USER_OBJ:

include/linux/dcache.h

+2 −0

Original line number	Original line	Diff line number	Diff line
	@@ -221,6 +221,8 @@ struct dentry_operations {
	#define DCACHE_SYMLINK_TYPE 0x00300000 /* Symlink */		#define DCACHE_SYMLINK_TYPE 0x00300000 /* Symlink */
	#define DCACHE_FILE_TYPE 0x00400000 /* Other file type */		#define DCACHE_FILE_TYPE 0x00400000 /* Other file type */

			#define DCACHE_MAY_FREE 0x00800000

	extern seqlock_t rename_lock;		extern seqlock_t rename_lock;

	static inline int dname_external(const struct dentry *dentry)		static inline int dname_external(const struct dentry *dentry)

include/linux/mm.h

+2 −0

Original line number	Original line	Diff line number	Diff line
	@@ -370,6 +370,8 @@ static inline int is_vmalloc_or_module_addr(const void *x)
	}		}
	#endif		#endif

			extern void kvfree(const void *addr);

	static inline void compound_lock(struct page *page)		static inline void compound_lock(struct page *page)
	{		{
	#ifdef CONFIG_TRANSPARENT_HUGEPAGE		#ifdef CONFIG_TRANSPARENT_HUGEPAGE

Admin message