Commit 5f6f4f28 authored by Ian Kent's avatar Ian Kent Committed by Linus Torvalds
Browse files

autofs4: don't make expiring dentry negative 



Correct the error of making a positive dentry negative after it has been
instantiated.

The code that makes this error attempts to re-use the dentry from a
concurrent expire and mount to resolve a race and the dentry used for the
lookup must be negative for mounts to trigger in the required cases.  The
fact is that the dentry doesn't need to be re-used because all that is
needed is to preserve the flag that indicates an expire is still
incomplete at the time of the mount request.

This change uses the the dentry to check the flag and wait for the expire
to complete then discards it instead of attempting to re-use it.

Signed-off-by: default avatarIan Kent <raven@themaw.net>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent 391b52f9

fs/autofs4/autofs_i.h

+3 −3
Original line number Diff line number Diff line
@@ -52,7 +52,7 @@ struct autofs_info { 


	int		flags;



	struct list_head rehash;

	struct list_head expiring;



	struct autofs_sb_info *sbi;

	unsigned long last_used;
@@ -112,8 +112,8 @@ struct autofs_sb_info { 
	struct mutex wq_mutex;

	spinlock_t fs_lock;

	struct autofs_wait_queue *queues; /* Wait queue pointer */

	spinlock_t rehash_lock;

	struct list_head rehash_list;

	spinlock_t lookup_lock;

	struct list_head expiring_list;

};



static inline struct autofs_sb_info *autofs4_sbi(struct super_block *sb)

fs/autofs4/inode.c

+3 −3
Original line number Diff line number Diff line
@@ -47,7 +47,7 @@ struct autofs_info *autofs4_init_ino(struct autofs_info *ino, 
	ino->dentry = NULL;

	ino->size = 0;



	INIT_LIST_HEAD(&ino->rehash);

	INIT_LIST_HEAD(&ino->expiring);



	ino->last_used = jiffies;

	atomic_set(&ino->count, 0);
@@ -338,8 +338,8 @@ int autofs4_fill_super(struct super_block *s, void *data, int silent) 
	mutex_init(&sbi->wq_mutex);

	spin_lock_init(&sbi->fs_lock);

	sbi->queues = NULL;

	spin_lock_init(&sbi->rehash_lock);

	INIT_LIST_HEAD(&sbi->rehash_list);

	spin_lock_init(&sbi->lookup_lock);

	INIT_LIST_HEAD(&sbi->expiring_list);

	s->s_blocksize = 1024;

	s->s_blocksize_bits = 10;

	s->s_magic = AUTOFS_SUPER_MAGIC;

fs/autofs4/root.c

+46 −72
Original line number Diff line number Diff line
@@ -493,10 +493,10 @@ void autofs4_dentry_release(struct dentry *de) 
		struct autofs_sb_info *sbi = autofs4_sbi(de->d_sb);



		if (sbi) {

			spin_lock(&sbi->rehash_lock);

			if (!list_empty(&inf->rehash))

				list_del(&inf->rehash);

			spin_unlock(&sbi->rehash_lock);

			spin_lock(&sbi->lookup_lock);

			if (!list_empty(&inf->expiring))

				list_del(&inf->expiring);

			spin_unlock(&sbi->lookup_lock);

		}



		inf->dentry = NULL;
@@ -518,7 +518,7 @@ static struct dentry_operations autofs4_dentry_operations = { 
	.d_release	= autofs4_dentry_release,

};



static struct dentry *autofs4_lookup_unhashed(struct autofs_sb_info *sbi, struct dentry *parent, struct qstr *name)

static struct dentry *autofs4_lookup_expiring(struct autofs_sb_info *sbi, struct dentry *parent, struct qstr *name)

{

	unsigned int len = name->len;

	unsigned int hash = name->hash;
@@ -526,14 +526,14 @@ static struct dentry *autofs4_lookup_unhashed(struct autofs_sb_info *sbi, struct 
	struct list_head *p, *head;



	spin_lock(&dcache_lock);

	spin_lock(&sbi->rehash_lock);

	head = &sbi->rehash_list;

	spin_lock(&sbi->lookup_lock);

	head = &sbi->expiring_list;

	list_for_each(p, head) {

		struct autofs_info *ino;

		struct dentry *dentry;

		struct qstr *qstr;



		ino = list_entry(p, struct autofs_info, rehash);

		ino = list_entry(p, struct autofs_info, expiring);

		dentry = ino->dentry;



		spin_lock(&dentry->d_lock);
@@ -555,33 +555,16 @@ static struct dentry *autofs4_lookup_unhashed(struct autofs_sb_info *sbi, struct 
			goto next;



		if (d_unhashed(dentry)) {

			struct inode *inode = dentry->d_inode;



			ino = autofs4_dentry_ino(dentry);

			list_del_init(&ino->rehash);

			dget(dentry);

			/*

			 * Make the rehashed dentry negative so the VFS

			 * behaves as it should.

			 */

			if (inode) {

				dentry->d_inode = NULL;

				list_del_init(&dentry->d_alias);

				spin_unlock(&dentry->d_lock);

				spin_unlock(&sbi->rehash_lock);

				spin_unlock(&dcache_lock);

				iput(inode);

				return dentry;

			}

			spin_unlock(&dentry->d_lock);

			spin_unlock(&sbi->rehash_lock);

			spin_unlock(&sbi->lookup_lock);

			spin_unlock(&dcache_lock);

			return dentry;

		}

next:

		spin_unlock(&dentry->d_lock);

	}

	spin_unlock(&sbi->rehash_lock);

	spin_unlock(&sbi->lookup_lock);

	spin_unlock(&dcache_lock);



	return NULL;
@@ -591,7 +574,7 @@ next: 
static struct dentry *autofs4_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)

{

	struct autofs_sb_info *sbi;

	struct dentry *unhashed;

	struct dentry *expiring;

	int oz_mode;



	DPRINTK("name = %.*s",
@@ -607,8 +590,28 @@ static struct dentry *autofs4_lookup(struct inode *dir, struct dentry *dentry, s 
	DPRINTK("pid = %u, pgrp = %u, catatonic = %d, oz_mode = %d",

		 current->pid, task_pgrp_nr(current), sbi->catatonic, oz_mode);



	unhashed = autofs4_lookup_unhashed(sbi, dentry->d_parent, &dentry->d_name);

	if (!unhashed) {

	expiring = autofs4_lookup_expiring(sbi, dentry->d_parent, &dentry->d_name);

	if (expiring) {

		struct autofs_info *ino = autofs4_dentry_ino(expiring);

		/*

		 * If we are racing with expire the request might not

		 * be quite complete but the directory has been removed

		 * so it must have been successful, so just wait for it.

		 */

		while (ino && (ino->flags & AUTOFS_INF_EXPIRING)) {

			DPRINTK("wait for incomplete expire %p name=%.*s",

				expiring, expiring->d_name.len,

				expiring->d_name.name);

			autofs4_wait(sbi, expiring, NFY_NONE);

			DPRINTK("request completed");

		}

		spin_lock(&sbi->lookup_lock);

		if (!list_empty(&ino->expiring))

			list_del_init(&ino->expiring);

		spin_unlock(&sbi->lookup_lock);

		dput(expiring);

	}



	/*

	 * Mark the dentry incomplete but don't hash it. We do this

	 * to serialize our inode creation operations (symlink and
@@ -624,26 +627,6 @@ static struct dentry *autofs4_lookup(struct inode *dir, struct dentry *dentry, s 


	dentry->d_fsdata = NULL;

	d_instantiate(dentry, NULL);

	} else {

		struct autofs_info *ino = autofs4_dentry_ino(unhashed);

		DPRINTK("rehash %p with %p", dentry, unhashed);

		/*

		 * If we are racing with expire the request might not

		 * be quite complete but the directory has been removed

		 * so it must have been successful, so just wait for it.

		 * We need to ensure the AUTOFS_INF_EXPIRING flag is clear

		 * before continuing as revalidate may fail when calling

		 * try_to_fill_dentry (returning EAGAIN) if we don't.

		 */

		while (ino && (ino->flags & AUTOFS_INF_EXPIRING)) {

			DPRINTK("wait for incomplete expire %p name=%.*s",

				unhashed, unhashed->d_name.len,

				unhashed->d_name.name);

			autofs4_wait(sbi, unhashed, NFY_NONE);

			DPRINTK("request completed");

		}

		dentry = unhashed;

	}



	if (!oz_mode) {

		spin_lock(&dentry->d_lock);
@@ -668,8 +651,6 @@ static struct dentry *autofs4_lookup(struct inode *dir, struct dentry *dentry, s 
			if (sigismember (sigset, SIGKILL) ||

			    sigismember (sigset, SIGQUIT) ||

			    sigismember (sigset, SIGINT)) {

			    if (unhashed)

				dput(unhashed);

			    return ERR_PTR(-ERESTARTNOINTR);

			}

		}
@@ -699,15 +680,9 @@ static struct dentry *autofs4_lookup(struct inode *dir, struct dentry *dentry, s 
		else

			dentry = ERR_PTR(-ENOENT);



		if (unhashed)

			dput(unhashed);



		return dentry;

	}



	if (unhashed)

		return dentry;



	return NULL;

}
@@ -769,9 +744,8 @@ static int autofs4_dir_symlink(struct inode *dir, 
 * that the file no longer exists. However, doing that means that the

 * VFS layer can turn the dentry into a negative dentry.  We don't want

 * this, because the unlink is probably the result of an expire.

 * We simply d_drop it and add it to a rehash candidates list in the

 * super block, which allows the dentry lookup to reuse it retaining

 * the flags, such as expire in progress, in case we're racing with expire.

 * We simply d_drop it and add it to a expiring list in the super block,

 * which allows the dentry lookup to check for an incomplete expire.

 *

 * If a process is blocked on the dentry waiting for the expire to finish,

 * it will invalidate the dentry and try to mount with a new one.
@@ -801,9 +775,9 @@ static int autofs4_dir_unlink(struct inode *dir, struct dentry *dentry) 
	dir->i_mtime = CURRENT_TIME;



	spin_lock(&dcache_lock);

	spin_lock(&sbi->rehash_lock);

	list_add(&ino->rehash, &sbi->rehash_list);

	spin_unlock(&sbi->rehash_lock);

	spin_lock(&sbi->lookup_lock);

	list_add(&ino->expiring, &sbi->expiring_list);

	spin_unlock(&sbi->lookup_lock);

	spin_lock(&dentry->d_lock);

	__d_drop(dentry);

	spin_unlock(&dentry->d_lock);
@@ -829,9 +803,9 @@ static int autofs4_dir_rmdir(struct inode *dir, struct dentry *dentry) 
		spin_unlock(&dcache_lock);

		return -ENOTEMPTY;

	}

	spin_lock(&sbi->rehash_lock);

	list_add(&ino->rehash, &sbi->rehash_list);

	spin_unlock(&sbi->rehash_lock);

	spin_lock(&sbi->lookup_lock);

	list_add(&ino->expiring, &sbi->expiring_list);

	spin_unlock(&sbi->lookup_lock);

	spin_lock(&dentry->d_lock);

	__d_drop(dentry);

	spin_unlock(&dentry->d_lock);

CRA Git | Maintained and supported by SUSTech CRA and CCSE