[packages/autofs.git] / autofs-5.0.4-fix-negative-cache-non-existent-key.patch

autofs-5.0.4 - fix negative cache non-existent key

From: Ian Kent <raven@themaw.net>

autofs was not recording map entries that don't exist for negative
caching. This was causing unwanted network map lookups.
---

 CHANGELOG                |    1 +
 daemon/lookup.c          |   48 ++++++++++++++++++++++++++++++++++++++++++++--
 modules/lookup_file.c    |   20 ++++++++++++-------
 modules/lookup_hosts.c   |   21 ++++++++++++++++----
 modules/lookup_ldap.c    |   20 ++++++++++++-------
 modules/lookup_nisplus.c |   19 ++++++++++++------
 modules/lookup_program.c |   35 ++++++++++++++++++++++++++--------
 modules/lookup_yp.c      |   19 ++++++++++++------
 8 files changed, 143 insertions(+), 40 deletions(-)


diff --git a/CHANGELOG b/CHANGELOG
index 88ca579..bd35b00 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -2,6 +2,7 @@
 -----------------------
 - fix dumb libxml2 check
 - fix nested submount expire deadlock.
+- fix negative caching for non-existent map keys.
 
 4/11/2008 autofs-5.0.4
 -----------------------
diff --git a/daemon/lookup.c b/daemon/lookup.c
index 803df4f..0cf6e3f 100644
--- a/daemon/lookup.c
+++ b/daemon/lookup.c
@@ -804,6 +804,45 @@ static enum nsswitch_status lookup_map_name(struct nss_source *this,
 	return result;
 }
 
+static void update_negative_cache(struct autofs_point *ap, struct map_source *source, const char *name)
+{
+	struct master_mapent *entry = ap->entry;
+	struct map_source *map;
+	struct mapent *me;
+
+	/* Have we recorded the lookup fail for negative caching? */
+	me = lookup_source_mapent(ap, name, LKP_DISTINCT);
+	if (me)
+		/*
+		 *  Already exists in the cache, the mount fail updates
+		 *  will update negative timeout status.
+		 */
+		cache_unlock(me->mc);
+	else {
+		/* Notify only once after fail */
+		error(ap->logopt, "key \"%s\" not found in map.", name);
+
+		/* Doesn't exist in any source, just add it somewhere */
+		if (source)
+			map = source;
+		else
+			map = entry->maps;
+		if (map) {
+			time_t now = time(NULL);
+			int rv = CHE_FAIL;
+
+			cache_writelock(map->mc);
+			rv = cache_update(map->mc, map, name, NULL, now);
+			if (rv != CHE_FAIL) {
+				me = cache_lookup_distinct(map->mc, name);
+				me->status = now + ap->negative_timeout;
+			}
+			cache_unlock(map->mc);
+		}
+	}
+	return;
+}
+
 int lookup_nss_mount(struct autofs_point *ap, struct map_source *source, const char *name, int name_len)
 {
 	struct master_mapent *entry = ap->entry;
@@ -907,8 +946,13 @@ int lookup_nss_mount(struct autofs_point *ap, struct map_source *source, const c
 		send_map_update_request(ap);
 	pthread_cleanup_pop(1);
 
-	if (result == NSS_STATUS_NOTFOUND)
-		error(ap->logopt, "key \"%s\" not found in map.", name);
+	/*
+	 * The last source lookup will return NSS_STATUS_NOTFOUND if the
+	 * map exits and the key has not been found but the map may also
+	 * not exist in which case the key is also not found.
+	 */
+	if (result == NSS_STATUS_NOTFOUND || result == NSS_STATUS_UNAVAIL)
+		update_negative_cache(ap, source, name);
 
 	return !result;
 }
diff --git a/modules/lookup_file.c b/modules/lookup_file.c
index 807ceab..9e34b72 100644
--- a/modules/lookup_file.c
+++ b/modules/lookup_file.c
@@ -1069,14 +1069,20 @@ int lookup_mount(struct autofs_point *ap, const char *name, int name_len, void *
 	if (key_len > KEY_MAX_LEN)
 		return NSS_STATUS_NOTFOUND;
 
-	/* Check if we recorded a mount fail for this key */
-	cache_readlock(mc);
-	me = cache_lookup_distinct(mc, key);
-	if (me && me->status >= time(NULL)) {
-		cache_unlock(mc);
-		return NSS_STATUS_UNAVAIL;
+	/* Check if we recorded a mount fail for this key anywhere */
+	me = lookup_source_mapent(ap, key, LKP_DISTINCT);
+	if (me) {
+		if (me->status >= time(NULL)) {
+			cache_unlock(me->mc);
+			return NSS_STATUS_NOTFOUND;
+		}
+
+		/* Negative timeout expired for non-existent entry. */
+		if (!me->mapent)
+			cache_delete(me->mc, key);
+
+		cache_unlock(me->mc);
 	}
-	cache_unlock(mc);
 
 	/*
 	 * We can't check the direct mount map as if it's not in
diff --git a/modules/lookup_hosts.c b/modules/lookup_hosts.c
index bf24d7f..f8d4269 100644
--- a/modules/lookup_hosts.c
+++ b/modules/lookup_hosts.c
@@ -136,12 +136,25 @@ int lookup_mount(struct autofs_point *ap, const char *name, int name_len, void *
 
 	mc = source->mc;
 
+	/* Check if we recorded a mount fail for this key anywhere */
+	me = lookup_source_mapent(ap, name, LKP_DISTINCT);
+	if (me) {
+		if (me->status >= time(NULL)) {
+			cache_unlock(me->mc);
+			return NSS_STATUS_NOTFOUND;
+		}
+
+		if (!me->mapent) {
+			cache_delete(me->mc, name);
+			me = NULL;
+		}
+
+		cache_unlock(me->mc);
+	}
+
 	cache_readlock(mc);
 	me = cache_lookup_distinct(mc, name);
-	if (me && me->status >= time(NULL)) {
-		cache_unlock(mc);
-		return NSS_STATUS_NOTFOUND;
-	} else if (!me) {
+	if (!me) {
 		cache_unlock(mc);
 		/*
 		 * We haven't read the list of hosts into the
diff --git a/modules/lookup_ldap.c b/modules/lookup_ldap.c
index 31c2c13..42c3235 100644
--- a/modules/lookup_ldap.c
+++ b/modules/lookup_ldap.c
@@ -2709,14 +2709,20 @@ int lookup_mount(struct autofs_point *ap, const char *name, int name_len, void *
 	if (key_len > KEY_MAX_LEN)
 		return NSS_STATUS_NOTFOUND;
 
-	/* Check if we recorded a mount fail for this key */
-	cache_readlock(mc);
-	me = cache_lookup_distinct(mc, key);
-	if (me && me->status >= time(NULL)) {
-		cache_unlock(mc);
-		return NSS_STATUS_NOTFOUND;
+	/* Check if we recorded a mount fail for this key anywhere */
+	me = lookup_source_mapent(ap, key, LKP_DISTINCT);
+	if (me) {
+		if (me->status >= time(NULL)) {
+			cache_unlock(me->mc);
+			return NSS_STATUS_NOTFOUND;
+		}
+
+		/* Negative timeout expired for non-existent entry. */
+		if (!me->mapent)
+			cache_delete(me->mc, key);
+
+		cache_unlock(me->mc);
 	}
-	cache_unlock(mc);
 
         /*
 	 * We can't check the direct mount map as if it's not in
diff --git a/modules/lookup_nisplus.c b/modules/lookup_nisplus.c
index 755556d..f15465f 100644
--- a/modules/lookup_nisplus.c
+++ b/modules/lookup_nisplus.c
@@ -493,13 +493,20 @@ int lookup_mount(struct autofs_point *ap, const char *name, int name_len, void *
 	if (key_len > KEY_MAX_LEN)
 		return NSS_STATUS_NOTFOUND;
 
-	cache_readlock(mc);
-	me = cache_lookup_distinct(mc, key);
-	if (me && me->status >= time(NULL)) {
-		cache_unlock(mc);
-		return NSS_STATUS_NOTFOUND;
+	/* Check if we recorded a mount fail for this key anywhere */
+	me = lookup_source_mapent(ap, key, LKP_DISTINCT);
+	if (me) {
+		if (me->status >= time(NULL)) {
+			cache_unlock(me->mc);
+			return NSS_STATUS_NOTFOUND;
+		}
+
+		/* Negative timeout expired for non-existent entry. */
+		if (!me->mapent)
+			cache_delete(me->mc, key);
+
+		cache_unlock(me->mc);
 	}
-	cache_unlock(mc);
 
 	/*
 	 * We can't check the direct mount map as if it's not in
diff --git a/modules/lookup_program.c b/modules/lookup_program.c
index daf874d..bf32d3b 100644
--- a/modules/lookup_program.c
+++ b/modules/lookup_program.c
@@ -131,13 +131,25 @@ int lookup_mount(struct autofs_point *ap, const char *name, int name_len, void *
 
 	mc = source->mc;
 
+	/* Check if we recorded a mount fail for this key anywhere */
+	me = lookup_source_mapent(ap, name, LKP_DISTINCT);
+	if (me) {
+		if (me->status >= time(NULL)) {
+			cache_unlock(me->mc);
+			return NSS_STATUS_NOTFOUND;
+		}
+
+		/* Negative timeout expired for non-existent entry. */
+		if (!me->mapent)
+			cache_delete(me->mc, name);
+
+		cache_unlock(me->mc);
+	}
+
 	/* Catch installed direct offset triggers */
-	cache_readlock(mc);
+	cache_writelock(mc);
 	me = cache_lookup_distinct(mc, name);
-	if (me && me->status >= time(NULL)) {
-		cache_unlock(mc);
-		return NSS_STATUS_NOTFOUND;
-	} else if (!me) {
+	if (!me) {
 		cache_unlock(mc);
 		/*
 		 * If there's a '/' in the name and the offset is not in
@@ -149,8 +161,6 @@ int lookup_mount(struct autofs_point *ap, const char *name, int name_len, void *
 			return NSS_STATUS_NOTFOUND;
 		}
 	} else {
-		cache_unlock(mc);
-
 		/* Otherwise we found a valid offset so try mount it */
 		debug(ap->logopt, MODPREFIX "%s -> %s", name, me->mapent);
 
@@ -163,19 +173,28 @@ int lookup_mount(struct autofs_point *ap, const char *name, int name_len, void *
 		 */
 		if (strchr(name, '/') ||
 		    me->age + ap->negative_timeout > time(NULL)) {
+			char *ent = NULL;
+
+			if (me->mapent) {
+				ent = alloca(strlen(me->mapent) + 1);
+				strcpy(ent, me->mapent);
+			}
+			cache_unlock(mc);
 			master_source_current_wait(ap->entry);
 			ap->entry->current = source;
 			ret = ctxt->parse->parse_mount(ap, name,
-				 name_len, me->mapent, ctxt->parse->context);
+				 name_len, ent, ctxt->parse->context);
 			goto out_free;
 		} else {
 			if (me->multi) {
+				cache_unlock(mc);
 				warn(ap->logopt, MODPREFIX
 				     "unexpected lookup for active multi-mount"
 				     " key %s, returning fail", name);
 				return NSS_STATUS_UNAVAIL;
 			}
 			cache_delete(mc, name);
+			cache_unlock(mc);
 		}
 	}
 
diff --git a/modules/lookup_yp.c b/modules/lookup_yp.c
index 8b6408b..1b62f57 100644
--- a/modules/lookup_yp.c
+++ b/modules/lookup_yp.c
@@ -603,13 +603,20 @@ int lookup_mount(struct autofs_point *ap, const char *name, int name_len, void *
 	if (key_len > KEY_MAX_LEN)
 		return NSS_STATUS_NOTFOUND;
 
-	cache_readlock(mc);
-	me = cache_lookup_distinct(mc, key);
-	if (me && me->status >= time(NULL)) {
-		cache_unlock(mc);
-		return NSS_STATUS_NOTFOUND;
+	/* Check if we recorded a mount fail for this key anywhere */
+	me = lookup_source_mapent(ap, key, LKP_DISTINCT);
+	if (me) {
+		if (me->status >= time(NULL)) {
+			cache_unlock(me->mc);
+			return NSS_STATUS_NOTFOUND;
+		}
+
+		/* Negative timeout expired for non-existent entry. */
+		if (!me->mapent)
+			cache_delete(me->mc, key);
+
+		cache_unlock(me->mc);
 	}
-	cache_unlock(mc);
 
 	 /*
 	  * We can't check the direct mount map as if it's not in
Commit	Line	Data
e5fd101c PS	1	autofs-5.0.4 - fix negative cache non-existent key
	2
	3	From: Ian Kent <raven@themaw.net>
	4
	5	autofs was not recording map entries that don't exist for negative
	6	caching. This was causing unwanted network map lookups.
	7	---
	8
	9	CHANGELOG \| 1 +
	10	daemon/lookup.c \| 48 ++++++++++++++++++++++++++++++++++++++++++++--
	11	modules/lookup_file.c \| 20 ++++++++++++-------
	12	modules/lookup_hosts.c \| 21 ++++++++++++++++----
	13	modules/lookup_ldap.c \| 20 ++++++++++++-------
	14	modules/lookup_nisplus.c \| 19 ++++++++++++------
	15	modules/lookup_program.c \| 35 ++++++++++++++++++++++++++--------
	16	modules/lookup_yp.c \| 19 ++++++++++++------
	17	8 files changed, 143 insertions(+), 40 deletions(-)
	18
	19
	20	diff --git a/CHANGELOG b/CHANGELOG
	21	index 88ca579..bd35b00 100644
	22	--- a/CHANGELOG
	23	+++ b/CHANGELOG
	24	@@ -2,6 +2,7 @@
	25	-----------------------
	26	- fix dumb libxml2 check
	27	- fix nested submount expire deadlock.
	28	+- fix negative caching for non-existent map keys.
	29
	30	4/11/2008 autofs-5.0.4
	31	-----------------------
	32	diff --git a/daemon/lookup.c b/daemon/lookup.c
	33	index 803df4f..0cf6e3f 100644
	34	--- a/daemon/lookup.c
	35	+++ b/daemon/lookup.c
	36	@@ -804,6 +804,45 @@ static enum nsswitch_status lookup_map_name(struct nss_source *this,
	37	return result;
	38	}
	39
	40	+static void update_negative_cache(struct autofs_point ap, struct map_source source, const char *name)
	41	+{
	42	+ struct master_mapent *entry = ap->entry;
	43	+ struct map_source *map;
	44	+ struct mapent *me;
	45	+
	46	+ /* Have we recorded the lookup fail for negative caching? */
	47	+ me = lookup_source_mapent(ap, name, LKP_DISTINCT);
	48	+ if (me)
	49	+ /*
	50	+ * Already exists in the cache, the mount fail updates
	51	+ * will update negative timeout status.
	52	+ */
	53	+ cache_unlock(me->mc);
	54	+ else {
	55	+ /* Notify only once after fail */
	56	+ error(ap->logopt, "key \"%s\" not found in map.", name);
	57	+
	58	+ /* Doesn't exist in any source, just add it somewhere */
	59	+ if (source)
	60	+ map = source;
	61	+ else
	62	+ map = entry->maps;
	63	+ if (map) {
	64	+ time_t now = time(NULL);
65	+ int rv = CHE_FAIL;
66	+
67	+ cache_writelock(map->mc);
68	+ rv = cache_update(map->mc, map, name, NULL, now);
69	+ if (rv != CHE_FAIL) {
70	+ me = cache_lookup_distinct(map->mc, name);
71	+ me->status = now + ap->negative_timeout;
72	+ }
73	+ cache_unlock(map->mc);
74	+ }
75	+ }
76	+ return;
77	+}
78	+
79	int lookup_nss_mount(struct autofs_point ap, struct map_source source, const char *name, int name_len)
80	{
81	struct master_mapent *entry = ap->entry;
82	@@ -907,8 +946,13 @@ int lookup_nss_mount(struct autofs_point ap, struct map_source source, const c
83	send_map_update_request(ap);
84	pthread_cleanup_pop(1);
85
86	- if (result == NSS_STATUS_NOTFOUND)
87	- error(ap->logopt, "key \"%s\" not found in map.", name);
88	+ /*
89	+ * The last source lookup will return NSS_STATUS_NOTFOUND if the
90	+ * map exits and the key has not been found but the map may also
91	+ * not exist in which case the key is also not found.
92	+ */
93	+ if (result == NSS_STATUS_NOTFOUND \|\| result == NSS_STATUS_UNAVAIL)
94	+ update_negative_cache(ap, source, name);
95
96	return !result;
97	}
98	diff --git a/modules/lookup_file.c b/modules/lookup_file.c
99	index 807ceab..9e34b72 100644
100	--- a/modules/lookup_file.c
101	+++ b/modules/lookup_file.c
102	@@ -1069,14 +1069,20 @@ int lookup_mount(struct autofs_point ap, const char name, int name_len, void *
103	if (key_len > KEY_MAX_LEN)
104	return NSS_STATUS_NOTFOUND;
105
106	- /* Check if we recorded a mount fail for this key */
107	- cache_readlock(mc);
108	- me = cache_lookup_distinct(mc, key);
109	- if (me && me->status >= time(NULL)) {
110	- cache_unlock(mc);
111	- return NSS_STATUS_UNAVAIL;
112	+ /* Check if we recorded a mount fail for this key anywhere */
113	+ me = lookup_source_mapent(ap, key, LKP_DISTINCT);
114	+ if (me) {
115	+ if (me->status >= time(NULL)) {
116	+ cache_unlock(me->mc);
117	+ return NSS_STATUS_NOTFOUND;
118	+ }
119	+
120	+ /* Negative timeout expired for non-existent entry. */
121	+ if (!me->mapent)
122	+ cache_delete(me->mc, key);
123	+
124	+ cache_unlock(me->mc);
125	}
126	- cache_unlock(mc);
127
128	/*
129	* We can't check the direct mount map as if it's not in
130	diff --git a/modules/lookup_hosts.c b/modules/lookup_hosts.c
131	index bf24d7f..f8d4269 100644
132	--- a/modules/lookup_hosts.c
133	+++ b/modules/lookup_hosts.c
134	@@ -136,12 +136,25 @@ int lookup_mount(struct autofs_point ap, const char name, int name_len, void *
135
136	mc = source->mc;
137
138	+ /* Check if we recorded a mount fail for this key anywhere */
139	+ me = lookup_source_mapent(ap, name, LKP_DISTINCT);
140	+ if (me) {
141	+ if (me->status >= time(NULL)) {
142	+ cache_unlock(me->mc);
143	+ return NSS_STATUS_NOTFOUND;
144	+ }
145	+
146	+ if (!me->mapent) {
147	+ cache_delete(me->mc, name);
148	+ me = NULL;
149	+ }
150	+
151	+ cache_unlock(me->mc);
152	+ }
153	+
154	cache_readlock(mc);
155	me = cache_lookup_distinct(mc, name);
156	- if (me && me->status >= time(NULL)) {
157	- cache_unlock(mc);
158	- return NSS_STATUS_NOTFOUND;
159	- } else if (!me) {
160	+ if (!me) {
161	cache_unlock(mc);
162	/*
163	* We haven't read the list of hosts into the
164	diff --git a/modules/lookup_ldap.c b/modules/lookup_ldap.c
165	index 31c2c13..42c3235 100644
166	--- a/modules/lookup_ldap.c
167	+++ b/modules/lookup_ldap.c
168	@@ -2709,14 +2709,20 @@ int lookup_mount(struct autofs_point ap, const char name, int name_len, void *
169	if (key_len > KEY_MAX_LEN)
170	return NSS_STATUS_NOTFOUND;
171
172	- /* Check if we recorded a mount fail for this key */
173	- cache_readlock(mc);
174	- me = cache_lookup_distinct(mc, key);
175	- if (me && me->status >= time(NULL)) {
176	- cache_unlock(mc);
177	- return NSS_STATUS_NOTFOUND;
178	+ /* Check if we recorded a mount fail for this key anywhere */
179	+ me = lookup_source_mapent(ap, key, LKP_DISTINCT);
180	+ if (me) {
181	+ if (me->status >= time(NULL)) {
182	+ cache_unlock(me->mc);
183	+ return NSS_STATUS_NOTFOUND;
184	+ }
185	+
186	+ /* Negative timeout expired for non-existent entry. */
187	+ if (!me->mapent)
188	+ cache_delete(me->mc, key);
189	+
190	+ cache_unlock(me->mc);
191	}
192	- cache_unlock(mc);
193
194	/*
195	* We can't check the direct mount map as if it's not in
196	diff --git a/modules/lookup_nisplus.c b/modules/lookup_nisplus.c
197	index 755556d..f15465f 100644
198	--- a/modules/lookup_nisplus.c
199	+++ b/modules/lookup_nisplus.c
200	@@ -493,13 +493,20 @@ int lookup_mount(struct autofs_point ap, const char name, int name_len, void *
201	if (key_len > KEY_MAX_LEN)
202	return NSS_STATUS_NOTFOUND;
203
204	- cache_readlock(mc);
205	- me = cache_lookup_distinct(mc, key);
206	- if (me && me->status >= time(NULL)) {
207	- cache_unlock(mc);
208	- return NSS_STATUS_NOTFOUND;
209	+ /* Check if we recorded a mount fail for this key anywhere */
210	+ me = lookup_source_mapent(ap, key, LKP_DISTINCT);
211	+ if (me) {
212	+ if (me->status >= time(NULL)) {
213	+ cache_unlock(me->mc);
214	+ return NSS_STATUS_NOTFOUND;
215	+ }
216	+
217	+ /* Negative timeout expired for non-existent entry. */
218	+ if (!me->mapent)
219	+ cache_delete(me->mc, key);
220	+
221	+ cache_unlock(me->mc);
222	}
223	- cache_unlock(mc);
224
225	/*
226	* We can't check the direct mount map as if it's not in
227	diff --git a/modules/lookup_program.c b/modules/lookup_program.c
228	index daf874d..bf32d3b 100644
229	--- a/modules/lookup_program.c
230	+++ b/modules/lookup_program.c
231	@@ -131,13 +131,25 @@ int lookup_mount(struct autofs_point ap, const char name, int name_len, void *
232
233	mc = source->mc;
234
235	+ /* Check if we recorded a mount fail for this key anywhere */
236	+ me = lookup_source_mapent(ap, name, LKP_DISTINCT);
237	+ if (me) {
238	+ if (me->status >= time(NULL)) {
239	+ cache_unlock(me->mc);
240	+ return NSS_STATUS_NOTFOUND;
241	+ }
242	+
243	+ /* Negative timeout expired for non-existent entry. */
244	+ if (!me->mapent)
245	+ cache_delete(me->mc, name);
246	+
247	+ cache_unlock(me->mc);
248	+ }
249	+
250	/* Catch installed direct offset triggers */
251	- cache_readlock(mc);
252	+ cache_writelock(mc);
253	me = cache_lookup_distinct(mc, name);
254	- if (me && me->status >= time(NULL)) {
255	- cache_unlock(mc);
256	- return NSS_STATUS_NOTFOUND;
257	- } else if (!me) {
258	+ if (!me) {
259	cache_unlock(mc);
260	/*
261	* If there's a '/' in the name and the offset is not in
262	@@ -149,8 +161,6 @@ int lookup_mount(struct autofs_point ap, const char name, int name_len, void *
263	return NSS_STATUS_NOTFOUND;
264	}
265	} else {
266	- cache_unlock(mc);
267	-
268	/* Otherwise we found a valid offset so try mount it */
269	debug(ap->logopt, MODPREFIX "%s -> %s", name, me->mapent);
270
271	@@ -163,19 +173,28 @@ int lookup_mount(struct autofs_point ap, const char name, int name_len, void *
272	*/
273	if (strchr(name, '/') \|\|
274	me->age + ap->negative_timeout > time(NULL)) {
275	+ char *ent = NULL;
276	+
277	+ if (me->mapent) {
278	+ ent = alloca(strlen(me->mapent) + 1);
279	+ strcpy(ent, me->mapent);
280	+ }
281	+ cache_unlock(mc);
282	master_source_current_wait(ap->entry);
283	ap->entry->current = source;
284	ret = ctxt->parse->parse_mount(ap, name,
285	- name_len, me->mapent, ctxt->parse->context);
286	+ name_len, ent, ctxt->parse->context);
287	goto out_free;
288	} else {
289	if (me->multi) {
290	+ cache_unlock(mc);
291	warn(ap->logopt, MODPREFIX
292	"unexpected lookup for active multi-mount"
293	" key %s, returning fail", name);
294	return NSS_STATUS_UNAVAIL;
295	}
296	cache_delete(mc, name);
297	+ cache_unlock(mc);
298	}
299	}
300
301	diff --git a/modules/lookup_yp.c b/modules/lookup_yp.c
302	index 8b6408b..1b62f57 100644
303	--- a/modules/lookup_yp.c
304	+++ b/modules/lookup_yp.c
305	@@ -603,13 +603,20 @@ int lookup_mount(struct autofs_point ap, const char name, int name_len, void *
306	if (key_len > KEY_MAX_LEN)
307	return NSS_STATUS_NOTFOUND;
308
309	- cache_readlock(mc);
310	- me = cache_lookup_distinct(mc, key);
311	- if (me && me->status >= time(NULL)) {
312	- cache_unlock(mc);
313	- return NSS_STATUS_NOTFOUND;
314	+ /* Check if we recorded a mount fail for this key anywhere */
315	+ me = lookup_source_mapent(ap, key, LKP_DISTINCT);
316	+ if (me) {
317	+ if (me->status >= time(NULL)) {
318	+ cache_unlock(me->mc);
319	+ return NSS_STATUS_NOTFOUND;
320	+ }
321	+
322	+ /* Negative timeout expired for non-existent entry. */
323	+ if (!me->mapent)
324	+ cache_delete(me->mc, key);
325	+
326	+ cache_unlock(me->mc);
327	}
328	- cache_unlock(mc);
329
330	/*
331	* We can't check the direct mount map as if it's not in