autofs-5.1.6 - use mnt_list for submounts

From: Ian Kent <raven@themaw.net>

Use struct mnt_list objects for submount list entries instead of

struct autofs_point itself.

Signed-off-by: Ian Kent <raven@themaw.net>

---

 CHANGELOG              |    1 

 daemon/automount.c     |   11 ++++-

 daemon/direct.c        |    7 ++-

 daemon/indirect.c      |    5 ++

 include/automount.h    |    2 -

 include/master.h       |    2 -

 include/mounts.h       |   10 +++++

 lib/master.c           |   93 +++++++++++++++----------------------------------

 lib/mounts.c           |   81 ++++++++++++++++++++++++++++++++++++++++++

 modules/mount_autofs.c |   17 ++++++++

 10 files changed, 157 insertions(+), 72 deletions(-)

--- autofs-5.1.4.orig/CHANGELOG

+++ autofs-5.1.4/CHANGELOG

@@ -122,6 +122,7 @@ xx/xx/2018 autofs-5.1.5

 - make external mounts independent of amd_entry.

 - make external mounts use simpler hashtable.

 - add a hash index to mnt_list.

+- use mnt_list for submounts.

 19/12/2017 autofs-5.1.4

 - fix spec file url.

--- autofs-5.1.4.orig/daemon/automount.c

+++ autofs-5.1.4/daemon/automount.c

@@ -624,6 +624,7 @@ done:

    it also tries to umount path itself */

 int umount_multi(struct autofs_point *ap, const char *path, int incl)

 {

+	struct mnt_list *sbmnt;

 	int is_autofs_fs;

 	struct stat st;

 	int left;

@@ -685,8 +686,11 @@ int umount_multi(struct autofs_point *ap

 	}

 	is_autofs_fs = 0;

-	if (master_find_submount(ap, path))

+	sbmnt = mnts_find_submount(path);

+	if (sbmnt) {

 		is_autofs_fs = 1;

+		mnts_put_mount(sbmnt);

+	}

 	left = 0;

@@ -1717,9 +1721,12 @@ static void handle_mounts_cleanup(void *

 	if (submount) {

 		struct amd_entry *am;

+

 		/* We are finishing up */

 		ap->parent->submnt_count--;

-		list_del_init(&ap->mounts);

+

+		/* Submount at ap->path belongs to parent submount list. */

+		mnts_remove_submount(ap->path);

 		am = __master_find_amdmount(ap->parent, ap->path);

 		if (am) {

 			list_del_init(&am->entries);

--- autofs-5.1.4.orig/daemon/direct.c

+++ autofs-5.1.4/daemon/direct.c

@@ -1211,14 +1211,17 @@ static void *do_mount_direct(void *arg)

 	 */

 	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &state);

 	if (status) {

+		struct mnt_list *sbmnt;

 		struct mapent *me;

 		struct statfs fs;

 		unsigned int close_fd = 0;

+		sbmnt = mnts_find_submount(mt.name);

 		if (statfs(mt.name, &fs) == -1 ||

-		   (fs.f_type == AUTOFS_SUPER_MAGIC &&

-		    !master_find_submount(ap, mt.name)))

+		   (fs.f_type == AUTOFS_SUPER_MAGIC && !sbmnt))

 			close_fd = 1;

+		if (sbmnt)

+			mnts_put_mount(sbmnt);

 		cache_writelock(mt.mc);

 		if ((me = cache_lookup_distinct(mt.mc, mt.name))) {

 			/*

--- autofs-5.1.4.orig/daemon/indirect.c

+++ autofs-5.1.4/daemon/indirect.c

@@ -401,6 +401,7 @@ void *expire_proc_indirect(void *arg)

 			if (next->flags & MNTS_INDIRECT)

 				master_notify_submount(ap, next->mp, ap->state);

 			else if (next->flags & MNTS_OFFSET) {

+				struct mnt_list *sbmnt;

 				struct map_source *map;

 				struct mapent_cache *mc = NULL;

 				struct mapent *me = NULL;

@@ -413,7 +414,9 @@ void *expire_proc_indirect(void *arg)

 				}

 				/* Don't touch submounts */

-				if (master_find_submount(ap, next->mp)) {

+				sbmnt = mnts_find_submount(next->mp);

+				if (sbmnt) {

+					mnts_put_mount(sbmnt);

 					pthread_setcancelstate(cur_state, NULL);

 					continue;

 				}

--- autofs-5.1.4.orig/include/automount.h

+++ autofs-5.1.4/include/automount.h

@@ -570,9 +570,9 @@ struct autofs_point {

 	struct list_head mounts;	/* List of autofs mounts at current level */

 	struct list_head amdmounts;	/* List of non submount amd mounts */

 	unsigned int submount;		/* Is this a submount */

-	unsigned int shutdown;		/* Shutdown notification */

 	unsigned int submnt_count;	/* Number of submounts */

 	struct list_head submounts;	/* List of child submounts */

+	unsigned int shutdown;		/* Shutdown notification */

 };

 #define UNLINK_AND_CONT		0x01

--- autofs-5.1.4.orig/include/master.h

+++ autofs-5.1.4/include/master.h

@@ -109,8 +109,6 @@ void master_source_current_wait(struct m

 void master_source_current_signal(struct master_mapent *);

 struct master_mapent *master_find_mapent(struct master *, const char *);

 unsigned int master_partial_match_mapent(struct master *, const char *);

-struct autofs_point *__master_find_submount(struct autofs_point *, const char *);

-struct autofs_point *master_find_submount(struct autofs_point *, const char *);

 struct amd_entry *__master_find_amdmount(struct autofs_point *, const char *);

 struct amd_entry *master_find_amdmount(struct autofs_point *, const char *);

 struct master_mapent *master_new_mapent(struct master *, const char *, time_t);

--- autofs-5.1.4.orig/include/mounts.h

+++ autofs-5.1.4/include/mounts.h

@@ -59,6 +59,11 @@ struct mnt_list {

 	struct hlist_node hash;

 	unsigned int ref;

+	/* List of sub-mounts of an autofs_point */

+	struct autofs_point *ap;

+	struct list_head submount;

+	struct list_head submount_work;

+

 	/*

 	 * List operations ie. get_mnt_list.

 	 */

@@ -108,6 +113,11 @@ int ext_mount_remove(const char *);

 int ext_mount_inuse(const char *);

 struct mnt_list *mnts_lookup_mount(const char *mp);

 void mnts_put_mount(struct mnt_list *mnt);

+struct mnt_list *mnts_find_submount(const char *path);

+struct mnt_list *mnts_add_submount(struct autofs_point *ap);

+void mnts_remove_submount(const char *mp);

+void mnts_get_submount_list(struct list_head *mnts, struct autofs_point *ap);

+void mnts_put_submount_list(struct list_head *mnts);

 struct mnt_list *get_mnt_list(const char *path, int include);

 int unlink_mount_tree(struct autofs_point *ap, const char *mp);

 void free_mnt_list(struct mnt_list *list);

--- autofs-5.1.4.orig/lib/master.c

+++ autofs-5.1.4/lib/master.c

@@ -761,34 +761,6 @@ unsigned int master_partial_match_mapent

 	return ret;

 }

-struct autofs_point *__master_find_submount(struct autofs_point *ap, const char *path)

-{

-	struct list_head *head, *p;

-

-	head = &ap->submounts;

-	list_for_each(p, head) {

-		struct autofs_point *submount;

-

-		submount = list_entry(p, struct autofs_point, mounts);

-

-		if (!strcmp(submount->path, path))

-			return submount;

-	}

-

-	return NULL;

-}

-

-struct autofs_point *master_find_submount(struct autofs_point *ap, const char *path)

-{

-	struct autofs_point *submount;

-

-	mounts_mutex_lock(ap);

-	submount = __master_find_submount(ap, path);

-	mounts_mutex_unlock(ap);

-

-	return submount;

-}

-

 struct amd_entry *__master_find_amdmount(struct autofs_point *ap, const char *path)

 {

 	struct list_head *head, *p;

@@ -1190,85 +1162,80 @@ int master_submount_list_empty(struct au

 int master_notify_submount(struct autofs_point *ap, const char *path, enum states state)

 {

-	struct list_head *head, *p;

-	struct autofs_point *this = NULL;

+	struct mnt_list *this, *sbmnt;

+	LIST_HEAD(sbmnts);

 	int ret = 1;

-	mounts_mutex_lock(ap);

-

-	head = &ap->submounts;

-	p = head->prev;

-	while (p != head) {

-		this = list_entry(p, struct autofs_point, mounts);

-		p = p->prev;

+	mnts_get_submount_list(&sbmnts, ap);

+	if (list_empty(&sbmnts))

+		return 1;

+

+	list_for_each_entry(this, &sbmnts, submount_work) {

+		/* Not a submount */

+		if (!(this->flags & MNTS_AUTOFS))

+			continue;

 		/* path not the same */

-		if (strcmp(this->path, path))

+		if (strcmp(this->mp, path))

 			continue;

-		if (!master_submount_list_empty(this)) {

-			char *this_path = strdup(this->path);

-			if (this_path) {

-				mounts_mutex_unlock(ap);

-				master_notify_submount(this, path, state);

-				mounts_mutex_lock(ap);

-				if (!__master_find_submount(ap, this_path)) {

-					free(this_path);

-					continue;

-				}

-				free(this_path);

-			}

+		if (!master_submount_list_empty(this->ap)) {

+			struct mnt_list *sm;

+

+			master_notify_submount(this->ap, path, state);

+			sm = mnts_find_submount(path);

+			if (!sm)

+				continue;

+			mnts_put_mount(sm);

 		}

 		/* Now we have found the submount we want to expire */

 		st_mutex_lock();

-		if (this->state == ST_SHUTDOWN) {

+		if (this->ap->state == ST_SHUTDOWN) {

 			this = NULL;

 			st_mutex_unlock();

 			break;

 		}

-		this->shutdown = ap->shutdown;

+		this->ap->shutdown = ap->shutdown;

-		__st_add_task(this, state);

+		__st_add_task(this->ap, state);

 		st_mutex_unlock();

-		mounts_mutex_unlock(ap);

-		st_wait_task(this, state, 0);

+		st_wait_task(this->ap, state, 0);

 		/*

 		 * If our submount gets to state ST_SHUTDOWN, ST_SHUTDOWN_PENDING or

 		 * ST_SHUTDOWN_FORCE we need to wait until it goes away or changes

 		 * to ST_READY.

 		 */

-		mounts_mutex_lock(ap);

 		st_mutex_lock();

-		while ((this = __master_find_submount(ap, path))) {

+		while ((sbmnt = mnts_find_submount(path))) {

 			struct timespec t = { 0, 300000000 };

 			struct timespec r;

-			if (this->state != ST_SHUTDOWN &&

-			    this->state != ST_SHUTDOWN_PENDING &&

-			    this->state != ST_SHUTDOWN_FORCE) {

+			if (sbmnt->ap->state != ST_SHUTDOWN &&

+			    sbmnt->ap->state != ST_SHUTDOWN_PENDING &&

+			    sbmnt->ap->state != ST_SHUTDOWN_FORCE) {

 				ret = 0;

+				mnts_put_mount(sbmnt);

 				break;

 			}

+			mnts_put_mount(sbmnt);

 			st_mutex_unlock();

-			mounts_mutex_unlock(ap);

 			while (nanosleep(&t, &r) == -1 && errno == EINTR)

 				memcpy(&t, &r, sizeof(struct timespec));

-			mounts_mutex_lock(ap);

 			st_mutex_lock();

 		}

 		st_mutex_unlock();

 		break;

 	}

-	mounts_mutex_unlock(ap);

+	mnts_put_submount_list(&sbmnts);

 	return ret;

 }

--- autofs-5.1.4.orig/lib/mounts.c

+++ autofs-5.1.4/lib/mounts.c

@@ -885,6 +885,8 @@ static struct mnt_list *mnts_alloc_mount

 	this->ref = 1;

 	INIT_HLIST_NODE(&this->hash);

+	INIT_LIST_HEAD(&this->submount);

+	INIT_LIST_HEAD(&this->submount_work);

 done:

 	return this;

 }

@@ -967,6 +969,85 @@ void mnts_put_mount(struct mnt_list *mnt

 	mnts_hash_mutex_unlock();

 }

+struct mnt_list *mnts_find_submount(const char *path)

+{

+	struct mnt_list *mnt;

+

+	mnt = mnts_lookup_mount(path);

+	if (mnt && mnt->flags & MNTS_AUTOFS)

+		return mnt;

+	mnts_put_mount(mnt);

+	return NULL;

+}

+

+struct mnt_list *mnts_add_submount(struct autofs_point *ap)

+{

+	struct mnt_list *this;

+

+	mnts_hash_mutex_lock();

+	this = mnts_get_mount(ap->path);

+	if (this) {

+		if (!this->ap)

+			this->ap = ap;

+		else if (this->ap != ap ||

+			 this->ap->parent != ap->parent) {

+			__mnts_put_mount(this);

+			mnts_hash_mutex_unlock();

+			error(ap->logopt,

+			      "conflict with submount owner: %s", ap->path);

+			goto fail;

+		}

+		this->flags |= MNTS_AUTOFS;

+		if (list_empty(&this->submount))

+			list_add_tail(&this->submount, &ap->parent->submounts);

+	}

+	mnts_hash_mutex_unlock();

+fail:

+	return this;

+}

+

+void mnts_remove_submount(const char *mp)

+{

+	struct mnt_list *this;

+

+	mnts_hash_mutex_lock();

+	this = mnts_lookup(mp);

+	if (this && this->flags & MNTS_AUTOFS) {

+		this->flags &= ~MNTS_AUTOFS;

+		this->ap = NULL;

+		list_del_init(&this->submount);

+		__mnts_put_mount(this);

+	}

+	mnts_hash_mutex_unlock();

+}

+

+void mnts_get_submount_list(struct list_head *mnts, struct autofs_point *ap)

+{

+	struct mnt_list *mnt;

+

+	mnts_hash_mutex_lock();

+	if (list_empty(&ap->submounts))

+		goto done;

+	list_for_each_entry(mnt, &ap->submounts, submount) {

+		__mnts_get_mount(mnt);

+		list_add(&mnt->submount_work, mnts);

+	}

+done:

+	mnts_hash_mutex_unlock();

+}

+

+void mnts_put_submount_list(struct list_head *mnts)

+{

+	struct mnt_list *mnt, *tmp;

+

+	mnts_hash_mutex_lock();

+	list_for_each_entry_safe(mnt, tmp, mnts, submount_work) {

+		list_del_init(&mnt->submount_work);

+		__mnts_put_mount(mnt);

+	}

+	mnts_hash_mutex_unlock();

+}

+

 /* From glibc decode_name() */

 /* Since the values in a line are separated by spaces, a name cannot

  * contain a space.  Therefore some programs encode spaces in names

--- autofs-5.1.4.orig/modules/mount_autofs.c

+++ autofs-5.1.4/modules/mount_autofs.c

@@ -65,6 +65,7 @@ int mount_mount(struct autofs_point *ap,

 	struct master_mapent *entry;

 	struct map_source *source;

 	struct autofs_point *nap;

+	struct mnt_list *mnt;

 	char buf[MAX_ERR_BUF];

 	char *options, *p;

 	int len, ret;

@@ -307,6 +308,18 @@ int mount_mount(struct autofs_point *ap,

 		return 1;

 	}

+	mnt = mnts_add_submount(nap);

+	if (!mnt) {

+		crit(ap->logopt,

+		     MODPREFIX "failed to allocate mount %s", realpath);

+		handle_mounts_startup_cond_destroy(&suc);

+		mounts_mutex_unlock(ap);

+		master_free_map_source(source, 1);

+		master_free_mapent(entry);

+		return 1;

+	}

+

+

 	suc.ap = nap;

 	suc.root = mountpoint;

 	suc.done = 0;

@@ -318,6 +331,7 @@ int mount_mount(struct autofs_point *ap,

 		     "failed to create mount handler thread for %s",

 		     realpath);

 		handle_mounts_startup_cond_destroy(&suc);

+		mnts_remove_submount(nap->path);

 		mounts_mutex_unlock(ap);

 		master_free_map_source(source, 1);

 		master_free_mapent(entry);

@@ -328,6 +342,7 @@ int mount_mount(struct autofs_point *ap,

 		status = pthread_cond_wait(&suc.cond, &suc.mutex);

 		if (status) {

 			handle_mounts_startup_cond_destroy(&suc);

+			mnts_remove_submount(nap->path);

 			mounts_mutex_unlock(ap);

 			master_free_map_source(source, 1);

 			master_free_mapent(entry);

@@ -339,6 +354,7 @@ int mount_mount(struct autofs_point *ap,

 		crit(ap->logopt,

 		     MODPREFIX "failed to create submount for %s", realpath);

 		handle_mounts_startup_cond_destroy(&suc);

+		mnts_remove_submount(nap->path);

 		mounts_mutex_unlock(ap);

 		master_free_map_source(source, 1);

 		master_free_mapent(entry);

@@ -347,7 +363,6 @@ int mount_mount(struct autofs_point *ap,

 	nap->thid = thid;

 	ap->submnt_count++;

-	list_add(&nap->mounts, &ap->submounts);

 	handle_mounts_startup_cond_destroy(&suc);

 	mounts_mutex_unlock(ap);