diff --git a/README b/README
index 8446a3b..6ed7de2 100644
--- a/README
+++ b/README
@@ -114,6 +114,19 @@
 	entries.  The permissible values are between 12 and 20, the latter
 	indicating 1048576 entries.  The default is 12.
 
+ (*) resume_thresholds <blocks> <files>
+
+	Scanning to refill the cull table is suspended when all the objects in
+	a cache are pinned by a live network filesystem in the kernel and
+	there's nothing available to cull.  Scanning is resumed when the kernel
+	releases sufficient objects that either the number of objects released
+	exceeds the files parameter here or the cumulative i_blocks values
+	exceed the blocks parameter.  Either threshold can be disabled by
+	specifying it as "-".
+
+	The default is to ignore the block threshold and to resume when five or
+	more files have been released.
+
  (*) debug <mask>
 
 	Specify a numeric bitmask to control debugging in the kernel module.
diff --git a/cachefilesd.c b/cachefilesd.c
index eaa1bb0..bb05a38 100644
--- a/cachefilesd.c
+++ b/cachefilesd.c
@@ -46,6 +46,7 @@
 #include <dirent.h>
 #include <time.h>
 #include <poll.h>
+#include <limits.h>
 #include <sys/inotify.h>
 #include <sys/time.h>
 #include <sys/vfs.h>
@@ -85,8 +86,8 @@
 static int nopendir;
 
 /* current scan point */
-static struct object *scan = &root;
-static bool jumpstart_scan;
+static struct object *scan_cursor;
+static bool scan_signalled, stop_signalled, reap_signalled;
 
 /* ranked order of cullable objects
  * - we have two tables: one we're building and one that's full of ready to be
@@ -99,7 +100,10 @@
 static unsigned nr_in_build_table;
 static unsigned nr_in_ready_table;
 static int ncullable;
-static bool cull_delayed;
+static bool kernel_wants_cull;
+static bool have_nr_releases;
+static unsigned long long f_released_since_last_scan;
+static unsigned long long b_released_since_last_scan;
 
 
 static const char *configfile = "/etc/cachefilesd.conf";
@@ -108,11 +112,13 @@
 static const char *pidfile = "/var/run/cachefilesd.pid";
 static char *cacheroot, *graveyardpath;
 
+static bool culling_disabled;
 static bool xnolog, xopenedlog;
 static int xdebug;
-static bool nocull, stop, reap, cull;
 static int graveyardfd;
 static unsigned long long brun, bcull, bstop, frun, fcull, fstop;
+static unsigned long long b_resume_threshold = ULLONG_MAX;
+static unsigned long long f_resume_threshold = 5;
 
 #define cachefd 3
 
@@ -212,7 +218,8 @@
 static void read_cache_state(void);
 static int is_object_in_use(const char *filename);
 static void cull_file(const char *filename);
-static void build_cull_table(void);
+static void begin_building_cull_table(void);
+static bool build_cull_table(void);
 static void decant_cull_table(void);
 static void insert_into_cull_table(struct object *object);
 static void put_object(struct object *object);
@@ -228,7 +235,7 @@
  */
 static void sigterm(int sig)
 {
-	stop = true;
+	stop_signalled = true;
 }
 
 /*****************************************************************************/
@@ -237,7 +244,7 @@
  */
 static void sigio(int sig)
 {
-	reap = true;
+	reap_signalled = true;
 }
 
 /*****************************************************************************/
@@ -246,8 +253,7 @@
  */
 static void sigalrm(int sig)
 {
-	jumpstart_scan = true;
-	cull_delayed = false;
+	scan_signalled = true;
 }
 
 /*****************************************************************************/
@@ -312,7 +318,7 @@
 
 		case 'N':
 			/* disable culling */
-			nocull = true;
+			culling_disabled = true;
 			break;
 
 		case 'f':
@@ -420,7 +426,7 @@
 		/*  allow culling to be disabled */
 		if (memcmp(cp, "nocull", 6) == 0 &&
 		    (!cp[6] || isspace(cp[6]))) {
-			nocull = true;
+			culling_disabled = true;
 		}
 
 		/* note the cull table size command */
@@ -439,6 +445,44 @@
 			continue;
 		}
 
+		/* Note the suspension resume released file count thresholds
+		 * ("-" to disable a threshold).
+		 */
+		if (memcmp(cp, "resume_thresholds", 18) == 0 && isspace(cp[18])) {
+			unsigned long long b_thresh, f_thresh;
+			char *sp;
+
+			for (sp = cp + 18; isspace(*sp); sp++) {;}
+
+			if (*sp == '-') {
+				sp++;
+				b_thresh = ULLONG_MAX;
+			} else {
+				b_thresh = strtoul(sp, &sp, 10);
+			}
+
+			if (!*sp || !isspace(*sp))
+				cfgerror("Error parsing resume threshold (blocks)");
+			if (b_thresh == 0)
+				cfgerror("Invalid resume threshold (blocks)");
+			for (; isspace(*sp); sp++) {;}
+
+			if (*sp == '-') {
+				sp++;
+				f_thresh = ULLONG_MAX;
+			} else {
+				f_thresh = strtoul(sp, &sp, 10);
+				if (*sp)
+					cfgerror("Error parsing resume threshold (files)");
+				if (f_thresh == 0)
+					cfgerror("Invalid resume threshold (files)");
+			}
+
+			b_resume_threshold = b_thresh;
+			f_resume_threshold = f_thresh;
+			continue;
+		}
+
 		/* note the dir command */
 		if (memcmp(cp, "dir", 3) == 0 && isspace(cp[3])) {
 			char *sp;
@@ -479,7 +523,7 @@
 		oserror("Unable to close %s", configfile);
 
 	/* allocate the cull tables */
-	if (!nocull) {
+	if (!culling_disabled) {
 		cullbuild = calloc(culltable_size, sizeof(cullbuild[0]));
 		if (!cullbuild)
 			oserror("calloc");
@@ -583,6 +627,8 @@
 static void cachefilesd(void)
 {
 	sigset_t sigs, osigs;
+	bool scanning_suspended = false;
+	bool scan_in_progress = false;
 
 	struct pollfd pollfds[1] = {
 		[0] = {
@@ -596,13 +642,14 @@
 	/* open the cache directories */
 	open_cache();
 
-	/* we need to disable I/O and termination signals so they're only
-	 * caught at appropriate times
+	/* We need to be able to disable signals that we need to check for
+	 * before calling poll so that we don't race and miss something.
 	 */
 	sigemptyset(&sigs);
 	sigaddset(&sigs, SIGIO);
 	sigaddset(&sigs, SIGINT);
 	sigaddset(&sigs, SIGTERM);
+	sigaddset(&sigs, SIGALRM);
 
 	signal(SIGTERM, sigterm);
 	signal(SIGINT, sigterm);
@@ -610,16 +657,81 @@
 	/* check the graveyard for graves */
 	reap_graveyard();
 
-	while (!stop) {
+	while (!stop_signalled) {
+		bool do_cull = false;
+
+		debug(3, "Loop %sbuild=%d ready=%d susp=%u scan=%u",
+		      culling_disabled ? "NOCULL " : "",
+		      nr_in_build_table, nr_in_ready_table,
+		      scanning_suspended, scan_in_progress);
+
 		read_cache_state();
 
-		/* sleep without racing on reap and cull with the signal
-		 * handlers */
-		if (!scan && !reap && !(cull && !cull_delayed)) {
+		if (!culling_disabled) {
+			/* Determine if we're going to need to start a new scan
+			 * to refill the cull table.  We want to do this if the
+			 * secondary cull table is less than half full - but
+			 * overriding that, we don't want to do this if we know
+			 * there's insufficient cullables to make it worth
+			 * while.
+			 */
+			if (!scan_in_progress) {
+				bool begin_scan = false;
+
+				debug(1, "Consider scan %d/%d",
+				      nr_in_build_table, culltable_size / 2);
+
+				if (nr_in_build_table < culltable_size / 2) {
+					debug(1, "Want to scan");
+					begin_scan = true;
+				}
+
+				if (begin_scan && scanning_suspended) {
+					debug(1, "Scanning suspended");
+					if (have_nr_releases) {
+						if (f_released_since_last_scan <
+						    f_resume_threshold &&
+						    b_released_since_last_scan <
+						    b_resume_threshold)
+							begin_scan = false;
+					} else {
+						begin_scan = scan_signalled;
+					}
+				}
+
+				if (begin_scan) {
+					debug(1, "Beginning a scan");
+					begin_building_cull_table();
+					scan_in_progress = true;
+					scanning_suspended = false;
+					scan_signalled = false;
+					f_released_since_last_scan = 0;
+					b_released_since_last_scan = 0;
+				}
+			}
+
+			/* Determine if there's anything we can actually cull yet if
+			 * the kernel is calling for space.
+			 */
+			if (kernel_wants_cull) {
+				debug(1, "Want to cull");
+				if (nr_in_ready_table > 0)
+					do_cull = true;
+			}
+		}
+
+		/* We block the signals across the checks for reap, cull and
+		 * scan initiation before polling so that we sleep without
+		 * racing against the signal handlers.
+		 */
+		if (!scan_in_progress && !reap_signalled && !do_cull) {
 			if (sigprocmask(SIG_BLOCK, &sigs, &osigs) < 0)
 				oserror("Unable to block signals");
 
-			if (!reap && !stop && !jumpstart_scan) {
+			if (!reap_signalled &&
+			    !stop_signalled &&
+			    !scan_signalled) {
+				debug(1, "Poll");
 				if (ppoll(pollfds, 1, NULL, &osigs) < 0 &&
 				    errno != EINTR)
 					oserror("Unable to suspend process");
@@ -627,37 +739,44 @@
 
 			if (sigprocmask(SIG_UNBLOCK, &sigs, NULL) < 0)
 				oserror("Unable to unblock signals");
-
-			read_cache_state();
+			continue;
 		}
 
-		if (nocull) {
-			cull = false;
-		} else {
-			if (jumpstart_scan) {
-				jumpstart_scan = false;
-				if (!stop && !scan) {
-					debug(1, "Refilling cull table");
-					root.usage++;
-					scan = &root;
+		if (!culling_disabled) {
+			if (do_cull)
+				cull_objects();
+
+			if (scan_in_progress) {
+				scan_in_progress = build_cull_table();
+				if (!scan_in_progress) {
+					/* Scan complete.
+					 *
+					 * If the scan didn't produce a full
+					 * table then don't repeat the scan
+					 * until something gets released by the
+					 * kernel.
+					 */
+					if (nr_in_build_table < culltable_size) {
+						debug(1, "Suspend scanning");
+						scanning_suspended = true;
+						if (!have_nr_releases) {
+							signal(SIGALRM, sigalrm);
+							alarm(30);
+						}
+					}
 				}
 			}
 
-			if (cull) {
-				if (nr_in_ready_table > 0)
-					cull_objects();
-				else if (nr_in_build_table == 0 && !cull_delayed)
-					jumpstart_scan = true;
+			if (!scan_in_progress) {
+				if (nr_in_ready_table <= culltable_size / 2 + 2 &&
+				    nr_in_build_table > 0) {
+					debug(1, "Decant");
+					decant_cull_table();
+				}
 			}
-
-			if (scan)
-				build_cull_table();
-
-			if (!scan && nr_in_ready_table == 0 && nr_in_build_table > 0)
-				decant_cull_table();
 		}
 
-		if (reap)
+		if (reap_signalled)
 			reap_graveyard();
 	}
 
@@ -672,7 +791,7 @@
 static void reap_graveyard(void)
 {
 	/* set a one-shot notification to catch more graves appearing */
-	reap = false;
+	reap_signalled = false;
 	signal(SIGIO, sigio);
 	if (fcntl(graveyardfd, F_NOTIFY, DN_CREATE) < 0)
 		oserror("unable to set notification on graveyard");
@@ -763,6 +882,8 @@
 		oserror("Unable to read cache state");
 	buffer[n] = '\0';
 
+	debug(3, "KERNEL: %s", buffer);
+
 	tok = buffer;
 	do {
 		next = strpbrk(tok, " \t");
@@ -777,20 +898,27 @@
 			continue;
 		}
 
-		if (strcmp(tok, "cull") == 0)
-			cull = (strtoul(arg, NULL, 0) != 0);
-		else if (strcmp(tok, "brun") == 0)
+		if (strcmp(tok, "cull") == 0) {
+			kernel_wants_cull = (strtoul(arg, NULL, 0) != 0);
+		} else if (strcmp(tok, "brun") == 0) {
 			brun = strtoull(arg, NULL, 16);
-		else if (strcmp(tok, "bcull") == 0)
+		} else if (strcmp(tok, "bcull") == 0) {
 			bcull = strtoull(arg, NULL, 16);
-		else if (strcmp(tok, "bstop") == 0)
+		} else if (strcmp(tok, "bstop") == 0) {
 			bstop = strtoull(arg, NULL, 16);
-		else if (strcmp(tok, "frun") == 0)
+		} else if (strcmp(tok, "frun") == 0) {
 			frun = strtoull(arg, NULL, 16);
-		else if (strcmp(tok, "fcull") == 0)
+		} else if (strcmp(tok, "fcull") == 0) {
 			fcull = strtoull(arg, NULL, 16);
-		else if (strcmp(tok, "fstop") == 0)
+		} else if (strcmp(tok, "fstop") == 0) {
 			fstop = strtoull(arg, NULL, 16);
+		} else if (strcmp(tok, "breleased") == 0) {
+			b_released_since_last_scan += strtoull(arg, NULL, 16);
+			have_nr_releases = true;
+		} else if (strcmp(tok, "freleased") == 0) {
+			f_released_since_last_scan += strtoull(arg, NULL, 16);
+			have_nr_releases = true;
+		}
 
 	} while ((tok = next));
 }
@@ -1123,9 +1251,21 @@
 
 /*****************************************************************************/
 /*
- * do the next step in building up the cull table
+ * Begin a scan to build a cull table.
  */
-static void build_cull_table(void)
+static void begin_building_cull_table(void)
+{
+	debug(1, "Refilling cull table");
+	root.usage++;
+	scan_cursor = &root;
+}
+
+/*****************************************************************************/
+/*
+ * Do the next step in building up the cull table.  Returns false upon
+ * completion of a scan.
+ */
+static bool build_cull_table(void)
 {
 	struct dirent dirent, *de;
 	struct object *curr, *child;
@@ -1133,7 +1273,7 @@
 	unsigned loop;
 	int fd;
 
-	curr = scan;
+	curr = scan_cursor;
 
 	if (!curr->dir) {
 		curr->empty = true;
@@ -1289,10 +1429,10 @@
 		debug(2, "- descend");
 
 		child->new = false;
-		scan = child;
+		scan_cursor = child;
 
 		debug(2, "<-- build_cull_table({%s})", curr->name);
-		return;
+		return true;
 
 	default:
 		error("Unexpected type");
@@ -1335,15 +1475,13 @@
 		}
 	}
 
-	scan = curr->parent;
-	if (!scan) {
+	scan_cursor = curr->parent;
+	if (!scan_cursor)
 		debug(1, "Scan complete");
-		decant_cull_table();
-	}
 
 	debug(2, "<-- build_cull_table({%s})", curr->name);
 	put_object(curr);
-	return;
+	return scan_cursor != NULL;
 
 	/* delete unexpected objects that we've found */
 found_unexpected_object:
@@ -1361,17 +1499,9 @@
 {
 	unsigned loop, avail, copy, leave, space, n;
 
-	if (scan)
+	if (scan_cursor)
 		error("Can't decant cull table whilst scanning");
 
-	/* if nothing there, scan again in a short while */
-	if (nr_in_build_table == 0) {
-		cull_delayed = true;
-		signal(SIGALRM, sigalrm);
-		alarm(30);
-		return;
-	}
-
 	/* mark the new entries cullable */
 	for (loop = 0; loop < nr_in_build_table; loop++) {
 		if (!cullbuild[loop]->cullable) {
@@ -1504,13 +1634,4 @@
 		cull_object(cullready[nr_in_ready_table - 1]);
 		cullready[--nr_in_ready_table] = (void *)(0x6b000000 | __LINE__);
 	}
-
-	/* must start refilling the cull table */
-	if (!scan && nr_in_build_table < culltable_size / 2 + 2) {
-		decant_cull_table();
-
-		debug(1, "Refilling cull table");
-		root.usage++;
-		scan = &root;
-	}
 }
diff --git a/cachefilesd.conf.5 b/cachefilesd.conf.5
index 028105e..b108bdc 100644
--- a/cachefilesd.conf.5
+++ b/cachefilesd.conf.5
@@ -75,6 +75,16 @@
 disables all culling activity.  The cache will keep building up to the limits
 set and won't be shrunk, except by the removal of out-dated cache files.
 .TP
+.B resume_thresholds <blocks> <files>
+This command specifies the amount of blocks or files that the kernel should let
+go of before the daemon should resume from culling table scan suspension.
+.IP
+Scanning to refill the cull table is suspended when all the objects in a cache
+are pinned by a live network filesystem in the kernel and there's nothing to
+cull.
+.IP
+Either value can be "-" to indicate that this threshold should be ignored.
+.TP
 .B debug <mask>
 This command specifies a numeric bitmask to control debugging in the kernel
 module.  The default is zero (all off).  The following values can be OR'd into