Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 48c4565e authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs 

Pull vfs fixes from Al Viro:
 "Tmpfs readdir throughput regression fix (this cycle) + some -stable
  fodder all over the place.

  One missing bit is Miklos' tonight locks.c fix - NFS folks had already
  grabbed that one by the time I woke up ;-)"

[ The locks.c fix came through the nfsd tree just moments ago ]

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs:
  namespace: update event counter when umounting a deleted dentry
  9p: use file_dentry()
  ceph: fix d_obtain_alias() misuses
  lockless next_positive()
  libfs.c: new helper - next_positive()
  dcache_{readdir,dir_lseek}(): don't bother with nested ->d_lock
parents 2728c57f e06b933e

fs/9p/vfs_file.c

+3 −3
Original line number Diff line number Diff line
@@ -74,7 +74,7 @@ int v9fs_file_open(struct inode *inode, struct file *file) 
					v9fs_proto_dotu(v9ses));

	fid = file->private_data;

	if (!fid) {

		fid = v9fs_fid_clone(file->f_path.dentry);

		fid = v9fs_fid_clone(file_dentry(file));

		if (IS_ERR(fid))

			return PTR_ERR(fid);
@@ -100,7 +100,7 @@ int v9fs_file_open(struct inode *inode, struct file *file) 
		 * because we want write after unlink usecase

		 * to work.

		 */

		fid = v9fs_writeback_fid(file->f_path.dentry);

		fid = v9fs_writeback_fid(file_dentry(file));

		if (IS_ERR(fid)) {

			err = PTR_ERR(fid);

			mutex_unlock(&v9inode->v_mutex);
@@ -516,7 +516,7 @@ v9fs_mmap_file_mmap(struct file *filp, struct vm_area_struct *vma) 
		 * because we want write after unlink usecase

		 * to work.

		 */

		fid = v9fs_writeback_fid(filp->f_path.dentry);

		fid = v9fs_writeback_fid(file_dentry(filp));

		if (IS_ERR(fid)) {

			retval = PTR_ERR(fid);

			mutex_unlock(&v9inode->v_mutex);

fs/ceph/export.c

+3 −7
Original line number Diff line number Diff line
@@ -95,10 +95,8 @@ static struct dentry *__fh_to_dentry(struct super_block *sb, u64 ino) 
	}



	dentry = d_obtain_alias(inode);

	if (IS_ERR(dentry)) {

		iput(inode);

	if (IS_ERR(dentry))

		return dentry;

	}

	err = ceph_init_dentry(dentry);

	if (err < 0) {

		dput(dentry);
@@ -167,10 +165,8 @@ static struct dentry *__get_parent(struct super_block *sb, 
		return ERR_PTR(-ENOENT);



	dentry = d_obtain_alias(inode);

	if (IS_ERR(dentry)) {

		iput(inode);

	if (IS_ERR(dentry))

		return dentry;

	}

	err = ceph_init_dentry(dentry);

	if (err < 0) {

		dput(dentry);
@@ -210,7 +206,7 @@ static struct dentry *ceph_fh_to_parent(struct super_block *sb, 


	dout("fh_to_parent %llx\n", cfh->parent_ino);

	dentry = __get_parent(sb, NULL, cfh->ino);

	if (IS_ERR(dentry) && PTR_ERR(dentry) == -ENOENT)

	if (unlikely(dentry == ERR_PTR(-ENOENT)))

		dentry = __fh_to_dentry(sb, cfh->parent_ino);

	return dentry;

}

fs/libfs.c

+71 −38
Original line number Diff line number Diff line
@@ -84,6 +84,61 @@ int dcache_dir_close(struct inode *inode, struct file *file) 
}

EXPORT_SYMBOL(dcache_dir_close);



/* parent is locked at least shared */

static struct dentry *next_positive(struct dentry *parent,

				    struct list_head *from,

				    int count)

{

	unsigned *seq = &parent->d_inode->i_dir_seq, n;

	struct dentry *res;

	struct list_head *p;

	bool skipped;

	int i;



retry:

	i = count;

	skipped = false;

	n = smp_load_acquire(seq) & ~1;

	res = NULL;

	rcu_read_lock();

	for (p = from->next; p != &parent->d_subdirs; p = p->next) {

		struct dentry *d = list_entry(p, struct dentry, d_child);

		if (!simple_positive(d)) {

			skipped = true;

		} else if (!--i) {

			res = d;

			break;

		}

	}

	rcu_read_unlock();

	if (skipped) {

		smp_rmb();

		if (unlikely(*seq != n))

			goto retry;

	}

	return res;

}



static void move_cursor(struct dentry *cursor, struct list_head *after)

{

	struct dentry *parent = cursor->d_parent;

	unsigned n, *seq = &parent->d_inode->i_dir_seq;

	spin_lock(&parent->d_lock);

	for (;;) {

		n = *seq;

		if (!(n & 1) && cmpxchg(seq, n, n + 1) == n)

			break;

		cpu_relax();

	}

	__list_del(cursor->d_child.prev, cursor->d_child.next);

	if (after)

		list_add(&cursor->d_child, after);

	else

		list_add_tail(&cursor->d_child, &parent->d_subdirs);

	smp_store_release(seq, n + 2);

	spin_unlock(&parent->d_lock);

}



loff_t dcache_dir_lseek(struct file *file, loff_t offset, int whence)

{

	struct dentry *dentry = file->f_path.dentry;
@@ -99,25 +154,14 @@ loff_t dcache_dir_lseek(struct file *file, loff_t offset, int whence) 
	if (offset != file->f_pos) {

		file->f_pos = offset;

		if (file->f_pos >= 2) {

			struct list_head *p;

			struct dentry *cursor = file->private_data;

			struct dentry *to;

			loff_t n = file->f_pos - 2;



			spin_lock(&dentry->d_lock);

			/* d_lock not required for cursor */

			list_del(&cursor->d_child);

			p = dentry->d_subdirs.next;

			while (n && p != &dentry->d_subdirs) {

				struct dentry *next;

				next = list_entry(p, struct dentry, d_child);

				spin_lock_nested(&next->d_lock, DENTRY_D_LOCK_NESTED);

				if (simple_positive(next))

					n--;

				spin_unlock(&next->d_lock);

				p = p->next;

			}

			list_add_tail(&cursor->d_child, p);

			spin_unlock(&dentry->d_lock);

			inode_lock_shared(dentry->d_inode);

			to = next_positive(dentry, &dentry->d_subdirs, n);

			move_cursor(cursor, to ? &to->d_child : NULL);

			inode_unlock_shared(dentry->d_inode);

		}

	}

	return offset;
@@ -140,36 +184,25 @@ int dcache_readdir(struct file *file, struct dir_context *ctx) 
{

	struct dentry *dentry = file->f_path.dentry;

	struct dentry *cursor = file->private_data;

	struct list_head *p, *q = &cursor->d_child;

	struct list_head *p = &cursor->d_child;

	struct dentry *next;

	bool moved = false;



	if (!dir_emit_dots(file, ctx))

		return 0;

	spin_lock(&dentry->d_lock);

	if (ctx->pos == 2)

		list_move(q, &dentry->d_subdirs);



	for (p = q->next; p != &dentry->d_subdirs; p = p->next) {

		struct dentry *next = list_entry(p, struct dentry, d_child);

		spin_lock_nested(&next->d_lock, DENTRY_D_LOCK_NESTED);

		if (!simple_positive(next)) {

			spin_unlock(&next->d_lock);

			continue;

		}



		spin_unlock(&next->d_lock);

		spin_unlock(&dentry->d_lock);

	if (ctx->pos == 2)

		p = &dentry->d_subdirs;

	while ((next = next_positive(dentry, p, 1)) != NULL) {

		if (!dir_emit(ctx, next->d_name.name, next->d_name.len,

			      d_inode(next)->i_ino, dt_type(d_inode(next))))

			return 0;

		spin_lock(&dentry->d_lock);

		spin_lock_nested(&next->d_lock, DENTRY_D_LOCK_NESTED);

		/* next is still alive */

		list_move(q, p);

		spin_unlock(&next->d_lock);

		p = q;

			break;

		moved = true;

		p = &next->d_child;

		ctx->pos++;

	}

	spin_unlock(&dentry->d_lock);

	if (moved)

		move_cursor(cursor, p);

	return 0;

}

EXPORT_SYMBOL(dcache_readdir);

fs/namespace.c

+1 −0
Original line number Diff line number Diff line
@@ -1562,6 +1562,7 @@ void __detach_mounts(struct dentry *dentry) 
		goto out_unlock;



	lock_mount_hash();

	event++;

	while (!hlist_empty(&mp->m_list)) {

		mnt = hlist_entry(mp->m_list.first, struct mount, mnt_mp_list);

		if (mnt->mnt.mnt_flags & MNT_UMOUNT) {