autofs/autofs-5.1.7-eliminate-cache_lookup_offset-usage.patch

autofs-5.1.7 - eliminate cache_lookup_offset() usage

From: Ian Kent <raven@themaw.net>

The function cache_lookup_offset() will do a linear search when
looking for an offset. If the number of offsets is large this
can be a lot of overhead.

But it's possible to use the information already present where
this is called to to do a hashed lookup instead.

Signed-off-by: Ian Kent <raven@themaw.net>
---
 CHANGELOG           |    1 
 lib/mounts.c        |   82 +++++++++++++++++++++++++++++++++-------------------
 modules/parse_sun.c |   77 ++++++++++++++++++++++++++++++------------------
 3 files changed, 102 insertions(+), 58 deletions(-)

--- autofs-5.1.4.orig/CHANGELOG
+++ autofs-5.1.4/CHANGELOG
@@ -4,6 +4,7 @@
 - dont use realloc in host exports list processing.
 - use sprintf() when constructing hosts mapent.
 - fix mnts_remove_amdmount() uses wrong list.
+- eliminate cache_lookup_offset() usage.
 
 xx/xx/2018 autofs-5.1.5
 - fix flag file permission.
--- autofs-5.1.4.orig/lib/mounts.c
+++ autofs-5.1.4/lib/mounts.c
@@ -2489,24 +2489,27 @@ int mount_multi_triggers(struct autofs_p
 	char *offset = path;
 	struct mapent *oe;
 	struct list_head *pos = NULL;
-	unsigned int fs_path_len;
+	unsigned int root_len = strlen(root);
 	int mounted;
 
-	fs_path_len = start + strlen(base);
-	if (fs_path_len > PATH_MAX)
-		return -1;
-
 	mounted = 0;
 	offset = cache_get_offset(base, offset, start, &me->multi_list, &pos);
 	while (offset) {
-		int plen = fs_path_len + strlen(offset);
+		char key[PATH_MAX + 1];
+		int key_len = root_len + strlen(offset);
 
-		if (plen > PATH_MAX) {
+		if (key_len > PATH_MAX) {
 			warn(ap->logopt, "path loo long");
 			goto cont;
 		}
 
-		oe = cache_lookup_offset(base, offset, start, &me->multi_list);
+		/* The root offset is always mounted seperately so the
+		 * offset path will always be root + offset.
+		 */
+		strcpy(key, root);
+		strcat(key, offset);
+
+		oe = cache_lookup_distinct(me->mc, key);
 		if (!oe || !oe->mapent)
 			goto cont;
 
@@ -2519,12 +2522,8 @@ int mount_multi_triggers(struct autofs_p
 		 */
 		if (ap->state == ST_READMAP && ap->flags & MOUNT_FLAG_REMOUNT) {
 			if (oe->ioctlfd != -1 ||
-			    is_mounted(oe->key, MNTS_REAL)) {
-				char oe_root[PATH_MAX + 1];
-				strcpy(oe_root, root);
-				strcat(oe_root, offset); 
-				mount_multi_triggers(ap, oe, oe_root, strlen(oe_root), base);
-			}
+			    is_mounted(oe->key, MNTS_REAL))
+				mount_multi_triggers(ap, oe, key, strlen(key), base);
 		}
 cont:
 		offset = cache_get_offset(base,
@@ -2578,6 +2577,8 @@ int umount_multi_triggers(struct autofs_
 	const char o_root[] = "/";
 	const char *mm_base;
 	int left, start;
+	unsigned int root_len;
+	unsigned int mm_base_len;
 
 	left = 0;
 	start = strlen(root);
@@ -2591,11 +2592,28 @@ int umount_multi_triggers(struct autofs_
 
 	pos = NULL;
 	offset = path;
+	root_len = start;
+	mm_base_len = strlen(mm_base);
 
 	while ((offset = cache_get_offset(mm_base, offset, start, mm_root, &pos))) {
+		char key[PATH_MAX + 1];
+		int key_len = root_len + strlen(offset);
 		char *oe_base;
 
-		oe = cache_lookup_offset(mm_base, offset, start, &me->multi_list);
+		if (mm_base_len > 1)
+			key_len += mm_base_len;
+
+		if (key_len > PATH_MAX) {
+			warn(ap->logopt, "path loo long");
+			continue;
+		}
+
+		strcpy(key, root);
+		if (mm_base_len > 1)
+			strcat(key, mm_base);
+		strcat(key, offset);
+
+		oe = cache_lookup_distinct(me->mc, key);
 		/* root offset is a special case */
 		if (!oe || (strlen(oe->key) - start) == 1)
 			continue;
@@ -2680,13 +2698,14 @@ int clean_stale_multi_triggers(struct au
 	char *root;
 	char mm_top[PATH_MAX + 1];
 	char path[PATH_MAX + 1];
-	char buf[MAX_ERR_BUF];
 	char *offset;
 	struct mapent *oe;
 	struct list_head *mm_root, *pos;
 	const char o_root[] = "/";
 	const char *mm_base;
 	int left, start;
+	unsigned int root_len;
+	unsigned int mm_base_len;
 	time_t age;
 
 	if (top)
@@ -2714,14 +2733,30 @@ int clean_stale_multi_triggers(struct au
 
 	pos = NULL;
 	offset = path;
+	root_len = start;
+	mm_base_len = strlen(mm_base);
 	age = me->multi->age;
 
 	while ((offset = cache_get_offset(mm_base, offset, start, mm_root, &pos))) {
+		char key[PATH_MAX + 1];
+		int key_len = root_len + strlen(offset);
 		char *oe_base;
-		char *key;
 		int ret;
 
-		oe = cache_lookup_offset(mm_base, offset, start, &me->multi_list);
+		if (mm_base_len > 1)
+			key_len += mm_base_len;
+
+		if (key_len > PATH_MAX) {
+			warn(ap->logopt, "path loo long");
+			continue;
+		}
+
+		strcpy(key, root);
+		if (mm_base_len > 1)
+			strcat(key, mm_base);
+		strcat(key, offset);
+
+		oe = cache_lookup_distinct(me->mc, key);
 		/* root offset is a special case */
 		if (!oe || (strlen(oe->key) - start) == 1)
 			continue;
@@ -2772,14 +2807,6 @@ int clean_stale_multi_triggers(struct au
 			}
 		}
 
-		key = strdup(oe->key);
-		if (!key) {
-	                char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
-		        error(ap->logopt, "malloc: %s", estr);
-			left++;
-			continue;
-		}
-
 		debug(ap->logopt, "umount offset %s", oe->key);
 
 		if (umount_autofs_offset(ap, oe)) {
@@ -2794,7 +2821,6 @@ int clean_stale_multi_triggers(struct au
 				if (cache_delete_offset(oe->mc, key) == CHE_FAIL)
 					error(ap->logopt,
 					     "failed to delete offset key %s", key);
-				free(key);
 				continue;
 			}
 
@@ -2810,7 +2836,6 @@ int clean_stale_multi_triggers(struct au
 					left++;
 					/* But we did origianlly create this */
 					oe->flags |= MOUNT_FLAG_DIR_CREATED;
-					free(key);
 					continue;
 				}
 				/*
@@ -2828,7 +2853,6 @@ int clean_stale_multi_triggers(struct au
 				error(ap->logopt,
 				     "failed to delete offset key %s", key);
 		}
-		free(key);
 	}
 
 	return left;
--- autofs-5.1.4.orig/modules/parse_sun.c
+++ autofs-5.1.4/modules/parse_sun.c
@@ -1088,6 +1088,8 @@ static void cleanup_multi_triggers(struc
 	struct list_head *mm_root, *pos;
 	const char o_root[] = "/";
 	const char *mm_base;
+	unsigned int root_len;
+	unsigned int mm_base_len;
 
 	mm_root = &me->multi->multi_list;
 
@@ -1097,16 +1099,31 @@ static void cleanup_multi_triggers(struc
 		mm_base = base;
 
 	pos = NULL;
+	root_len = strlen(root);
+	mm_base_len = strlen(mm_base);
 
 	/* Make sure "none" of the offsets have an active mount. */
 	while ((poffset = cache_get_offset(mm_base, poffset, start, mm_root, &pos))) {
-		oe = cache_lookup_offset(mm_base, poffset, start, &me->multi_list);
-		/* root offset is a special case */
-		if (!oe || !oe->mapent || (strlen(oe->key) - start) == 1)
+		unsigned int path_len = root_len + strlen(poffset);
+
+		if (mm_base_len > 1)
+			path_len += mm_base_len;
+
+		if (path_len > PATH_MAX) {
+			warn(ap->logopt, "path loo long");
 			continue;
+		}
 
 		strcpy(path, root);
+		if (mm_base_len > 1)
+			strcat(path, mm_base);
 		strcat(path, poffset);
+
+		oe = cache_lookup_distinct(me->mc, path);
+		/* root offset is a special case */
+		if (!oe || !oe->mapent || (strlen(oe->key) - start) == 1)
+			continue;
+
 		if (umount(path)) {
 			error(ap->logopt, "error recovering from mount fail");
 			error(ap->logopt, "cannot umount offset %s", path);
@@ -1119,17 +1136,14 @@ static void cleanup_multi_triggers(struc
 static int mount_subtree(struct autofs_point *ap, struct mapent *me,
 			 const char *name, char *loc, char *options, void *ctxt)
 {
-	struct mapent *mm;
 	struct mapent *ro;
 	char *mm_root, *mm_base, *mm_key;
-	const char *mnt_root;
-	unsigned int mm_root_len, mnt_root_len;
+	unsigned int mm_root_len;
 	int start, ret = 0, rv;
 
 	rv = 0;
 
-	mm = me->multi;
-	mm_key = mm->key;
+	mm_key = me->multi->key;
 
 	if (*mm_key == '/') {
 		mm_root = mm_key;
@@ -1143,20 +1157,26 @@ static int mount_subtree(struct autofs_p
 	}
 	mm_root_len = strlen(mm_root);
 
-	mnt_root = mm_root;
-	mnt_root_len = mm_root_len;
-
 	if (me == me->multi) {
+		char key[PATH_MAX + 1];
+
+		if (mm_root_len + 1 > PATH_MAX) {
+			warn(ap->logopt, "path loo long");
+			return 1;
+		}
+
 		/* name = NULL */
 		/* destination = mm_root */
 		mm_base = "/";
 
+		strcpy(key, mm_root);
+		strcat(key, mm_base);
+
 		/* Mount root offset if it exists */
-		ro = cache_lookup_offset(mm_base, mm_base, strlen(mm_root), &me->multi_list);
+		ro = cache_lookup_distinct(me->mc, key);
 		if (ro) {
-			char *myoptions, *ro_loc, *tmp;
+			char *myoptions, *ro_loc;
 			int namelen = name ? strlen(name) : 0;
-			const char *root;
 			int ro_len;
 
 			myoptions = NULL;
@@ -1174,13 +1194,7 @@ static int mount_subtree(struct autofs_p
 			if (ro_loc)
 				ro_len = strlen(ro_loc);
 
-			tmp = alloca(mnt_root_len + 2);
-			strcpy(tmp, mnt_root);
-			tmp[mnt_root_len] = '/';
-			tmp[mnt_root_len + 1] = '\0';
-			root = tmp;
-
-			rv = sun_mount(ap, root, name, namelen, ro_loc, ro_len, myoptions, ctxt);
+			rv = sun_mount(ap, key, name, namelen, ro_loc, ro_len, myoptions, ctxt);
 
 			free(myoptions);
 			if (ro_loc)
@@ -1188,11 +1202,11 @@ static int mount_subtree(struct autofs_p
 		}
 
 		if (ro && rv == 0) {
-			ret = mount_multi_triggers(ap, me, mnt_root, start, mm_base);
+			ret = mount_multi_triggers(ap, me, mm_root, start, mm_base);
 			if (ret == -1) {
 				error(ap->logopt, MODPREFIX
 					 "failed to mount offset triggers");
-				cleanup_multi_triggers(ap, me, mnt_root, start, mm_base);
+				cleanup_multi_triggers(ap, me, mm_root, start, mm_base);
 				return 1;
 			}
 		} else if (rv <= 0) {
@@ -1208,24 +1222,29 @@ static int mount_subtree(struct autofs_p
 		int loclen = strlen(loc);
 		int namelen = strlen(name);
 
-		mnt_root = name;
-
 		/* name = mm_root + mm_base */
 		/* destination = mm_root + mm_base = name */
 		mm_base = &me->key[start];
 
-		rv = sun_mount(ap, mnt_root, name, namelen, loc, loclen, options, ctxt);
+		rv = sun_mount(ap, name, name, namelen, loc, loclen, options, ctxt);
 		if (rv == 0) {
-			ret = mount_multi_triggers(ap, me->multi, mnt_root, start, mm_base);
+			ret = mount_multi_triggers(ap, me->multi, name, start, mm_base);
 			if (ret == -1) {
 				error(ap->logopt, MODPREFIX
 					 "failed to mount offset triggers");
-				cleanup_multi_triggers(ap, me, mnt_root, start, mm_base);
+				cleanup_multi_triggers(ap, me, name, start, mm_base);
 				return 1;
 			}
 		} else if (rv < 0) {
-			char *mm_root_base = alloca(strlen(mm_root) + strlen(mm_base) + 1);
+			char mm_root_base[PATH_MAX + 1];
+			unsigned int mm_root_base_len = mm_root_len + strlen(mm_base) + 1;
 	
+			if (mm_root_base_len > PATH_MAX) {
+				warn(ap->logopt, MODPREFIX "path too long");
+				cache_delete_offset_list(me->mc, name);
+				return 1;
+			}
+
 			strcpy(mm_root_base, mm_root);
 			strcat(mm_root_base, mm_base);