Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs (dc0755cd) · Commits · e / devices / android_kernel_fairphone_FP4

fs/afs/dir.c

+3 −7

Original line number	Diff line number	Diff line
		@@ -685,16 +685,12 @@ static int afs_d_revalidate(struct dentry *dentry, unsigned int flags)
		spin_unlock(&dentry->d_lock);

		out_bad:
		if (dentry->d_inode) {
		/* don't unhash if we have submounts */
		if (have_submounts(dentry))
		if (check_submounts_and_drop(dentry) != 0)
		goto out_skip;
		}

		_debug("dropping dentry %s/%s",
		parent->d_name.name, dentry->d_name.name);
		shrink_dcache_parent(dentry);
		d_drop(dentry);
		dput(parent);
		key_put(key);

fs/dcache.c

+246 −165

Original line number	Diff line number	Diff line
		@@ -1031,34 +1031,56 @@ static struct dentry try_to_ascend(struct dentry old, int locked, unsigned seq
		return new;
		}


		/*
		* Search for at least 1 mount point in the dentry's subdirs.
		* We descend to the next level whenever the d_subdirs
		* list is non-empty and continue searching.
		*/
		/**
		* enum d_walk_ret - action to talke during tree walk
		* @D_WALK_CONTINUE: contrinue walk
		* @D_WALK_QUIT: quit walk
		* @D_WALK_NORETRY: quit when retry is needed
		* @D_WALK_SKIP: skip this dentry and its children
		*/
		enum d_walk_ret {
		D_WALK_CONTINUE,
		D_WALK_QUIT,
		D_WALK_NORETRY,
		D_WALK_SKIP,
		};

		/**
		* have_submounts - check for mounts over a dentry
		* @parent: dentry to check.
		* d_walk - walk the dentry tree
		* @parent: start of walk
		* @data: data passed to @enter() and @finish()
		* @enter: callback when first entering the dentry
		* @finish: callback when successfully finished the walk
		*
		* Return true if the parent or its subdirectories contain
		* a mount point
		* The @enter() and @finish() callbacks are called with d_lock held.
		*/
		int have_submounts(struct dentry *parent)
		static void d_walk(struct dentry parent, void data,
		enum d_walk_ret (enter)(void , struct dentry *),
		void (finish)(void ))
		{
		struct dentry *this_parent;
		struct list_head *next;
		unsigned seq;
		int locked = 0;
		enum d_walk_ret ret;
		bool retry = true;

		seq = read_seqbegin(&rename_lock);
		again:
		this_parent = parent;

		if (d_mountpoint(parent))
		goto positive;
		spin_lock(&this_parent->d_lock);

		ret = enter(data, this_parent);
		switch (ret) {
		case D_WALK_CONTINUE:
		break;
		case D_WALK_QUIT:
		case D_WALK_SKIP:
		goto out_unlock;
		case D_WALK_NORETRY:
		retry = false;
		break;
		}
		repeat:
		next = this_parent->d_subdirs.next;
		resume:
		@@ -1068,12 +1090,22 @@ int have_submounts(struct dentry *parent)
		next = tmp->next;

		spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
		/* Have we found a mount point ? */
		if (d_mountpoint(dentry)) {

		ret = enter(data, dentry);
		switch (ret) {
		case D_WALK_CONTINUE:
		break;
		case D_WALK_QUIT:
		spin_unlock(&dentry->d_lock);
		spin_unlock(&this_parent->d_lock);
		goto positive;
		goto out_unlock;
		case D_WALK_NORETRY:
		retry = false;
		break;
		case D_WALK_SKIP:
		spin_unlock(&dentry->d_lock);
		continue;
		}

		if (!list_empty(&dentry->d_subdirs)) {
		spin_unlock(&this_parent->d_lock);
		spin_release(&dentry->d_lock.dep_map, 1, _RET_IP_);
		@@ -1094,28 +1126,96 @@ int have_submounts(struct dentry *parent)
		next = child->d_u.d_child.next;
		goto resume;
		}
		if (!locked && read_seqretry(&rename_lock, seq)) {
		spin_unlock(&this_parent->d_lock);
		if (!locked && read_seqretry(&rename_lock, seq))
		goto rename_retry;
		if (locked)
		write_sequnlock(&rename_lock);
		return 0; /* No mount points found in tree */
		positive:
		if (!locked && read_seqretry(&rename_lock, seq))
		goto rename_retry;
		}
		if (finish)
		finish(data);

		out_unlock:
		spin_unlock(&this_parent->d_lock);
		if (locked)
		write_sequnlock(&rename_lock);
		return 1;
		return;

		rename_retry:
		if (!retry)
		return;
		if (locked)
		goto again;
		locked = 1;
		write_seqlock(&rename_lock);
		goto again;
		}

		/*
		* Search for at least 1 mount point in the dentry's subdirs.
		* We descend to the next level whenever the d_subdirs
		* list is non-empty and continue searching.
		*/

		/**
		* have_submounts - check for mounts over a dentry
		* @parent: dentry to check.
		*
		* Return true if the parent or its subdirectories contain
		* a mount point
		*/

		static enum d_walk_ret check_mount(void data, struct dentry dentry)
		{
		int *ret = data;
		if (d_mountpoint(dentry)) {
		*ret = 1;
		return D_WALK_QUIT;
		}
		return D_WALK_CONTINUE;
		}

		int have_submounts(struct dentry *parent)
		{
		int ret = 0;

		d_walk(parent, &ret, check_mount, NULL);

		return ret;
		}
		EXPORT_SYMBOL(have_submounts);

		/*
		* Called by mount code to set a mountpoint and check if the mountpoint is
		* reachable (e.g. NFS can unhash a directory dentry and then the complete
		* subtree can become unreachable).
		*
		* Only one of check_submounts_and_drop() and d_set_mounted() must succeed. For
		* this reason take rename_lock and d_lock on dentry and ancestors.
		*/
		int d_set_mounted(struct dentry *dentry)
		{
		struct dentry *p;
		int ret = -ENOENT;
		write_seqlock(&rename_lock);
		for (p = dentry->d_parent; !IS_ROOT(p); p = p->d_parent) {
		/* Need exclusion wrt. check_submounts_and_drop() */
		spin_lock(&p->d_lock);
		if (unlikely(d_unhashed(p))) {
		spin_unlock(&p->d_lock);
		goto out;
		}
		spin_unlock(&p->d_lock);
		}
		spin_lock(&dentry->d_lock);
		if (!d_unlinked(dentry)) {
		dentry->d_flags \|= DCACHE_MOUNTED;
		ret = 0;
		}
		spin_unlock(&dentry->d_lock);
		out:
		write_sequnlock(&rename_lock);
		return ret;
		}

		/*
		* Search the dentry child list of the specified parent,
		* and move any unused dentries to the end of the unused
		@@ -1130,27 +1230,20 @@ EXPORT_SYMBOL(have_submounts);
		* drop the lock and return early due to latency
		* constraints.
		*/
		static int select_parent(struct dentry parent, struct list_head dispose)
		{
		struct dentry *this_parent;
		struct list_head *next;
		unsigned seq;
		int found = 0;
		int locked = 0;

		seq = read_seqbegin(&rename_lock);
		again:
		this_parent = parent;
		spin_lock(&this_parent->d_lock);
		repeat:
		next = this_parent->d_subdirs.next;
		resume:
		while (next != &this_parent->d_subdirs) {
		struct list_head *tmp = next;
		struct dentry *dentry = list_entry(tmp, struct dentry, d_u.d_child);
		next = tmp->next;
		struct select_data {
		struct dentry *start;
		struct list_head dispose;
		int found;
		};

		spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
		static enum d_walk_ret select_collect(void _data, struct dentry dentry)
		{
		struct select_data *data = _data;
		enum d_walk_ret ret = D_WALK_CONTINUE;

		if (data->start == dentry)
		goto out;

		/*
		* move only zero ref count dentries to the dispose list.
		@@ -1163,79 +1256,111 @@ static int select_parent(struct dentry parent, struct list_head dispose)
		if (dentry->d_lockref.count) {
		dentry_lru_del(dentry);
		} else if (!(dentry->d_flags & DCACHE_SHRINK_LIST)) {
		dentry_lru_move_list(dentry, dispose);
		dentry_lru_move_list(dentry, &data->dispose);
		dentry->d_flags \|= DCACHE_SHRINK_LIST;
		found++;
		data->found++;
		ret = D_WALK_NORETRY;
		}
		/*
		* We can return to the caller if we have found some (this
		* ensures forward progress). We'll be coming back to find
		* the rest.
		*/
		if (found && need_resched()) {
		spin_unlock(&dentry->d_lock);
		goto out;
		if (data->found && need_resched())
		ret = D_WALK_QUIT;
		out:
		return ret;
		}

		/*
		* Descend a level if the d_subdirs list is non-empty.
		/**
		* shrink_dcache_parent - prune dcache
		* @parent: parent of entries to prune
		*
		* Prune the dcache to remove unused children of the parent dentry.
		*/
		if (!list_empty(&dentry->d_subdirs)) {
		spin_unlock(&this_parent->d_lock);
		spin_release(&dentry->d_lock.dep_map, 1, _RET_IP_);
		this_parent = dentry;
		spin_acquire(&this_parent->d_lock.dep_map, 0, 1, _RET_IP_);
		goto repeat;
		void shrink_dcache_parent(struct dentry *parent)
		{
		for (;;) {
		struct select_data data;

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

		d_walk(parent, &data, select_collect, NULL);
		if (!data.found)
		break;

		shrink_dentry_list(&data.dispose);
		cond_resched();
		}
		}
		EXPORT_SYMBOL(shrink_dcache_parent);

		spin_unlock(&dentry->d_lock);
		static enum d_walk_ret check_and_collect(void _data, struct dentry dentry)
		{
		struct select_data *data = _data;

		if (d_mountpoint(dentry)) {
		data->found = -EBUSY;
		return D_WALK_QUIT;
		}
		/*
		* All done at this level ... ascend and resume the search.
		*/
		if (this_parent != parent) {
		struct dentry *child = this_parent;
		this_parent = try_to_ascend(this_parent, locked, seq);
		if (!this_parent)
		goto rename_retry;
		next = child->d_u.d_child.next;
		goto resume;

		return select_collect(_data, dentry);
		}
		out:
		spin_unlock(&this_parent->d_lock);
		if (!locked && read_seqretry(&rename_lock, seq))
		goto rename_retry;
		if (locked)
		write_sequnlock(&rename_lock);
		return found;

		rename_retry:
		if (found)
		return found;
		if (locked)
		goto again;
		locked = 1;
		write_seqlock(&rename_lock);
		goto again;
		static void check_and_drop(void *_data)
		{
		struct select_data *data = _data;

		if (d_mountpoint(data->start))
		data->found = -EBUSY;
		if (!data->found)
		__d_drop(data->start);
		}

		/**
		* shrink_dcache_parent - prune dcache
		* @parent: parent of entries to prune
		* check_submounts_and_drop - prune dcache, check for submounts and drop
		*
		* Prune the dcache to remove unused children of the parent dentry.
		* All done as a single atomic operation relative to has_unlinked_ancestor().
		* Returns 0 if successfully unhashed @parent. If there were submounts then
		* return -EBUSY.
		*
		* @dentry: dentry to prune and drop
		*/
		void shrink_dcache_parent(struct dentry * parent)
		int check_submounts_and_drop(struct dentry *dentry)
		{
		LIST_HEAD(dispose);
		int found;
		int ret = 0;

		/* Negative dentries can be dropped without further checks */
		if (!dentry->d_inode) {
		d_drop(dentry);
		goto out;
		}

		for (;;) {
		struct select_data data;

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

		d_walk(dentry, &data, check_and_collect, check_and_drop);
		ret = data.found;

		if (!list_empty(&data.dispose))
		shrink_dentry_list(&data.dispose);

		if (ret <= 0)
		break;

		while ((found = select_parent(parent, &dispose)) != 0) {
		shrink_dentry_list(&dispose);
		cond_resched();
		}

		out:
		return ret;
		}
		EXPORT_SYMBOL(shrink_dcache_parent);
		EXPORT_SYMBOL(check_submounts_and_drop);

		/**
		* __d_alloc - allocate a dcache entry
		@@ -2928,68 +3053,24 @@ int is_subdir(struct dentry new_dentry, struct dentry old_dentry)
		return result;
		}

		void d_genocide(struct dentry *root)
		static enum d_walk_ret d_genocide_kill(void data, struct dentry dentry)
		{
		struct dentry *this_parent;
		struct list_head *next;
		unsigned seq;
		int locked = 0;

		seq = read_seqbegin(&rename_lock);
		again:
		this_parent = root;
		spin_lock(&this_parent->d_lock);
		repeat:
		next = this_parent->d_subdirs.next;
		resume:
		while (next != &this_parent->d_subdirs) {
		struct list_head *tmp = next;
		struct dentry *dentry = list_entry(tmp, struct dentry, d_u.d_child);
		next = tmp->next;
		struct dentry *root = data;
		if (dentry != root) {
		if (d_unhashed(dentry) \|\| !dentry->d_inode)
		return D_WALK_SKIP;

		spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
		if (d_unhashed(dentry) \|\| !dentry->d_inode) {
		spin_unlock(&dentry->d_lock);
		continue;
		}
		if (!list_empty(&dentry->d_subdirs)) {
		spin_unlock(&this_parent->d_lock);
		spin_release(&dentry->d_lock.dep_map, 1, _RET_IP_);
		this_parent = dentry;
		spin_acquire(&this_parent->d_lock.dep_map, 0, 1, _RET_IP_);
		goto repeat;
		}
		if (!(dentry->d_flags & DCACHE_GENOCIDE)) {
		dentry->d_flags \|= DCACHE_GENOCIDE;
		dentry->d_lockref.count--;
		}
		spin_unlock(&dentry->d_lock);
		}
		if (this_parent != root) {
		struct dentry *child = this_parent;
		if (!(this_parent->d_flags & DCACHE_GENOCIDE)) {
		this_parent->d_flags \|= DCACHE_GENOCIDE;
		this_parent->d_lockref.count--;
		return D_WALK_CONTINUE;
		}
		this_parent = try_to_ascend(this_parent, locked, seq);
		if (!this_parent)
		goto rename_retry;
		next = child->d_u.d_child.next;
		goto resume;
		}
		spin_unlock(&this_parent->d_lock);
		if (!locked && read_seqretry(&rename_lock, seq))
		goto rename_retry;
		if (locked)
		write_sequnlock(&rename_lock);
		return;

		rename_retry:
		if (locked)
		goto again;
		locked = 1;
		write_seqlock(&rename_lock);
		goto again;
		void d_genocide(struct dentry *parent)
		{
		d_walk(parent, parent, d_genocide_kill, NULL);
		}

		void d_tmpfile(struct dentry dentry, struct inode inode)

fs/fuse/dir.c

+46 −51

Original line number	Diff line number	Diff line
		@@ -182,10 +182,11 @@ static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags)
		struct inode *inode;
		struct dentry *parent;
		struct fuse_conn *fc;
		int ret;

		inode = ACCESS_ONCE(entry->d_inode);
		if (inode && is_bad_inode(inode))
		return 0;
		goto invalid;
		else if (fuse_dentry_time(entry) < get_jiffies_64()) {
		int err;
		struct fuse_entry_out outarg;
		@@ -195,20 +196,23 @@ static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags)

		/* For negative dentries, always do a fresh lookup */
		if (!inode)
		return 0;
		goto invalid;

		ret = -ECHILD;
		if (flags & LOOKUP_RCU)
		return -ECHILD;
		goto out;

		fc = get_fuse_conn(inode);
		req = fuse_get_req_nopages(fc);
		ret = PTR_ERR(req);
		if (IS_ERR(req))
		return 0;
		goto out;

		forget = fuse_alloc_forget();
		if (!forget) {
		fuse_put_request(fc, req);
		return 0;
		ret = -ENOMEM;
		goto out;
		}

		attr_version = fuse_get_attr_version(fc);
		@@ -227,7 +231,7 @@ static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags)
		struct fuse_inode *fi = get_fuse_inode(inode);
		if (outarg.nodeid != get_node_id(inode)) {
		fuse_queue_forget(fc, forget, outarg.nodeid, 1);
		return 0;
		goto invalid;
		}
		spin_lock(&fc->lock);
		fi->nlookup++;
		@@ -235,7 +239,7 @@ static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags)
		}
		kfree(forget);
		if (err \|\| (outarg.attr.mode ^ inode->i_mode) & S_IFMT)
		return 0;
		goto invalid;

		fuse_change_attributes(inode, &outarg.attr,
		entry_attr_timeout(&outarg),
		@@ -249,7 +253,15 @@ static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags)
		dput(parent);
		}
		}
		return 1;
		ret = 1;
		out:
		return ret;

		invalid:
		ret = 0;
		if (check_submounts_and_drop(entry) != 0)
		ret = 1;
		goto out;
		}

		static int invalid_nodeid(u64 nodeid)
		@@ -267,26 +279,6 @@ int fuse_valid_type(int m)
		S_ISBLK(m) \|\| S_ISFIFO(m) \|\| S_ISSOCK(m);
		}

		/*
		* Add a directory inode to a dentry, ensuring that no other dentry
		* refers to this inode. Called with fc->inst_mutex.
		*/
		static struct dentry fuse_d_add_directory(struct dentry entry,
		struct inode *inode)
		{
		struct dentry *alias = d_find_alias(inode);
		if (alias && !(alias->d_flags & DCACHE_DISCONNECTED)) {
		/* This tries to shrink the subtree below alias */
		fuse_invalidate_entry(alias);
		dput(alias);
		if (!hlist_empty(&inode->i_dentry))
		return ERR_PTR(-EBUSY);
		} else {
		dput(alias);
		}
		return d_splice_alias(inode, entry);
		}

		int fuse_lookup_name(struct super_block sb, u64 nodeid, struct qstr name,
		struct fuse_entry_out outarg, struct inode *inode)
		{
		@@ -345,6 +337,24 @@ int fuse_lookup_name(struct super_block sb, u64 nodeid, struct qstr name,
		return err;
		}

		static struct dentry fuse_materialise_dentry(struct dentry dentry,
		struct inode *inode)
		{
		struct dentry *newent;

		if (inode && S_ISDIR(inode->i_mode)) {
		struct fuse_conn *fc = get_fuse_conn(inode);

		mutex_lock(&fc->inst_mutex);
		newent = d_materialise_unique(dentry, inode);
		mutex_unlock(&fc->inst_mutex);
		} else {
		newent = d_materialise_unique(dentry, inode);
		}

		return newent;
		}

		static struct dentry fuse_lookup(struct inode dir, struct dentry *entry,
		unsigned int flags)
		{
		@@ -352,7 +362,6 @@ static struct dentry fuse_lookup(struct inode dir, struct dentry *entry,
		struct fuse_entry_out outarg;
		struct inode *inode;
		struct dentry *newent;
		struct fuse_conn *fc = get_fuse_conn(dir);
		bool outarg_valid = true;

		err = fuse_lookup_name(dir->i_sb, get_node_id(dir), &entry->d_name,
		@@ -368,16 +377,10 @@ static struct dentry fuse_lookup(struct inode dir, struct dentry *entry,
		if (inode && get_node_id(inode) == FUSE_ROOT_ID)
		goto out_iput;

		if (inode && S_ISDIR(inode->i_mode)) {
		mutex_lock(&fc->inst_mutex);
		newent = fuse_d_add_directory(entry, inode);
		mutex_unlock(&fc->inst_mutex);
		newent = fuse_materialise_dentry(entry, inode);
		err = PTR_ERR(newent);
		if (IS_ERR(newent))
		goto out_iput;
		} else {
		newent = d_splice_alias(inode, entry);
		}
		goto out_err;

		entry = newent ? newent : entry;
		if (outarg_valid)
		@@ -1275,18 +1278,10 @@ static int fuse_direntplus_link(struct file *file,
		if (!inode)
		goto out;

		if (S_ISDIR(inode->i_mode)) {
		mutex_lock(&fc->inst_mutex);
		alias = fuse_d_add_directory(dentry, inode);
		mutex_unlock(&fc->inst_mutex);
		alias = fuse_materialise_dentry(dentry, inode);
		err = PTR_ERR(alias);
		if (IS_ERR(alias)) {
		iput(inode);
		if (IS_ERR(alias))
		goto out;
		}
		} else {
		alias = d_splice_alias(inode, dentry);
		}

		if (alias) {
		dput(dentry);

fs/gfs2/dentry.c

+3 −6

Original line number	Diff line number	Diff line
		@@ -93,12 +93,9 @@ static int gfs2_drevalidate(struct dentry *dentry, unsigned int flags)
		if (!had_lock)
		gfs2_glock_dq_uninit(&d_gh);
		invalid:
		if (inode && S_ISDIR(inode->i_mode)) {
		if (have_submounts(dentry))
		if (check_submounts_and_drop(dentry) != 0)
		goto valid;
		shrink_dcache_parent(dentry);
		}
		d_drop(dentry);

		dput(parent);
		return 0;

fs/internal.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -126,6 +126,7 @@ extern int invalidate_inodes(struct super_block *, bool);
		* dcache.c
		*/
		extern struct dentry __d_alloc(struct super_block , const struct qstr *);
		extern int d_set_mounted(struct dentry *dentry);

		/*
		* read_write.c