autofs-5.0.3 - fix submount shutdown handling.

From: Ian Kent <raven@themaw.net>

When using submount maps on a busy system autofs can hang.

This problem comes about because of processes walking into the

submount filesystem when it is in the process of shutting down.

While this race has been fixed for other types of mounts it

still isn't possible to to block processes from walking into

submounts that are expiring so we need to be able to recover

when this happens.

This patch improves the submount shutdown logic and allows

submounts that become busy during shutdown to recover.

---

 CHANGELOG              |    1 

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

 daemon/direct.c        |   97 ++++++++++++++------

 daemon/indirect.c      |  114 ++++++++++++++++++-----

 daemon/lookup.c        |   11 --

 daemon/state.c         |  235 +++++++++++++++++++++++++++++++++---------------

 include/automount.h    |   17 ---

 include/master.h       |    5 -

 include/state.h        |    9 ++

 lib/alarm.c            |   14 ---

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

 modules/mount_autofs.c |    2 

 12 files changed, 458 insertions(+), 435 deletions(-)

diff --git a/CHANGELOG b/CHANGELOG

index 9da7be3..ff04985 100644

--- a/CHANGELOG

+++ b/CHANGELOG

@@ -26,6 +26,7 @@

 - add command line option to override check for daemon already running.

 - don't use proc file system when checking if the daemon is running.

 - make handle_mounts startup condition distinct.

+- fix submount shutdown recovery handling.

 14/01/2008 autofs-5.0.3

 -----------------------

diff --git a/daemon/automount.c b/daemon/automount.c

index 086affb..68bf1d3 100644

--- a/daemon/automount.c

+++ b/daemon/automount.c

@@ -369,6 +369,18 @@ int count_mounts(unsigned logopt, const char *path, dev_t dev)

 static void check_rm_dirs(struct autofs_point *ap, const char *path, int incl)

 {

+	/*

+	 * If we're a submount the kernel can't know we're trying to

+	 * shutdown and so cannot block processes walking into the

+	 * mount point directory. If this is the call to umount_multi()

+	 * made during shutdown (incl == 0) we have to leave any mount

+	 * point directories in place so we can recover if needed. The

+	 * umount itself will clean these directories up for us

+	 * automagically.

+	 */

+	if (!incl && ap->submount)

+		return;

+

 	if ((!ap->ghost) ||

 	    (ap->state == ST_SHUTDOWN_PENDING ||

 	     ap->state == ST_SHUTDOWN_FORCE ||

@@ -390,8 +402,6 @@ static void update_map_cache(struct autofs_point *ap, const char *path)

 	else

 		key = path;

-	pthread_cleanup_push(master_source_lock_cleanup, ap->entry);

-	master_source_readlock(ap->entry);

 	map = ap->entry->maps;

 	while (map) {

 		struct mapent *me = NULL;

@@ -413,7 +423,6 @@ static void update_map_cache(struct autofs_point *ap, const char *path)

 		map = map->next;

 	}

-	pthread_cleanup_pop(1);

 	return;

 }

@@ -918,38 +927,22 @@ static int get_pkt(struct autofs_point *ap, union autofs_v5_packet_union *pkt)

 		}

 		if (fds[1].revents & POLLIN) {

-			enum states next_state, post_state;

+			enum states next_state;

 			size_t read_size = sizeof(next_state);

 			int state_pipe;

-			next_state = post_state = ST_INVAL;

+			next_state = ST_INVAL;

-			state_mutex_lock(ap);

+			st_mutex_lock();

 			state_pipe = ap->state_pipe[0];

 			if (fullread(state_pipe, &next_state, read_size)) {

-				state_mutex_unlock(ap);

+				st_mutex_unlock();

 				continue;

 			}

-			if (next_state != ST_INVAL && next_state != ap->state) {

-				if (next_state != ST_SHUTDOWN)

-					post_state = next_state;

-				else

-					ap->state = ST_SHUTDOWN;

-			}

-

-			state_mutex_unlock(ap);

-

-			if (post_state != ST_INVAL) {

-				if (post_state == ST_SHUTDOWN_PENDING ||

-				    post_state == ST_SHUTDOWN_FORCE) {

-					alarm_delete(ap);

-					st_remove_tasks(ap);

-				}

-				st_add_task(ap, post_state);

-			}

+			st_mutex_unlock();

 			if (next_state == ST_SHUTDOWN)

 				return -1;

@@ -985,11 +978,14 @@ int do_expire(struct autofs_point *ap, const char *name, int namelen)

 	info(ap->logopt, "expiring path %s", buf);

+	pthread_cleanup_push(master_source_lock_cleanup, ap->entry);

+	master_source_readlock(ap->entry);

 	ret = umount_multi(ap, buf, 1);

 	if (ret == 0)

 		info(ap->logopt, "expired %s", buf);

 	else

 		warn(ap->logopt, "couldn't complete expire of %s", buf);

+	pthread_cleanup_pop(1);

 	return ret;

 }

@@ -1069,7 +1065,7 @@ static int mount_autofs(struct autofs_point *ap)

 	if (status < 0)

 		return -1;

-	ap->state = ST_READY;

+	st_add_task(ap, ST_READY);

 	return 0;

 }

@@ -1423,44 +1419,6 @@ static void return_start_status(void *arg)

 		fatal(status);

 }

-static void mutex_operation_wait(pthread_mutex_t *mutex)

-{

-	int status;

-

-	/*

-	 * Unlock a mutex, but wait for a pending operation

-	 * if one is in progress

-	 */

-	status = pthread_mutex_trylock(mutex);

-	if (status) {

-		if (status == EBUSY) {

-			/* Mutex locked - do we own it */

-			status = pthread_mutex_unlock(mutex);

-			if (status) {

-				if (status != EPERM)

-					fatal(status);

-			} else

-				return;

-

-			status = pthread_mutex_lock(mutex);

-			if (status)

-				fatal(status);

-		} else

-			fatal(status);

-

-		/* Operation complete, release it */

-		status = pthread_mutex_unlock(mutex);

-		if (status)

-			fatal(status);

-	} else {

-		status = pthread_mutex_unlock(mutex);

-		if (status)

-			fatal(status);

-	}

-

-	return;

-}

-

 int handle_mounts_startup_cond_init(struct startup_cond *suc)

 {

 	int status;

@@ -1526,22 +1484,25 @@ static void handle_mounts_cleanup(void *arg)

 	if (!submount && strcmp(ap->path, "/-") && ap->dir_created)

 		clean = 1;

-	/* If we have been canceled then we may hold the state mutex. */

-	mutex_operation_wait(&ap->state_mutex);

+	if (submount) {

+		/* We are finishing up */

+		ap->parent->submnt_count--;

+		list_del_init(&ap->mounts);

+	}

-	alarm_delete(ap);

-	st_remove_tasks(ap);

+	master_remove_mapent(ap->entry);

+	master_source_unlock(ap->entry);

-	umount_autofs(ap, 1);

+	if (submount) {

+		mounts_mutex_unlock(ap->parent);

+		master_source_unlock(ap->parent->entry);

+	}

+	master_mutex_unlock();

 	destroy_logpri_fifo(ap);

-	master_signal_submount(ap, MASTER_SUBMNT_JOIN);

-	master_remove_mapent(ap->entry);

 	master_free_mapent_sources(ap->entry, 1);

 	master_free_mapent(ap->entry);

-	sched_yield();

-

 	if (clean) {

 		if (rmdir(path) == -1) {

 			char *estr = strerror_r(errno, buf, MAX_ERR_BUF);

@@ -1572,8 +1533,6 @@ void *handle_mounts(void *arg)

 	pthread_cleanup_push(return_start_status, suc);

 	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cancel_state);

-	state_mutex_lock(ap);

-

 	status = pthread_mutex_lock(&suc->mutex);

 	if (status) {

 		logerr("failed to lock startup condition mutex!");

@@ -1583,7 +1542,6 @@ void *handle_mounts(void *arg)

 	if (mount_autofs(ap) < 0) {

 		crit(ap->logopt, "mount of %s failed!", ap->path);

 		suc->status = 1;

-		state_mutex_unlock(ap);

 		umount_autofs(ap, 1);

 		pthread_setcancelstate(cancel_state, NULL);

 		pthread_exit(NULL);

@@ -1600,56 +1558,70 @@ void *handle_mounts(void *arg)

 	if (!ap->submount && ap->exp_timeout)

 		alarm_add(ap, ap->exp_runfreq + rand() % ap->exp_runfreq);

-	pthread_cleanup_push(handle_mounts_cleanup, ap);

 	pthread_setcancelstate(cancel_state, NULL);

-	state_mutex_unlock(ap);

-

 	while (ap->state != ST_SHUTDOWN) {

 		if (handle_packet(ap)) {

-			int ret, result;

+			int ret, cur_state;

+

+			/*

+			 * If we're a submount we need to ensure our parent

+			 * doesn't try to mount us again until our shutdown

+			 * is complete and that any outstanding mounts are

+			 * completed before we try to shutdown.

+			 */

+			pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cur_state);

+

+			master_mutex_lock();

+

+			if (ap->submount) {

+				master_source_writelock(ap->parent->entry);

+				mounts_mutex_lock(ap->parent);

+			}

+

+			master_source_writelock(ap->entry);

+

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

+				if (!ap->submount)

+					alarm_add(ap, ap->exp_runfreq);

+				/* Return to ST_READY is done immediately */

+				st_add_task(ap, ST_READY);

+				master_source_unlock(ap->entry);

+				if (ap->submount) {

+					mounts_mutex_unlock(ap->parent);

+					master_source_unlock(ap->parent->entry);

+				}

+

+				master_mutex_unlock();

+

+				pthread_setcancelstate(cur_state, NULL);

+				continue;

+			}

+

+			alarm_delete(ap);

+			st_remove_tasks(ap);

+			st_wait_task(ap, ST_ANY, 0);

-			state_mutex_lock(ap);

 			/*

 			 * For a direct mount map all mounts have already gone

-			 * by the time we get here.

+			 * by the time we get here and since we only ever

+			 * umount direct mounts at shutdown there is no need

+			 * to check for possible recovery.

 			 */

 			if (ap->type == LKP_DIRECT) {

-				status = 1;

-				state_mutex_unlock(ap);

+				umount_autofs(ap, 1);

 				break;

 			}

 			/*

-			 * If the ioctl fails assume the kernel doesn't have

-			 * AUTOFS_IOC_ASKUMOUNT and just continue.

+			 * If umount_autofs returns non-zero it wasn't able

+			 * to complete the umount and has left the mount intact

+			 * so we can continue. This can happen if a lookup

+			 * occurs while we're trying to umount.

 			 */

-			ret = ioctl(ap->ioctlfd, AUTOFS_IOC_ASKUMOUNT, &result);

-			if (ret == -1) {

-				state_mutex_unlock(ap);

+			ret = umount_autofs(ap, 1);

+			if (!ret)

 				break;

-			}

-

-			/* OK to exit */

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

-				if (result) {

-					state_mutex_unlock(ap);

-					break;

-				}

-#ifdef ENABLE_IGNORE_BUSY_MOUNTS

-				/*

-				 * There weren't any active mounts but if the

-				 * filesystem is busy there may be a mount

-				 * request in progress so return to the ready

-				 * state unless a shutdown has been explicitly

-				 * requested.

-				 */

-				if (ap->shutdown) {

-					state_mutex_unlock(ap);

-					break;

-				}

-#endif

-			}

 			/* Failed shutdown returns to ready */

 			warn(ap->logopt,

@@ -1657,14 +1629,22 @@ void *handle_mounts(void *arg)

 			     ap->path);

 			if (!ap->submount)

 				alarm_add(ap, ap->exp_runfreq);

-			nextstate(ap->state_pipe[1], ST_READY);

+			/* Return to ST_READY is done immediately */

+			st_add_task(ap, ST_READY);

+			master_source_unlock(ap->entry);

+			if (ap->submount) {

+				mounts_mutex_unlock(ap->parent);

+				master_source_unlock(ap->parent->entry);

+			}

+

+			master_mutex_unlock();

+

+			pthread_setcancelstate(cur_state, NULL);

-			state_mutex_unlock(ap);

 		}

 	}

-	pthread_cleanup_pop(1);

-	sched_yield();

+	handle_mounts_cleanup(ap);

 	return NULL;

 }

diff --git a/daemon/direct.c b/daemon/direct.c

index a3869a5..334a4b6 100644

--- a/daemon/direct.c

+++ b/daemon/direct.c

@@ -216,8 +216,6 @@ int umount_autofs_direct(struct autofs_point *ap)

 	mnts = tree_make_mnt_tree(_PROC_MOUNTS, "/");

 	pthread_cleanup_push(mnts_cleanup, mnts);

-	pthread_cleanup_push(master_source_lock_cleanup, ap->entry);

-	master_source_readlock(ap->entry);

 	nc = ap->entry->master->nc;

 	cache_readlock(nc);

 	pthread_cleanup_push(cache_lock_cleanup, nc);

@@ -244,7 +242,6 @@ int umount_autofs_direct(struct autofs_point *ap)

 	}

 	pthread_cleanup_pop(1);

 	pthread_cleanup_pop(1);

-	pthread_cleanup_pop(1);

 	return 0;

 }

@@ -572,9 +569,10 @@ int umount_autofs_offset(struct autofs_point *ap, struct mapent *me)

 			return 1;

 		} else if (!status) {

 			if (ap->state != ST_SHUTDOWN_FORCE) {

-				error(ap->logopt,

-				      "ask umount returned busy for %s",

-				      me->key);

+				if (ap->shutdown)

+					error(ap->logopt,

+					     "ask umount returned busy for %s",

+					     me->key);

 				return 1;

 			} else {

 				me->ioctlfd = -1;

@@ -904,7 +902,10 @@ void *expire_proc_direct(void *arg)

 		 * 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->path, LKP_DISTINCT);

+		pthread_cleanup_pop(1);

 		if (!me)

 			continue;

@@ -1110,6 +1111,8 @@ int handle_packet_expire_direct(struct autofs_point *ap, autofs_packet_expire_di

 	struct pending_args *mt;

 	char buf[MAX_ERR_BUF];

 	pthread_t thid;

+	struct timespec wait;

+	struct timeval now;

 	int status, state;

 	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &state);

@@ -1124,7 +1127,7 @@ int handle_packet_expire_direct(struct autofs_point *ap, autofs_packet_expire_di

 	 * and since it got mounted we have to trust that

 	 * there is an entry in the cache.

 	 */

-	master_source_readlock(ap->entry);

+	master_source_writelock(ap->entry);

 	map = ap->entry->maps;

 	while (map) {

 		mc = map->mc;

@@ -1135,7 +1138,6 @@ int handle_packet_expire_direct(struct autofs_point *ap, autofs_packet_expire_di

 		cache_unlock(mc);

 		map = map->next;

 	}

-	master_source_unlock(ap->entry);

 	if (!me) {

 		/*

@@ -1144,10 +1146,28 @@ int handle_packet_expire_direct(struct autofs_point *ap, autofs_packet_expire_di

 		 */

 		crit(ap->logopt, "can't find map entry for (%lu,%lu)",

 		    (unsigned long) pkt->dev, (unsigned long) pkt->ino);

+		cache_unlock(mc);

+		master_source_unlock(ap->entry);

 		pthread_setcancelstate(state, NULL);

 		return 1;

 	}

+	/* Can't expire it if it isn't mounted */

+	if (me->ioctlfd == -1) {

+		int ioctlfd = open(me->key, O_RDONLY);

+		if (ioctlfd == -1) {

+			crit(ap->logopt, "can't open ioctlfd for %s",

+			     me->key);

+			pthread_setcancelstate(state, NULL);

+			return 1;

+		}

+		send_ready(ap->logopt, ioctlfd, pkt->wait_queue_token);

+		close(ioctlfd);

+		cache_unlock(mc);

+		master_source_unlock(ap->entry);

+		pthread_setcancelstate(state, NULL);

+		return 0;

+	}

 	mt = malloc(sizeof(struct pending_args));

 	if (!mt) {

@@ -1155,6 +1175,7 @@ int handle_packet_expire_direct(struct autofs_point *ap, autofs_packet_expire_di

 		error(ap->logopt, "malloc: %s", estr);

 		send_fail(ap->logopt, me->ioctlfd, pkt->wait_queue_token);

 		cache_unlock(mc);

+		master_source_unlock(ap->entry);

 		pthread_setcancelstate(state, NULL);

 		return 1;

 	}

@@ -1184,6 +1205,7 @@ int handle_packet_expire_direct(struct autofs_point *ap, autofs_packet_expire_di

 		error(ap->logopt, "expire thread create failed");

 		send_fail(ap->logopt, mt->ioctlfd, pkt->wait_queue_token);

 		cache_unlock(mc);

+		master_source_unlock(ap->entry);

 		expire_mutex_unlock(NULL);

 		pending_cond_destroy(mt);

 		free_pending_args(mt);

@@ -1192,14 +1214,18 @@ int handle_packet_expire_direct(struct autofs_point *ap, autofs_packet_expire_di

 	}

 	cache_unlock(mc);

+	master_source_unlock(ap->entry);

 	pthread_cleanup_push(expire_mutex_unlock, NULL);

 	pthread_setcancelstate(state, NULL);

 	mt->signaled = 0;

 	while (!mt->signaled) {

+		gettimeofday(&now, NULL);

+		wait.tv_sec = now.tv_sec + 2;

+		wait.tv_nsec = now.tv_usec * 1000;

 		status = pthread_cond_wait(&mt->cond, &ea_mutex);

-		if (status)

+		if (status && status != ETIMEDOUT)

 			fatal(status);

 	}

@@ -1263,6 +1289,9 @@ static void *do_mount_direct(void *arg)

 	if (status == -1) {

 		error(ap->logopt,

 		      "can't stat direct mount trigger %s", mt.name);

+		send_fail(ap->logopt,

+			  mt.ioctlfd, mt.wait_queue_token);

+		close(mt.ioctlfd);

 		pthread_setcancelstate(state, NULL);

 		pthread_exit(NULL);

 	}

@@ -1272,6 +1301,8 @@ static void *do_mount_direct(void *arg)

 		error(ap->logopt,

 		     "direct trigger not valid or already mounted %s",

 		     mt.name);

+		send_ready(ap->logopt, mt.ioctlfd, mt.wait_queue_token);

+		close(mt.ioctlfd);

 		pthread_setcancelstate(state, NULL);

 		pthread_exit(NULL);

 	}

@@ -1290,19 +1321,12 @@ static void *do_mount_direct(void *arg)

 	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &state);

 	if (status) {

 		struct mapent *me;

-		int real_mount, set_fd;

-		cache_readlock(mt.mc);

+		cache_writelock(mt.mc);

 		me = cache_lookup_distinct(mt.mc, mt.name);

-		real_mount = is_mounted(_PATH_MOUNTED, me->key, MNTS_REAL);

-		set_fd = (real_mount || me->multi == me);

-		cache_unlock(mt.mc);

-		if (set_fd) {

+		if (me)

 			me->ioctlfd = mt.ioctlfd;

-			send_ready(ap->logopt, mt.ioctlfd, mt.wait_queue_token);

-		} else {

-			send_ready(ap->logopt, mt.ioctlfd, mt.wait_queue_token);

-			close(mt.ioctlfd);

-		}

+		send_ready(ap->logopt, mt.ioctlfd, mt.wait_queue_token);

+		cache_unlock(mt.mc);

 		info(ap->logopt, "mounted %s", mt.name);

 	} else {

 		send_fail(ap->logopt, mt.ioctlfd, mt.wait_queue_token);

@@ -1325,11 +1349,21 @@ int handle_packet_missing_direct(struct autofs_point *ap, autofs_packet_missing_

 	struct pending_args *mt;

 	char buf[MAX_ERR_BUF];

 	int status = 0;

+	struct timespec wait;

+	struct timeval now;

 	int ioctlfd, len, cl_flags, state;

 	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &state);

-	master_source_readlock(ap->entry);

+	/*

+	 * If our parent is a direct or offset mount that has been

+	 * covered by a mount and another lookup occurs after the

+	 * mount but before the device and inode are set in the

+	 * cache entry we will not be able to find the mapent. So

+	 * we must take the source writelock to ensure the parent

+	 * has mount is complete before we look for the entry.

+	 */

+	master_source_writelock(ap->entry);

 	map = ap->entry->maps;

 	while (map) {

 		/*

@@ -1349,7 +1383,6 @@ int handle_packet_missing_direct(struct autofs_point *ap, autofs_packet_missing_

 		cache_unlock(mc);

 		map = map->next;

 	}

-	master_source_unlock(ap->entry);

 	if (!me) {

 		/*

@@ -1358,6 +1391,8 @@ int handle_packet_missing_direct(struct autofs_point *ap, autofs_packet_missing_

 		 */

 		logerr("can't find map entry for (%lu,%lu)",

 		    (unsigned long) pkt->dev, (unsigned long) pkt->ino);

+		cache_unlock(mc);

+		master_source_unlock(ap->entry);

 		pthread_setcancelstate(state, NULL);

 		return 1;

 	}

@@ -1371,6 +1406,7 @@ int handle_packet_missing_direct(struct autofs_point *ap, autofs_packet_missing_

 	if (ioctlfd == -1) {

 		cache_unlock(mc);

+		master_source_unlock(ap->entry);

 		pthread_setcancelstate(state, NULL);

 		crit(ap->logopt, "failed to create ioctl fd for %s", me->key);

 		/* TODO:  how do we clear wait q in kernel ?? */

@@ -1386,12 +1422,11 @@ int handle_packet_missing_direct(struct autofs_point *ap, autofs_packet_missing_

 		  (unsigned long) pkt->wait_queue_token, me->key, pkt->pid);

 	/* Ignore packet if we're trying to shut down */

-	if (ap->shutdown ||

-	    ap->state == ST_SHUTDOWN_FORCE ||

-	    ap->state == ST_SHUTDOWN) {

+	if (ap->shutdown || ap->state == ST_SHUTDOWN_FORCE) {

 		send_fail(ap->logopt, ioctlfd, pkt->wait_queue_token);

 		close(ioctlfd);

 		cache_unlock(mc);

+		master_source_unlock(ap->entry);

 		pthread_setcancelstate(state, NULL);

 		return 1;

 	}

@@ -1402,6 +1437,7 @@ int handle_packet_missing_direct(struct autofs_point *ap, autofs_packet_missing_

 		send_fail(ap->logopt, ioctlfd, pkt->wait_queue_token);

 		close(ioctlfd);

 		cache_unlock(mc);

+		master_source_unlock(ap->entry);

 		pthread_setcancelstate(state, NULL);

 		return 1;

 	}

@@ -1413,6 +1449,7 @@ int handle_packet_missing_direct(struct autofs_point *ap, autofs_packet_missing_

 		send_fail(ap->logopt, ioctlfd, pkt->wait_queue_token);

 		close(ioctlfd);

 		cache_unlock(mc);

+		master_source_unlock(ap->entry);

 		pthread_setcancelstate(state, NULL);

 		return 1;

 	}

@@ -1447,6 +1484,7 @@ int handle_packet_missing_direct(struct autofs_point *ap, autofs_packet_missing_

 		send_fail(ap->logopt, ioctlfd, pkt->wait_queue_token);

 		close(ioctlfd);

 		cache_unlock(mc);

+		master_source_unlock(ap->entry);

 		mount_mutex_unlock(mt);

 		pending_cond_destroy(mt);

 		pending_mutex_destroy(mt);

@@ -1456,6 +1494,8 @@ int handle_packet_missing_direct(struct autofs_point *ap, autofs_packet_missing_

 	}

 	cache_unlock(mc);

+	master_source_unlock(ap->entry);

+

 	pthread_cleanup_push(free_pending_args, mt);

 	pthread_cleanup_push(pending_mutex_destroy, mt);

 	pthread_cleanup_push(pending_cond_destroy, mt);

@@ -1464,8 +1504,11 @@ int handle_packet_missing_direct(struct autofs_point *ap, autofs_packet_missing_

 	mt->signaled = 0;

 	while (!mt->signaled) {

-		status = pthread_cond_wait(&mt->cond, &mt->mutex);

-		if (status)

+		gettimeofday(&now, NULL);

+		wait.tv_sec = now.tv_sec + 2;

+		wait.tv_nsec = now.tv_usec * 1000;

+		status = pthread_cond_timedwait(&mt->cond, &mt->mutex, &wait);

+		if (status && status != ETIMEDOUT)

 			fatal(status);

 	}

diff --git a/daemon/indirect.c b/daemon/indirect.c

index 3922f3f..17bed3e 100644

--- a/daemon/indirect.c

+++ b/daemon/indirect.c

@@ -230,11 +230,8 @@ int mount_autofs_indirect(struct autofs_point *ap)

 	return 0;

 }

-int umount_autofs_indirect(struct autofs_point *ap)

+static void close_mount_fds(struct autofs_point *ap)

 {

-	char buf[MAX_ERR_BUF];

-	int ret, rv, retries;

-

 	/*

 	 * Since submounts look after themselves the parent never knows

 	 * it needs to close the ioctlfd for offset mounts so we have

@@ -244,6 +241,25 @@ int umount_autofs_indirect(struct autofs_point *ap)

 	if (ap->submount)

 		lookup_source_close_ioctlfd(ap->parent, ap->path);

+	close(ap->state_pipe[0]);

+	close(ap->state_pipe[1]);

+	ap->state_pipe[0] = -1;

+	ap->state_pipe[1] = -1;

+

+	if (ap->pipefd >= 0)

+		close(ap->pipefd);

+

+	if (ap->kpipefd >= 0)

+		close(ap->kpipefd);

+

+	return;

+}

+

+int umount_autofs_indirect(struct autofs_point *ap)

+{

+	char buf[MAX_ERR_BUF];

+	int ret, rv, retries;

+

 	/* If we are trying to shutdown make sure we can umount */

 	rv = ioctl(ap->ioctlfd, AUTOFS_IOC_ASKUMOUNT, &ret;;

 	if (rv == -1) {

@@ -251,24 +267,20 @@ int umount_autofs_indirect(struct autofs_point *ap)

 		logerr("ioctl failed: %s", estr);

 		return 1;

 	} else if (!ret) {

+#if defined(ENABLE_IGNORE_BUSY_MOUNTS) || defined(ENABLE_FORCED_SHUTDOWN)

+		if (!ap->shutdown)

+			return 1;

 		error(ap->logopt, "ask umount returned busy %s", ap->path);

+#else

 		return 1;

+#endif

 	}

-	ioctl(ap->ioctlfd, AUTOFS_IOC_CATATONIC, 0);

+	if (ap->shutdown)

+		ioctl(ap->ioctlfd, AUTOFS_IOC_CATATONIC, 0);

+

 	close(ap->ioctlfd);

 	ap->ioctlfd = -1;

-	close(ap->state_pipe[0]);

-	close(ap->state_pipe[1]);

-	ap->state_pipe[0] = -1;

-	ap->state_pipe[1] = -1;

-

-	if (ap->pipefd >= 0)

-		close(ap->pipefd);

-

-	if (ap->kpipefd >= 0)

-		close(ap->kpipefd);

-

 	sched_yield();

 	retries = UMOUNT_RETRIES;

@@ -285,24 +297,61 @@ int umount_autofs_indirect(struct autofs_point *ap)

 		case EINVAL:

 			error(ap->logopt,

 			      "mount point %s does not exist", ap->path);

+			close_mount_fds(ap);

 			return 0;

 			break;

 		case EBUSY:

-			error(ap->logopt,

+			debug(ap->logopt,

 			      "mount point %s is in use", ap->path);

-			if (ap->state == ST_SHUTDOWN_FORCE)

+			if (ap->state == ST_SHUTDOWN_FORCE) {

+				close_mount_fds(ap);

 				goto force_umount;

-			else

-				return 0;

+			} else {

+				int cl_flags;

+				/*

+				 * If the umount returns EBUSY there may be

+				 * a mount request in progress so we need to

+				 * recover unless we have been explicitly

+				 * asked to shutdown and configure option

+				 * ENABLE_IGNORE_BUSY_MOUNTS is enabled.

+				 */

+#ifdef ENABLE_IGNORE_BUSY_MOUNTS

+				if (ap->shutdown) {

+					close_mount_fds(ap);

+					return 0;

+				}

+#endif

+				ap->ioctlfd = open(ap->path, O_RDONLY);

+				if (ap->ioctlfd < 0) {

+					warn(ap->logopt,

+					     "could not recover autofs path %s",

+					     ap->path);

+					close_mount_fds(ap);

+					return 0;

+				}

+

+				if ((cl_flags = fcntl(ap->ioctlfd, F_GETFD, 0)) != -1) {

+					cl_flags |= FD_CLOEXEC;

+					fcntl(ap->ioctlfd, F_SETFD, cl_flags);

+				}

+			}

 			break;

 		case ENOTDIR:

 			error(ap->logopt, "mount point is not a directory");

+			close_mount_fds(ap);

 			return 0;

 			break;

 		}

 		return 1;

 	}

+	/*

+	 * We have successfully umounted the mount so we now close

+	 * the descriptors. The kernel end of the kernel pipe will

+	 * have been put during the umount super block cleanup.

+	 */

+	close_mount_fds(ap);

+

 force_umount:

 	if (rv != 0) {

 		warn(ap->logopt,

@@ -439,9 +488,12 @@ void *expire_proc_indirect(void *arg)

 		 * Otherwise it's a top level indirect mount (possibly

 		 * with offsets in it) and we use the usual ioctlfd.

 		 */

+		pthread_cleanup_push(master_source_lock_cleanup, ap->entry);

+		master_source_readlock(ap->entry);

 		me = lookup_source_mapent(ap, next->path, LKP_DISTINCT);

 		if (!me && ind_key)

 			me = lookup_source_mapent(ap, ind_key, LKP_NORMAL);

+		pthread_cleanup_pop(1);

 		if (!me)

 			continue;

@@ -586,6 +638,8 @@ int handle_packet_expire_indirect(struct autofs_point *ap, autofs_packet_expire_

 	struct pending_args *mt;

 	char buf[MAX_ERR_BUF];

 	pthread_t thid;

+	struct timespec wait;

+	struct timeval now;

 	int status, state;

 	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &state);

@@ -632,8 +686,11 @@ int handle_packet_expire_indirect(struct autofs_point *ap, autofs_packet_expire_

 	mt->signaled = 0;

 	while (!mt->signaled) {

-		status = pthread_cond_wait(&mt->cond, &ea_mutex);

-		if (status)

+		gettimeofday(&now, NULL);

+		wait.tv_sec = now.tv_sec + 2;

+		wait.tv_nsec = now.tv_usec * 1000;

+		status = pthread_cond_timedwait(&mt->cond, &ea_mutex, &wait);

+		if (status && status != ETIMEDOUT)

 			fatal(status);

 	}

@@ -735,6 +792,8 @@ int handle_packet_missing_indirect(struct autofs_point *ap, autofs_packet_missin

 	pthread_t thid;

 	char buf[MAX_ERR_BUF];

 	struct pending_args *mt;

+	struct timespec wait;

+	struct timeval now;

 	int status, state;

 	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &state);

@@ -743,9 +802,7 @@ int handle_packet_missing_indirect(struct autofs_point *ap, autofs_packet_missin

 		(unsigned long) pkt->wait_queue_token, pkt->name, pkt->pid);

 	/* Ignore packet if we're trying to shut down */

-	if (ap->shutdown ||

-	    ap->state == ST_SHUTDOWN_FORCE ||

-	    ap->state == ST_SHUTDOWN) {

+	if (ap->shutdown || ap->state == ST_SHUTDOWN_FORCE) {

 		send_fail(ap->logopt, ap->ioctlfd, pkt->wait_queue_token);

 		pthread_setcancelstate(state, NULL);

 		return 0;

@@ -802,8 +859,11 @@ int handle_packet_missing_indirect(struct autofs_point *ap, autofs_packet_missin

 	mt->signaled = 0;

 	while (!mt->signaled) {

-		status = pthread_cond_wait(&mt->cond, &mt->mutex);

-		if (status)

+		gettimeofday(&now, NULL);