autofs/autofs-5.1.6-use-struct-mnt_list-mounted-list-for-expire.patch

autofs-5.1.6 - use struct mnt_list mounted list for expire

From: Ian Kent <raven@themaw.net>

Now we are keeping track of mounted mounts using the mnt_list struct
use it to drive the expire instead of using the system mount table.

Signed-off-by: Ian Kent <raven@themaw.net>
---
 CHANGELOG         |    1 
 daemon/direct.c   |   61 +++++++----------
 daemon/indirect.c |   66 +++++++++----------
 include/mounts.h  |    5 -
 lib/master.c      |   36 +---------
 lib/mounts.c      |  185 ++++++++++++++++++++++++++++++++++++++++++++++--------
 6 files changed, 223 insertions(+), 131 deletions(-)

--- autofs-5.1.4.orig/CHANGELOG
+++ autofs-5.1.4/CHANGELOG
@@ -129,6 +129,7 @@ xx/xx/2018 autofs-5.1.5
 - fix remount expire.
 - fix stale offset directories disable mount.
 - use struct mnt_list to track mounted mounts.
+- use struct mnt_list mounted list for expire.
 
 19/12/2017 autofs-5.1.4
 - fix spec file url.
--- autofs-5.1.4.orig/daemon/direct.c
+++ autofs-5.1.4/daemon/direct.c
@@ -77,9 +77,8 @@ static void key_mnt_params_init(void)
 
 static void mnts_cleanup(void *arg)
 {
-	struct mnt_list *mnts = (struct mnt_list *) arg;
-	tree_free_mnt_tree(mnts);
-	return;
+	struct list_head *mnts = (struct list_head *) arg;
+	mnts_put_expire_list(mnts);
 }
 
 int do_umount_autofs_direct(struct autofs_point *ap, struct mapent *me)
@@ -788,8 +787,8 @@ out_err:
 void *expire_proc_direct(void *arg)
 {
 	struct ioctl_ops *ops = get_ioctl_ops();
-	struct mnt_list *mnts = NULL, *next;
-	struct list_head list, *p;
+	struct mnt_list *mnt;
+	LIST_HEAD(mnts);
 	struct expire_args *ea;
 	struct expire_args ec;
 	struct autofs_point *ap;
@@ -821,31 +820,24 @@ void *expire_proc_direct(void *arg)
 
 	left = 0;
 
-	mnts = tree_make_mnt_tree("/");
-	pthread_cleanup_push(mnts_cleanup, mnts);
-
-	/* Get a list of mounts select real ones and expire them if possible */
-	INIT_LIST_HEAD(&list);
-	if (!tree_get_mnt_list(mnts, &list, "/", 0)) {
-		ec.status = 0;
-		return NULL;
-	}
-
-	list_for_each(p, &list) {
-		next = list_entry(p, struct mnt_list, list);
-
+	/* Get the list of real mounts and expire them if possible */
+	mnts_get_expire_list(&mnts, ap);
+	if (list_empty(&mnts))
+		goto done;
+	pthread_cleanup_push(mnts_cleanup, &mnts);
+	list_for_each_entry(mnt, &mnts, expire) {
 		/*
 		 * All direct mounts must be present in the map
 		 * entry cache.
 		 */
 		pthread_cleanup_push(master_source_lock_cleanup, ap->entry);
 		master_source_readlock(ap->entry);
-		me = lookup_source_mapent(ap, next->mp, LKP_DISTINCT);
+		me = lookup_source_mapent(ap, mnt->mp, LKP_DISTINCT);
 		pthread_cleanup_pop(1);
 		if (!me)
 			continue;
 
-		if (next->flags & MNTS_AUTOFS) {
+		if (mnt->flags & (MNTS_AUTOFS|MNTS_OFFSET)) {
 			struct stat st;
 			int ioctlfd;
 
@@ -856,22 +848,17 @@ void *expire_proc_direct(void *arg)
 			 * one of them and pass on state change.
 			 */
 			pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cur_state);
-			if (next->flags & MNTS_INDIRECT) {
-				master_notify_submount(ap, next->mp, ap->state);
-				pthread_setcancelstate(cur_state, NULL);
-				continue;
-			}
+			if (mnt->flags & MNTS_AUTOFS)
+				master_notify_submount(ap, mnt->mp, ap->state);
 
 			if (me->ioctlfd == -1) {
 				pthread_setcancelstate(cur_state, NULL);
 				continue;
 			}
 
-			/* It's got a mount, deal with in the outer loop */
-			if (is_mounted(me->key, MNTS_REAL)) {
-				pthread_setcancelstate(cur_state, NULL);
-				continue;
-			}
+			/* It's got a mount, just send the expire. */
+			if (is_mounted(me->key, MNTS_REAL))
+				goto cont;
 
 			/*
 			 * Maybe a manual umount, repair.
@@ -888,19 +875,19 @@ void *expire_proc_direct(void *arg)
 			cache_writelock(me->mc);
 			if (me->ioctlfd != -1 && 
 			    fstat(me->ioctlfd, &st) != -1 &&
-			    !count_mounts(ap, next->mp, st.st_dev)) {
+			    !count_mounts(ap, mnt->mp, st.st_dev)) {
 				ops->close(ap->logopt, me->ioctlfd);
 				me->ioctlfd = -1;
 				cache_unlock(me->mc);
-				mnts_remove_mount(next->mp, MNTS_MOUNTED);
+				mnts_remove_mount(mnt->mp, MNTS_MOUNTED);
 				pthread_setcancelstate(cur_state, NULL);
 				continue;
 			}
 			cache_unlock(me->mc);
-
+cont:
 			ioctlfd = me->ioctlfd;
 
-			ret = ops->expire(ap->logopt, ioctlfd, next->mp, how);
+			ret = ops->expire(ap->logopt, ioctlfd, mnt->mp, how);
 			if (ret) {
 				left++;
 				pthread_setcancelstate(cur_state, NULL);
@@ -923,10 +910,10 @@ void *expire_proc_direct(void *arg)
 		if (ap->state == ST_EXPIRE || ap->state == ST_PRUNE)
 			pthread_testcancel();
 
-		debug(ap->logopt, "send expire to trigger %s", next->mp);
+		debug(ap->logopt, "send expire to trigger %s", mnt->mp);
 
 		pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cur_state);
-		ret = ops->expire(ap->logopt, ioctlfd, next->mp, how);
+		ret = ops->expire(ap->logopt, ioctlfd, mnt->mp, how);
 		if (ret)
 			left++;
 		pthread_setcancelstate(cur_state, NULL);
@@ -935,7 +922,7 @@ void *expire_proc_direct(void *arg)
 
 	if (left)
 		debug(ap->logopt, "%d remaining in %s", left, ap->path);
-
+done:
 	ec.status = left;
 
 	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cur_state);
--- autofs-5.1.4.orig/daemon/indirect.c
+++ autofs-5.1.4/daemon/indirect.c
@@ -343,17 +343,17 @@ force_umount:
 
 static void mnts_cleanup(void *arg)
 {
-	struct mnt_list *mnts = (struct mnt_list *) arg;
-	free_mnt_list(mnts);
-	return;
+	struct list_head *mnts = (struct list_head *) arg;
+	mnts_put_expire_list(mnts);
 }
 
 void *expire_proc_indirect(void *arg)
 {
 	struct ioctl_ops *ops = get_ioctl_ops();
 	struct autofs_point *ap;
-	struct mapent *me = NULL;
-	struct mnt_list *mnts = NULL, *next;
+	struct mnt_list *mnt;
+	LIST_HEAD(mnts);
+	struct mapent *me;
 	struct expire_args *ea;
 	struct expire_args ec;
 	unsigned int how;
@@ -385,36 +385,34 @@ void *expire_proc_indirect(void *arg)
 
 	left = 0;
 
-	/* Get a list of real mounts and expire them if possible */
-	mnts = get_mnt_list(ap->path, 0);
-	pthread_cleanup_push(mnts_cleanup, mnts);
-	for (next = mnts; next; next = next->next) {
+	/* Get the list of real mounts and expire them if possible */
+	mnts_get_expire_list(&mnts, ap);
+	if (list_empty(&mnts))
+		goto done;
+	pthread_cleanup_push(mnts_cleanup, &mnts);
+	list_for_each_entry(mnt, &mnts, expire) {
 		char *ind_key;
 		int ret;
 
-		if (next->flags & MNTS_AUTOFS) {
+		if (mnt->flags & (MNTS_AUTOFS|MNTS_OFFSET)) {
 			/*
 			 * If we have submounts check if this path lives below
 			 * one of them and pass on the state change.
 			 */
 			pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cur_state);
-			if (next->flags & MNTS_INDIRECT)
-				master_notify_submount(ap, next->mp, ap->state);
-			else if (next->flags & MNTS_OFFSET) {
+			if (mnt->flags & MNTS_AUTOFS)
+				master_notify_submount(ap, mnt->mp, ap->state);
+
+			/* An offset without a real mount, check for manual umount */
+			if (mnt->flags & MNTS_OFFSET &&
+			    !is_mounted(mnt->mp, MNTS_REAL)) {
 				struct mnt_list *sbmnt;
 				struct map_source *map;
 				struct mapent_cache *mc = NULL;
-				struct mapent *me = NULL;
 				struct stat st;
 
-				/* It's got a mount, deal with in the outer loop */
-				if (is_mounted(next->mp, MNTS_REAL)) {
-					pthread_setcancelstate(cur_state, NULL);
-					continue;
-				}
-
 				/* Don't touch submounts */
-				sbmnt = mnts_find_submount(next->mp);
+				sbmnt = mnts_find_submount(mnt->mp);
 				if (sbmnt) {
 					mnts_put_mount(sbmnt);
 					pthread_setcancelstate(cur_state, NULL);
@@ -427,7 +425,7 @@ void *expire_proc_indirect(void *arg)
 				while (map) {
 					mc = map->mc;
 					cache_writelock(mc);
-					me = cache_lookup_distinct(mc, next->mp);
+					me = cache_lookup_distinct(mc, mnt->mp);
 					if (me)
 						break;
 					cache_unlock(mc);
@@ -456,10 +454,10 @@ void *expire_proc_indirect(void *arg)
 
 				cache_unlock(mc);
 				master_source_unlock(ap->entry);
+				pthread_setcancelstate(cur_state, NULL);
+				continue;
 			}
-
 			pthread_setcancelstate(cur_state, NULL);
-			continue;
 		}
 
 		if (ap->state == ST_EXPIRE || ap->state == ST_PRUNE)
@@ -469,7 +467,7 @@ void *expire_proc_indirect(void *arg)
 		 * If the mount corresponds to an offset trigger then
 		 * the key is the path, otherwise it's the last component.
 		 */
-		ind_key = strrchr(next->mp, '/');
+		ind_key = strrchr(mnt->mp, '/');
 		if (ind_key)
 			ind_key++;
 
@@ -482,7 +480,7 @@ void *expire_proc_indirect(void *arg)
 		 */
 		pthread_cleanup_push(master_source_lock_cleanup, ap->entry);
 		master_source_readlock(ap->entry);
-		me = lookup_source_mapent(ap, next->mp, LKP_DISTINCT);
+		me = lookup_source_mapent(ap, mnt->mp, LKP_DISTINCT);
 		if (!me && ind_key)
 			me = lookup_source_mapent(ap, ind_key, LKP_NORMAL);
 		pthread_cleanup_pop(1);
@@ -494,10 +492,10 @@ void *expire_proc_indirect(void *arg)
 			cache_unlock(me->mc);
 		}
 
-		debug(ap->logopt, "expire %s", next->mp);
+		debug(ap->logopt, "expire %s", mnt->mp);
 
 		pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cur_state);
-		ret = ops->expire(ap->logopt, ioctlfd, next->mp, how);
+		ret = ops->expire(ap->logopt, ioctlfd, mnt->mp, how);
 		if (ret)
 			left++;
 		pthread_setcancelstate(cur_state, NULL);
@@ -519,14 +517,14 @@ void *expire_proc_indirect(void *arg)
 	pthread_cleanup_pop(1);
 
 	count = offsets = submnts = 0;
-	mnts = get_mnt_list(ap->path, 0);
-	pthread_cleanup_push(mnts_cleanup, mnts);
+	mnts_get_expire_list(&mnts, ap);
+	pthread_cleanup_push(mnts_cleanup, &mnts);
 	/* Are there any real mounts left */
-	for (next = mnts; next; next = next->next) {
-		if (!(next->flags & MNTS_AUTOFS))
+	list_for_each_entry(mnt, &mnts, expire) {
+		if (!(mnt->flags & MNTS_AUTOFS))
 			count++;
 		else {
-			if (next->flags & MNTS_INDIRECT)
+			if (mnt->flags & MNTS_INDIRECT)
 				submnts++;
 			else
 				offsets++;
@@ -544,7 +542,7 @@ void *expire_proc_indirect(void *arg)
 	 */
 	if (count)
 		debug(ap->logopt, "%d remaining in %s", count, ap->path);
-
+done:
 	ec.status = left;
 
 	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cur_state);
--- autofs-5.1.4.orig/include/mounts.h
+++ autofs-5.1.4/include/mounts.h
@@ -63,6 +63,8 @@ struct mnt_list {
 
 	/* List of mounts of an autofs_point */
 	struct list_head mount;
+	/* Mounted mounts list for expire */
+	struct list_head expire;
 
 	/* List of sub-mounts of an autofs_point */
 	struct autofs_point *ap;
@@ -129,15 +131,12 @@ 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 *mnts_find_amdmount(const char *path);
 struct mnt_list *mnts_add_amdmount(struct autofs_point *ap, struct amd_entry *entry);
 void mnts_remove_amdmount(const char *mp);
 struct mnt_list *mnts_add_mount(struct autofs_point *ap, const char *name, unsigned int flags);
 void mnts_remove_mount(const char *mp, unsigned int flags);
 struct mnt_list *get_mnt_list(const char *path, int include);
-unsigned int mnts_has_mounted_mounts(struct autofs_point *ap);
 void mnts_get_expire_list(struct list_head *mnts, struct autofs_point *ap);
 void mnts_put_expire_list(struct list_head *mnts);
 void mnts_set_mounted_mount(struct autofs_point *ap, const char *name);
--- autofs-5.1.4.orig/lib/master.c
+++ autofs-5.1.4/lib/master.c
@@ -1133,40 +1133,17 @@ int master_submount_list_empty(struct au
 int master_notify_submount(struct autofs_point *ap, const char *path, enum states state)
 {
 	struct mnt_list *this, *sbmnt;
-	LIST_HEAD(sbmnts);
 	int ret = 1;
 
-	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->mp, path))
-			continue;
-
-		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 */
-
+	this = mnts_find_submount(path);
+	if (this) {
+		/* We have found a submount to expire */
 		st_mutex_lock();
 
 		if (this->ap->state == ST_SHUTDOWN) {
 			this = NULL;
 			st_mutex_unlock();
-			break;
+			goto done;
 		}
 
 		this->ap->shutdown = ap->shutdown;
@@ -1202,11 +1179,10 @@ int master_notify_submount(struct autofs
 			st_mutex_lock();
 		}
 		st_mutex_unlock();
-		break;
+done:
+		mnts_put_mount(this);
 	}
 
-	mnts_put_submount_list(&sbmnts);
-
 	return ret;
 }
 
--- autofs-5.1.4.orig/lib/mounts.c
+++ autofs-5.1.4/lib/mounts.c
@@ -888,6 +888,7 @@ static struct mnt_list *mnts_alloc_mount
 	INIT_LIST_HEAD(&this->submount);
 	INIT_LIST_HEAD(&this->submount_work);
 	INIT_LIST_HEAD(&this->amdmount);
+	INIT_LIST_HEAD(&this->expire);
 done:
 	return this;
 }
@@ -1022,33 +1023,6 @@ void mnts_remove_submount(const char *mp
 	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();
-}
-
 struct mnt_list *mnts_find_amdmount(const char *path)
 {
 	struct mnt_list *mnt;
@@ -1234,6 +1208,163 @@ void mnts_set_mounted_mount(struct autof
 	}
 }
 
+struct node {
+	struct mnt_list *mnt;
+	struct node *left;
+	struct node *right;
+};
+
+static struct node *new(struct mnt_list *mnt)
+{
+	struct node *n;
+
+	n = malloc(sizeof(struct node));
+	if (!n)
+		return NULL;
+	memset(n, 0, sizeof(struct node));
+	n->mnt = mnt;
+
+	return n;
+}
+
+static struct node *tree_root(struct mnt_list *mnt)
+{
+	struct node *n;
+
+	n = new(mnt);
+	if (!n) {
+		error(LOGOPT_ANY, "failed to allcate tree root");
+		return NULL;
+	}
+
+	return n;
+}
+
+static struct node *add_left(struct node *this, struct mnt_list *mnt)
+{
+	struct node *n;
+
+	n = new(mnt);
+	if (!n) {
+		error(LOGOPT_ANY, "failed to allcate tree node");
+		return NULL;
+	}
+	this->left = n;
+
+	return n;
+}
+
+static struct node *add_right(struct node *this, struct mnt_list *mnt)
+{
+	struct node *n;
+
+	n = new(mnt);
+	if (!n) {
+		error(LOGOPT_ANY, "failed to allcate tree node");
+		return NULL;
+	}
+	this->right = n;
+
+	return n;
+}
+
+static struct node *add_node(struct node *root, struct mnt_list *mnt)
+{
+	struct node *p, *q;
+	unsigned int mp_len;
+
+	mp_len = strlen(mnt->mp);
+
+	q = root;
+	p = root;
+
+	while (q && strcmp(mnt->mp, p->mnt->mp)) {
+		p = q;
+		if (mp_len < strlen(p->mnt->mp))
+			q = p->left;
+		else
+			q = p->right;
+	}
+
+	if (strcmp(mnt->mp, p->mnt->mp) == 0)
+		error(LOGOPT_ANY, "duplicate entry in mounts list");
+	else {
+		if (mp_len < strlen(p->mnt->mp))
+			return add_left(p, mnt);
+		else
+			return add_right(p, mnt);
+	}
+
+	return NULL;
+}
+
+static void tree_free(struct node *tree)
+{
+	if (tree->right)
+		tree_free(tree->right);
+	if (tree->left)
+		tree_free(tree->left);
+	free(tree);
+}
+
+static void traverse(struct node *node, struct list_head *mnts)
+{
+	if (node->right)
+		traverse(node->right, mnts);
+	list_add_tail(&node->mnt->expire, mnts);
+	if (node->left)
+		traverse(node->left, mnts);
+}
+
+void mnts_get_expire_list(struct list_head *mnts, struct autofs_point *ap)
+{
+	struct mnt_list *mnt;
+	struct node *tree = NULL;
+
+	mnts_hash_mutex_lock();
+	if (list_empty(&ap->mounts))
+		goto done;
+
+	list_for_each_entry(mnt, &ap->mounts, mount) {
+		struct node *n;
+
+		__mnts_get_mount(mnt);
+
+		if (!tree) {
+			tree = tree_root(mnt);
+			if (!tree) {
+				error(LOGOPT_ANY, "failed to create expire tree root");
+				goto done;
+			}
+			continue;
+		}
+
+		n = add_node(tree, mnt);
+		if (!n) {
+			error(LOGOPT_ANY, "failed to add expire tree node");
+			tree_free(tree);
+			goto done;
+		}
+	}
+
+	traverse(tree, mnts);
+	tree_free(tree);
+done:
+	mnts_hash_mutex_unlock();
+}
+
+void mnts_put_expire_list(struct list_head *mnts)
+{
+	struct mnt_list *mnt, *tmp;
+
+	mnts_hash_mutex_lock();
+	list_for_each_entry_safe(mnt, tmp, mnts, expire) {
+		list_del_init(&mnt->expire);
+		__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