[packages/autofs.git] / autofs-5.0.4-dont-umount-existing-direct-mount-on-reread.patch

autofs-5.0.4 - dont umount existing direct mount on master re-read

From: Ian Kent <raven@themaw.net>

Since direct mounts can have multiple entries in the master map they each
have an instance associated with them. If one entry changes, such as the
mount options, the instance comparison test fails and a new instance is
added. This causes autofs to get confused because there are now two
entries that contain the same mount information in different internal
caches. There are several consequences of this, most of which are just
noise in the log, but it also causes confuion for the expiration of mounts
since, for an active mount, the old cache entry can't be pruned until it's
umounted. Also, the map caches were not being properly pruned.
---

 CHANGELOG           |    1 
 daemon/lookup.c     |  160 ++++++++++++++++++++++++++++-----------------------
 daemon/state.c      |   90 +++++++++++++++++++++--------
 include/automount.h |    1 
 4 files changed, 156 insertions(+), 96 deletions(-)


diff --git a/CHANGELOG b/CHANGELOG
index 387af5e..7ca45fd 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -43,6 +43,7 @@
 - use percent hack for master map keys.
 - use intr option as hosts mount default.
 - fix kernel includes.
+- dont umount existing direct mount on master re-read.
 
 4/11/2008 autofs-5.0.4
 -----------------------
diff --git a/daemon/lookup.c b/daemon/lookup.c
index fd2ce55..bc94655 100644
--- a/daemon/lookup.c
+++ b/daemon/lookup.c
@@ -1016,96 +1016,114 @@ static char *make_fullpath(const char *root, const char *key)
 	return path;
 }
 
-int lookup_prune_cache(struct autofs_point *ap, time_t age)
+void lookup_prune_one_cache(struct autofs_point *ap, struct mapent_cache *mc, time_t age)
 {
-	struct master_mapent *entry = ap->entry;
-	struct map_source *map;
-	struct mapent_cache *mc;
 	struct mapent *me, *this;
 	char *path;
 	int status = CHE_FAIL;
 
-	pthread_cleanup_push(master_source_lock_cleanup, entry);
-	master_source_readlock(entry);
+	me = cache_enumerate(mc, NULL);
+	while (me) {
+		struct mapent *valid;
+		char *key = NULL, *next_key = NULL;
 
-	map = entry->maps;
-	while (map) {
-		/* Is the map stale */
-		if (!map->stale) {
-			map = map->next;
+		if (me->age >= age) {
+			me = cache_enumerate(mc, me);
 			continue;
 		}
-		mc = map->mc;
-		pthread_cleanup_push(cache_lock_cleanup, mc);
-		cache_readlock(mc);
-		me = cache_enumerate(mc, NULL);
-		while (me) {
-			char *key = NULL, *next_key = NULL;
 
-			if (me->age >= age) {
-				me = cache_enumerate(mc, me);
-				continue;
-			}
+		key = strdup(me->key);
+		me = cache_enumerate(mc, me);
+		if (!key || *key == '*') {
+			if (key)
+				free(key);
+			continue;
+		}
 
-			key = strdup(me->key);
-			me = cache_enumerate(mc, me);
-			if (!key || *key == '*') {
-				if (key)
-					free(key);
-				continue;
-			}
+		path = make_fullpath(ap->path, key);
+		if (!path) {
+			warn(ap->logopt, "can't malloc storage for path");
+			free(key);
+			continue;
+		}
 
-			path = make_fullpath(ap->path, key);
-			if (!path) {
-				warn(ap->logopt,
-				     "can't malloc storage for path");
-				free(key);
-				continue;
-			}
+		/*
+		 * If this key has another valid entry we want to prune it,
+		 * even if it's a mount, as the valid entry will take the
+		 * mount if it is a direct mount or it's just a stale indirect
+		 * cache entry.
+		 */
+		valid = lookup_source_valid_mapent(ap, key, LKP_DISTINCT);
+		if (!valid &&
+		    is_mounted(_PATH_MOUNTED, path, MNTS_REAL)) {
+			debug(ap->logopt,
+			      "prune check posponed, %s mounted", path);
+			free(key);
+			free(path);
+			continue;
+		}
+		if (valid)
+			cache_unlock(valid->mc);
 
-			if (is_mounted(_PATH_MOUNTED, path, MNTS_REAL)) {
-				debug(ap->logopt,
-				      "prune check posponed, %s mounted", path);
-				free(key);
-				free(path);
-				continue;
-			}
+		if (me)
+			next_key = strdup(me->key);
 
-			if (me)
-				next_key = strdup(me->key);
+		cache_unlock(mc);
 
+		cache_writelock(mc);
+		this = cache_lookup_distinct(mc, key);
+		if (!this) {
 			cache_unlock(mc);
+			goto next;
+		}
 
-			cache_writelock(mc);
-			this = cache_lookup_distinct(mc, key);
-			if (!this) {
-				cache_unlock(mc);
-				goto next;
-			}
-
-			if (!is_mounted(_PROC_MOUNTS, path, MNTS_AUTOFS)) {
-				status = CHE_FAIL;
-				if (this->ioctlfd == -1)
-					status = cache_delete(mc, key);
-				if (status != CHE_FAIL) {
-					if (ap->type == LKP_INDIRECT) {
-						if (ap->flags & MOUNT_FLAG_GHOST)
-							rmdir_path(ap, path, ap->dev);
-					} else
-						rmdir_path(ap, path, this->dev);
-				}
+		if (valid)
+			cache_delete(mc, key);
+		else if (!is_mounted(_PROC_MOUNTS, path, MNTS_AUTOFS)) {
+			status = CHE_FAIL;
+			if (this->ioctlfd == -1)
+				status = cache_delete(mc, key);
+			if (status != CHE_FAIL) {
+				if (ap->type == LKP_INDIRECT) {
+					if (ap->flags & MOUNT_FLAG_GHOST)
+						rmdir_path(ap, path, ap->dev);
+				} else
+					rmdir_path(ap, path, this->dev);
 			}
-			cache_unlock(mc);
+		}
+		cache_unlock(mc);
 
 next:
-			cache_readlock(mc);
-			if (next_key) {
-				me = cache_lookup_distinct(mc, next_key);
-				free(next_key);
-			}
-			free(key);
-			free(path);
+		cache_readlock(mc);
+		if (next_key) {
+			me = cache_lookup_distinct(mc, next_key);
+			free(next_key);
 		}
+		free(key);
+		free(path);
+	}
+
+	return;
+}
+
+int lookup_prune_cache(struct autofs_point *ap, time_t age)
+{
+	struct master_mapent *entry = ap->entry;
+	struct map_source *map;
+
+	pthread_cleanup_push(master_source_lock_cleanup, entry);
+	master_source_readlock(entry);
+
+	map = entry->maps;
+	while (map) {
+		/* Is the map stale */
+		if (!map->stale) {
+			map = map->next;
+			continue;
+		}
+		pthread_cleanup_push(cache_lock_cleanup, map->mc);
+		cache_readlock(map->mc);
+		lookup_prune_one_cache(ap, map->mc, age);
 		pthread_cleanup_pop(1);
 		map->stale = 0;
 		map = map->next;
@@ -1124,7 +1142,6 @@ struct mapent *lookup_source_valid_mapent(struct autofs_point *ap, const char *k
 	struct mapent_cache *mc;
 	struct mapent *me = NULL;
 
-	master_source_readlock(entry);
 	map = entry->maps;
 	while (map) {
 		/*
@@ -1147,7 +1164,6 @@ struct mapent *lookup_source_valid_mapent(struct autofs_point *ap, const char *k
 		cache_unlock(mc);
 		map = map->next;
 	}
-	master_source_unlock(entry);
 
 	return me;
 }
diff --git a/daemon/state.c b/daemon/state.c
index 533e241..84ccba3 100644
--- a/daemon/state.c
+++ b/daemon/state.c
@@ -352,6 +352,68 @@ static void tree_mnts_cleanup(void *arg)
 	return;
 }
 
+static void do_readmap_mount(struct autofs_point *ap, struct mnt_list *mnts,
+			     struct map_source *map, struct mapent *me, time_t now)
+{
+	struct mapent_cache *nc;
+	struct mapent *ne, *nested, *valid;
+
+	nc = ap->entry->master->nc;
+
+	ne = cache_lookup_distinct(nc, me->key);
+	if (!ne) {
+		nested = cache_partial_match(nc, me->key);
+		if (nested) {
+			error(ap->logopt,
+			      "removing invalid nested null entry %s",
+			      nested->key);
+			nested = cache_partial_match(nc, me->key);
+			if (nested)
+				cache_delete(nc, nested->key);
+		}
+	}
+
+	if (me->age < now || (ne && map->master_line > ne->age)) {
+		/*
+		 * The map instance may have changed, such as the map name or
+		 * the mount options, but the direct map entry may still exist
+		 * in one of the other maps. If so then update the new cache
+		 * entry device and inode so we can find it at lookup. Later,
+		 * the mount for the new cache entry will just update the
+		 * timeout.
+		 *
+		 * TODO: how do we recognise these orphaned map instances. We
+		 * can't just delete these instances when the cache becomes
+		 * empty because that is a valid state for a master map entry.
+		 * This is becuase of the requirement to continue running with
+		 * an empty cache awaiting a map re-load.
+		 */
+		valid = lookup_source_valid_mapent(ap, me->key, LKP_DISTINCT);
+		if (valid) {
+			struct mapent_cache *vmc = valid->mc;
+			cache_unlock(vmc);
+			debug(ap->logopt,
+			     "updating cache entry for valid direct trigger %s",
+			     me->key);
+			cache_writelock(vmc);
+			valid = cache_lookup_distinct(vmc, me->key);
+			/* Take over the mount if there is one */
+			valid->ioctlfd = me->ioctlfd;
+			me->ioctlfd = -1;
+			/* Set device and inode number of the new mapent */
+			cache_set_ino_index(vmc, me->key, me->dev, me->ino);
+			cache_unlock(vmc);
+		} else if (!tree_is_mounted(mnts, me->key, MNTS_REAL))
+			do_umount_autofs_direct(ap, mnts, me);
+		else
+			debug(ap->logopt,
+			      "%s is mounted", me->key);
+	} else
+		do_mount_autofs_direct(ap, mnts, me);
+
+	return;
+}
+
 static void *do_readmap(void *arg)
 {
 	struct autofs_point *ap;
@@ -398,7 +460,8 @@ static void *do_readmap(void *arg)
 		lookup_prune_cache(ap, now);
 		status = lookup_ghost(ap, ap->path);
 	} else {
-		struct mapent *me, *ne, *nested;
+		struct mapent *me;
+
 		mnts = tree_make_mnt_tree(_PROC_MOUNTS, "/");
 		pthread_cleanup_push(tree_mnts_cleanup, mnts);
 		pthread_cleanup_push(master_source_lock_cleanup, ap->entry);
@@ -418,31 +481,10 @@ static void *do_readmap(void *arg)
 			cache_readlock(mc);
 			me = cache_enumerate(mc, NULL);
 			while (me) {
-				ne = cache_lookup_distinct(nc, me->key);
-				if (!ne) {
-					nested = cache_partial_match(nc, me->key);
-					if (nested) {
-						error(ap->logopt,
-						"removing invalid nested null entry %s",
-						nested->key);
-						nested = cache_partial_match(nc, me->key);
-						if (nested)
-							cache_delete(nc, nested->key);
-					}
-				}
-
-				/* TODO: check return of do_... */
-				if (me->age < now || (ne && map->master_line > ne->age)) {
-					if (!tree_is_mounted(mnts, me->key, MNTS_REAL))
-						do_umount_autofs_direct(ap, mnts, me);
-					else
-                                		debug(ap->logopt,
-						      "%s is mounted", me->key);
-				} else
-					do_mount_autofs_direct(ap, mnts, me);
-
+				do_readmap_mount(ap, mnts, map, me, now);
 				me = cache_enumerate(mc, me);
 			}
+			lookup_prune_one_cache(ap, map->mc, now);
 			pthread_cleanup_pop(1);
 			map->stale = 0;
 			map = map->next;
diff --git a/include/automount.h b/include/automount.h
index d4675bd..ae517a7 100644
--- a/include/automount.h
+++ b/include/automount.h
@@ -238,6 +238,7 @@ int lookup_enumerate(struct autofs_point *ap,
 int lookup_ghost(struct autofs_point *ap, const char *root);
 int lookup_nss_mount(struct autofs_point *ap, struct map_source *source, const char *name, int name_len);
 void lookup_close_lookup(struct autofs_point *ap);
+void lookup_prune_one_cache(struct autofs_point *ap, struct mapent_cache *mc, time_t age);
 int lookup_prune_cache(struct autofs_point *ap, time_t age);
 struct mapent *lookup_source_valid_mapent(struct autofs_point *ap, const char *key, unsigned int type);
 struct mapent *lookup_source_mapent(struct autofs_point *ap, const char *key, unsigned int type);
Commit	Line	Data
e5fd101c PS	1	autofs-5.0.4 - dont umount existing direct mount on master re-read
	2
	3	From: Ian Kent <raven@themaw.net>
	4
	5	Since direct mounts can have multiple entries in the master map they each
	6	have an instance associated with them. If one entry changes, such as the
	7	mount options, the instance comparison test fails and a new instance is
	8	added. This causes autofs to get confused because there are now two
	9	entries that contain the same mount information in different internal
	10	caches. There are several consequences of this, most of which are just
	11	noise in the log, but it also causes confuion for the expiration of mounts
	12	since, for an active mount, the old cache entry can't be pruned until it's
	13	umounted. Also, the map caches were not being properly pruned.
	14	---
	15
	16	CHANGELOG \| 1
	17	daemon/lookup.c \| 160 ++++++++++++++++++++++++++++-----------------------
	18	daemon/state.c \| 90 +++++++++++++++++++++--------
	19	include/automount.h \| 1
	20	4 files changed, 156 insertions(+), 96 deletions(-)
	21
	22
	23	diff --git a/CHANGELOG b/CHANGELOG
	24	index 387af5e..7ca45fd 100644
	25	--- a/CHANGELOG
	26	+++ b/CHANGELOG
	27	@@ -43,6 +43,7 @@
	28	- use percent hack for master map keys.
	29	- use intr option as hosts mount default.
	30	- fix kernel includes.
	31	+- dont umount existing direct mount on master re-read.
	32
	33	4/11/2008 autofs-5.0.4
	34	-----------------------
	35	diff --git a/daemon/lookup.c b/daemon/lookup.c
	36	index fd2ce55..bc94655 100644
	37	--- a/daemon/lookup.c
	38	+++ b/daemon/lookup.c
	39	@@ -1016,96 +1016,114 @@ static char make_fullpath(const char root, const char *key)
	40	return path;
	41	}
	42
	43	-int lookup_prune_cache(struct autofs_point *ap, time_t age)
	44	+void lookup_prune_one_cache(struct autofs_point ap, struct mapent_cache mc, time_t age)
	45	{
	46	- struct master_mapent *entry = ap->entry;
	47	- struct map_source *map;
	48	- struct mapent_cache *mc;
	49	struct mapent me, this;
	50	char *path;
	51	int status = CHE_FAIL;
	52
	53	- pthread_cleanup_push(master_source_lock_cleanup, entry);
	54	- master_source_readlock(entry);
	55	+ me = cache_enumerate(mc, NULL);
	56	+ while (me) {
	57	+ struct mapent *valid;
	58	+ char key = NULL, next_key = NULL;
	59
	60	- map = entry->maps;
	61	- while (map) {
	62	- /* Is the map stale */
	63	- if (!map->stale) {
	64	- map = map->next;
65	+ if (me->age >= age) {
66	+ me = cache_enumerate(mc, me);
67	continue;
68	}
69	- mc = map->mc;
70	- pthread_cleanup_push(cache_lock_cleanup, mc);
71	- cache_readlock(mc);
72	- me = cache_enumerate(mc, NULL);
73	- while (me) {
74	- char key = NULL, next_key = NULL;
75
76	- if (me->age >= age) {
77	- me = cache_enumerate(mc, me);
78	- continue;
79	- }
80	+ key = strdup(me->key);
81	+ me = cache_enumerate(mc, me);
82	+ if (!key \|\| key == '') {
83	+ if (key)
84	+ free(key);
85	+ continue;
86	+ }
87
88	- key = strdup(me->key);
89	- me = cache_enumerate(mc, me);
90	- if (!key \|\| key == '') {
91	- if (key)
92	- free(key);
93	- continue;
94	- }
95	+ path = make_fullpath(ap->path, key);
96	+ if (!path) {
97	+ warn(ap->logopt, "can't malloc storage for path");
98	+ free(key);
99	+ continue;
100	+ }
101
102	- path = make_fullpath(ap->path, key);
103	- if (!path) {
104	- warn(ap->logopt,
105	- "can't malloc storage for path");
106	- free(key);
107	- continue;
108	- }
109	+ /*
110	+ * If this key has another valid entry we want to prune it,
111	+ * even if it's a mount, as the valid entry will take the
112	+ * mount if it is a direct mount or it's just a stale indirect
113	+ * cache entry.
114	+ */
115	+ valid = lookup_source_valid_mapent(ap, key, LKP_DISTINCT);
116	+ if (!valid &&
117	+ is_mounted(_PATH_MOUNTED, path, MNTS_REAL)) {
118	+ debug(ap->logopt,
119	+ "prune check posponed, %s mounted", path);
120	+ free(key);
121	+ free(path);
122	+ continue;
123	+ }
124	+ if (valid)
125	+ cache_unlock(valid->mc);
126
127	- if (is_mounted(_PATH_MOUNTED, path, MNTS_REAL)) {
128	- debug(ap->logopt,
129	- "prune check posponed, %s mounted", path);
130	- free(key);
131	- free(path);
132	- continue;
133	- }
134	+ if (me)
135	+ next_key = strdup(me->key);
136
137	- if (me)
138	- next_key = strdup(me->key);
139	+ cache_unlock(mc);
140
141	+ cache_writelock(mc);
142	+ this = cache_lookup_distinct(mc, key);
143	+ if (!this) {
144	cache_unlock(mc);
145	+ goto next;
146	+ }
147
148	- cache_writelock(mc);
149	- this = cache_lookup_distinct(mc, key);
150	- if (!this) {
151	- cache_unlock(mc);
152	- goto next;
153	- }
154	-
155	- if (!is_mounted(_PROC_MOUNTS, path, MNTS_AUTOFS)) {
156	- status = CHE_FAIL;
157	- if (this->ioctlfd == -1)
158	- status = cache_delete(mc, key);
159	- if (status != CHE_FAIL) {
160	- if (ap->type == LKP_INDIRECT) {
161	- if (ap->flags & MOUNT_FLAG_GHOST)
162	- rmdir_path(ap, path, ap->dev);
163	- } else
164	- rmdir_path(ap, path, this->dev);
165	- }
166	+ if (valid)
167	+ cache_delete(mc, key);
168	+ else if (!is_mounted(_PROC_MOUNTS, path, MNTS_AUTOFS)) {
169	+ status = CHE_FAIL;
170	+ if (this->ioctlfd == -1)
171	+ status = cache_delete(mc, key);
172	+ if (status != CHE_FAIL) {
173	+ if (ap->type == LKP_INDIRECT) {
174	+ if (ap->flags & MOUNT_FLAG_GHOST)
175	+ rmdir_path(ap, path, ap->dev);
176	+ } else
177	+ rmdir_path(ap, path, this->dev);
178	}
179	- cache_unlock(mc);
180	+ }
181	+ cache_unlock(mc);
182
183	next:
184	- cache_readlock(mc);
185	- if (next_key) {
186	- me = cache_lookup_distinct(mc, next_key);
187	- free(next_key);
188	- }
189	- free(key);
190	- free(path);
191	+ cache_readlock(mc);
192	+ if (next_key) {
193	+ me = cache_lookup_distinct(mc, next_key);
194	+ free(next_key);
195	}
196	+ free(key);
197	+ free(path);
198	+ }
199	+
200	+ return;
201	+}
202	+
203	+int lookup_prune_cache(struct autofs_point *ap, time_t age)
204	+{
205	+ struct master_mapent *entry = ap->entry;
206	+ struct map_source *map;
207	+
208	+ pthread_cleanup_push(master_source_lock_cleanup, entry);
209	+ master_source_readlock(entry);
210	+
211	+ map = entry->maps;
212	+ while (map) {
213	+ /* Is the map stale */
214	+ if (!map->stale) {
215	+ map = map->next;
216	+ continue;
217	+ }
218	+ pthread_cleanup_push(cache_lock_cleanup, map->mc);
219	+ cache_readlock(map->mc);
220	+ lookup_prune_one_cache(ap, map->mc, age);
221	pthread_cleanup_pop(1);
222	map->stale = 0;
223	map = map->next;
224	@@ -1124,7 +1142,6 @@ struct mapent lookup_source_valid_mapent(struct autofs_point ap, const char *k
225	struct mapent_cache *mc;
226	struct mapent *me = NULL;
227
228	- master_source_readlock(entry);
229	map = entry->maps;
230	while (map) {
231	/*
232	@@ -1147,7 +1164,6 @@ struct mapent lookup_source_valid_mapent(struct autofs_point ap, const char *k
233	cache_unlock(mc);
234	map = map->next;
235	}
236	- master_source_unlock(entry);
237
238	return me;
239	}
240	diff --git a/daemon/state.c b/daemon/state.c
241	index 533e241..84ccba3 100644
242	--- a/daemon/state.c
243	+++ b/daemon/state.c
244	@@ -352,6 +352,68 @@ static void tree_mnts_cleanup(void *arg)
245	return;
246	}
247
248	+static void do_readmap_mount(struct autofs_point ap, struct mnt_list mnts,
249	+ struct map_source map, struct mapent me, time_t now)
250	+{
251	+ struct mapent_cache *nc;
252	+ struct mapent ne, nested, *valid;
253	+
254	+ nc = ap->entry->master->nc;
255	+
256	+ ne = cache_lookup_distinct(nc, me->key);
257	+ if (!ne) {
258	+ nested = cache_partial_match(nc, me->key);
259	+ if (nested) {
260	+ error(ap->logopt,
261	+ "removing invalid nested null entry %s",
262	+ nested->key);
263	+ nested = cache_partial_match(nc, me->key);
264	+ if (nested)
265	+ cache_delete(nc, nested->key);
266	+ }
267	+ }
268	+
269	+ if (me->age < now \|\| (ne && map->master_line > ne->age)) {
270	+ /*
271	+ * The map instance may have changed, such as the map name or
272	+ * the mount options, but the direct map entry may still exist
273	+ * in one of the other maps. If so then update the new cache
274	+ * entry device and inode so we can find it at lookup. Later,
275	+ * the mount for the new cache entry will just update the
276	+ * timeout.
277	+ *
278	+ * TODO: how do we recognise these orphaned map instances. We
279	+ * can't just delete these instances when the cache becomes
280	+ * empty because that is a valid state for a master map entry.
281	+ * This is becuase of the requirement to continue running with
282	+ * an empty cache awaiting a map re-load.
283	+ */
284	+ valid = lookup_source_valid_mapent(ap, me->key, LKP_DISTINCT);
285	+ if (valid) {
286	+ struct mapent_cache *vmc = valid->mc;
287	+ cache_unlock(vmc);
288	+ debug(ap->logopt,
289	+ "updating cache entry for valid direct trigger %s",
290	+ me->key);
291	+ cache_writelock(vmc);
292	+ valid = cache_lookup_distinct(vmc, me->key);
293	+ /* Take over the mount if there is one */
294	+ valid->ioctlfd = me->ioctlfd;
295	+ me->ioctlfd = -1;
296	+ /* Set device and inode number of the new mapent */
297	+ cache_set_ino_index(vmc, me->key, me->dev, me->ino);
298	+ cache_unlock(vmc);
299	+ } else if (!tree_is_mounted(mnts, me->key, MNTS_REAL))
300	+ do_umount_autofs_direct(ap, mnts, me);
301	+ else
302	+ debug(ap->logopt,
303	+ "%s is mounted", me->key);
304	+ } else
305	+ do_mount_autofs_direct(ap, mnts, me);
306	+
307	+ return;
308	+}
309	+
310	static void do_readmap(void arg)
311	{
312	struct autofs_point *ap;
313	@@ -398,7 +460,8 @@ static void do_readmap(void arg)
314	lookup_prune_cache(ap, now);
315	status = lookup_ghost(ap, ap->path);
316	} else {
317	- struct mapent me, ne, *nested;
318	+ struct mapent *me;
319	+
320	mnts = tree_make_mnt_tree(_PROC_MOUNTS, "/");
321	pthread_cleanup_push(tree_mnts_cleanup, mnts);
322	pthread_cleanup_push(master_source_lock_cleanup, ap->entry);
323	@@ -418,31 +481,10 @@ static void do_readmap(void arg)
324	cache_readlock(mc);
325	me = cache_enumerate(mc, NULL);
326	while (me) {
327	- ne = cache_lookup_distinct(nc, me->key);
328	- if (!ne) {
329	- nested = cache_partial_match(nc, me->key);
330	- if (nested) {
331	- error(ap->logopt,
332	- "removing invalid nested null entry %s",
333	- nested->key);
334	- nested = cache_partial_match(nc, me->key);
335	- if (nested)
336	- cache_delete(nc, nested->key);
337	- }
338	- }
339	-
340	- /* TODO: check return of do_... */
341	- if (me->age < now \|\| (ne && map->master_line > ne->age)) {
342	- if (!tree_is_mounted(mnts, me->key, MNTS_REAL))
343	- do_umount_autofs_direct(ap, mnts, me);
344	- else
345	- debug(ap->logopt,
346	- "%s is mounted", me->key);
347	- } else
348	- do_mount_autofs_direct(ap, mnts, me);
349	-
350	+ do_readmap_mount(ap, mnts, map, me, now);
351	me = cache_enumerate(mc, me);
352	}
353	+ lookup_prune_one_cache(ap, map->mc, now);
354	pthread_cleanup_pop(1);
355	map->stale = 0;
356	map = map->next;
357	diff --git a/include/automount.h b/include/automount.h
358	index d4675bd..ae517a7 100644
359	--- a/include/automount.h
360	+++ b/include/automount.h
361	@@ -238,6 +238,7 @@ int lookup_enumerate(struct autofs_point *ap,
362	int lookup_ghost(struct autofs_point ap, const char root);
363	int lookup_nss_mount(struct autofs_point ap, struct map_source source, const char *name, int name_len);
364	void lookup_close_lookup(struct autofs_point *ap);
365	+void lookup_prune_one_cache(struct autofs_point ap, struct mapent_cache mc, time_t age);
366	int lookup_prune_cache(struct autofs_point *ap, time_t age);
367	struct mapent lookup_source_valid_mapent(struct autofs_point ap, const char *key, unsigned int type);
368	struct mapent lookup_source_mapent(struct autofs_point ap, const char *key, unsigned int type);