5 files changed, 108 insertions, 33 deletions

diff --git a/sys/vm/vm_object.c b/sys/vm/vm_object.c
index 010e8eedfb00..822b95364a98 100644
--- a/sys/vm/vm_object.c
+++ b/sys/vm/vm_object.c
@@ -61,7 +61,7 @@
  * any improvements or extensions that they make and grant Carnegie the
  * rights to redistribute these changes.
  *
- * $Id: vm_object.c,v 1.117 1998/03/08 06:25:59 dyson Exp $
+ * $Id: vm_object.c,v 1.118 1998/03/08 18:05:59 dyson Exp $
  */
 
 /*
@@ -436,7 +436,14 @@ vm_object_terminate(object)
 		vp = (struct vnode *) object->handle;
 		vinvalbuf(vp, V_SAVE, NOCRED, NULL, 0, 0);
 
-	} else if (object->type != OBJT_DEAD) {
+		/*
+		 * Let the pager know object is dead.
+		 */
+		vm_pager_deallocate(object);
+
+	}
+
+	if ((object->type != OBJT_VNODE) && (object->ref_count == 0)) {
 
 		/*
 		 * Now free the pages. For internal objects, this also removes them
@@ -451,20 +458,15 @@ vm_object_terminate(object)
 			vm_page_free(p);
 			cnt.v_pfree++;
 		}
-
-	}
-
-	if (object->type != OBJT_DEAD) {
 		/*
 		 * Let the pager know object is dead.
 		 */
 		vm_pager_deallocate(object);
-	}
 
-	if (object->ref_count == 0) {
-		if ((object->type != OBJT_DEAD) || (object->resident_page_count == 0))
-			vm_object_dispose(object);
 	}
+
+	if ((object->ref_count == 0) && (object->resident_page_count == 0))
+		vm_object_dispose(object);
 }
 
 /*
diff --git a/sys/vm/vm_page.c b/sys/vm/vm_page.c
index c8f751704258..0fb05fa84f70 100644
--- a/sys/vm/vm_page.c
+++ b/sys/vm/vm_page.c
@@ -34,7 +34,7 @@
  * SUCH DAMAGE.
  *
  *	from: @(#)vm_page.c	7.4 (Berkeley) 5/7/91
- *	$Id: vm_page.c,v 1.95 1998/03/07 21:37:13 dyson Exp $
+ *	$Id: vm_page.c,v 1.96 1998/03/08 06:27:30 dyson Exp $
  */
 
 /*
@@ -1427,7 +1427,12 @@ vm_page_bits(int base, int size)
 
 	if ((base == 0) && (size >= PAGE_SIZE))
 		return VM_PAGE_BITS_ALL;
+
 	size = (size + DEV_BSIZE - 1) & ~(DEV_BSIZE - 1);
+	if (size > PAGE_SIZE - base) {
+		size = PAGE_SIZE - base;
+	}
+
 	base = (base % PAGE_SIZE) / DEV_BSIZE;
 	chunk = vm_page_dev_bsize_chunks[size / DEV_BSIZE];
 	return (chunk << base) & VM_PAGE_BITS_ALL;
@@ -1463,6 +1468,7 @@ vm_page_set_invalid(m, base, size)
 	m->valid &= ~(bits = vm_page_bits(base, size));
 	if (m->valid == 0)
 		m->dirty &= ~bits;
+	m->object->generation++;
 }
 
 /*
diff --git a/sys/vm/vm_pageout.c b/sys/vm/vm_pageout.c
index 7a2d81bd2d74..f4387fc76bdf 100644
--- a/sys/vm/vm_pageout.c
+++ b/sys/vm/vm_pageout.c
@@ -65,7 +65,7 @@
  * any improvements or extensions that they make and grant Carnegie the
  * rights to redistribute these changes.
  *
- * $Id: vm_pageout.c,v 1.118 1998/03/07 21:37:19 dyson Exp $
+ * $Id: vm_pageout.c,v 1.119 1998/03/08 18:19:17 dyson Exp $
  */
 
 /*
@@ -849,24 +849,9 @@ rescan0:
 	 */
 	page_shortage = (cnt.v_inactive_target + cnt.v_cache_min) -
 	    (cnt.v_free_count + cnt.v_inactive_count + cnt.v_cache_count);
+	page_shortage += addl_page_shortage;
 	if (page_shortage <= 0) {
-		if (pages_freed == 0) {
-			page_shortage = cnt.v_free_min - (cnt.v_free_count + cnt.v_cache_count);
-		} else {
-			page_shortage = 1;
-		}
-	}
-
-	/*
-	 * If the "inactive" loop finds that there is a shortage over and
-	 * above the page statistics variables, then we need to accomodate
-	 * that.  This avoids potential deadlocks due to pages being temporarily
-	 * busy for I/O or other types of temporary wiring.
-	 */
-	if (addl_page_shortage) {
-		if (page_shortage < 0)
-			page_shortage = 0;
-		page_shortage += addl_page_shortage;
+		page_shortage = 0;
 	}
 
 	pcount = cnt.v_active_count;
@@ -1070,6 +1055,12 @@ vm_pageout_page_stats()
 	vm_page_t m,next;
 	int pcount,tpcount;		/* Number of pages to check */
 	static int fullintervalcount = 0;
+	int page_shortage;
+
+	page_shortage = (cnt.v_inactive_target + cnt.v_cache_max + cnt.v_free_min) -
+	    (cnt.v_free_count + cnt.v_inactive_count + cnt.v_cache_count);
+	if (page_shortage <= 0)
+		return;
 
 	pcount = cnt.v_active_count;
 	fullintervalcount += vm_pageout_stats_interval;
@@ -1211,7 +1202,7 @@ vm_pageout()
 	 * Set interval in seconds for stats scan.
 	 */
 	if (vm_pageout_stats_interval == 0)
-		vm_pageout_stats_interval = 4;
+		vm_pageout_stats_interval = 5;
 	if (vm_pageout_full_stats_interval == 0)
 		vm_pageout_full_stats_interval = vm_pageout_stats_interval * 4;
 	
@@ -1220,7 +1211,7 @@ vm_pageout()
 	 * Set maximum free per pass
 	 */
 	if (vm_pageout_stats_free_max == 0)
-		vm_pageout_stats_free_max = 25;
+		vm_pageout_stats_free_max = 5;
 
 	max_page_launder = (cnt.v_page_count > 1800 ? 32 : 16);
 
diff --git a/sys/vm/vm_pager.c b/sys/vm/vm_pager.c
index 0f1140814bf2..2dc6e7b4e413 100644
--- a/sys/vm/vm_pager.c
+++ b/sys/vm/vm_pager.c
@@ -61,7 +61,7 @@
  * any improvements or extensions that they make and grant Carnegie the
  * rights to redistribute these changes.
  *
- * $Id: vm_pager.c,v 1.35 1998/02/23 08:22:40 dyson Exp $
+ * $Id: vm_pager.c,v 1.36 1998/03/07 21:37:21 dyson Exp $
  */
 
 /*
@@ -90,11 +90,85 @@ extern struct pagerops swappagerops;
 extern struct pagerops vnodepagerops;
 extern struct pagerops devicepagerops;
 
+static int dead_pager_getpages __P((vm_object_t, vm_page_t *, int, int));
+static vm_object_t dead_pager_alloc __P((void *, vm_size_t, vm_prot_t,
+	vm_ooffset_t));
+static int dead_pager_putpages __P((vm_object_t, vm_page_t *, int, int, int *));
+static boolean_t dead_pager_haspage __P((vm_object_t, vm_pindex_t, int *, int *));
+static void dead_pager_dealloc __P((vm_object_t));
+
+int
+dead_pager_getpages(obj, ma, count, req)
+	vm_object_t obj;
+	vm_page_t *ma;
+	int count;
+	int req;
+{
+	return VM_PAGER_FAIL;
+}
+
+vm_object_t
+dead_pager_alloc(handle, size, prot, off)
+	void *handle;
+	vm_size_t size;
+	vm_prot_t prot;
+	vm_ooffset_t off;
+{
+	return NULL;
+}
+
+int
+dead_pager_putpages(object, m, count, flags, rtvals)
+	vm_object_t object;
+	vm_page_t *m;
+	int count;
+	int flags;
+	int *rtvals;
+{
+	int i;
+	for (i = 0; i < count; i++) {
+		rtvals[i] = VM_PAGER_AGAIN;
+	}
+	return VM_PAGER_AGAIN;
+}
+
+int
+dead_pager_haspage(object, pindex, prev, next)
+	vm_object_t object;
+	vm_pindex_t pindex;
+	int *prev;
+	int *next;
+{
+	if (prev)
+		*prev = 0;
+	if (next)
+		*next = 0;
+	return FALSE;
+}
+
+void
+dead_pager_dealloc(object)
+	vm_object_t object;
+{
+	return;
+}
+
+struct pagerops deadpagerops = {
+	NULL,
+	dead_pager_alloc,
+	dead_pager_dealloc,
+	dead_pager_getpages,
+	dead_pager_putpages,
+	dead_pager_haspage,
+	NULL
+};
+
 static struct pagerops *pagertab[] = {
 	&defaultpagerops,	/* OBJT_DEFAULT */
 	&swappagerops,		/* OBJT_SWAP */
 	&vnodepagerops,		/* OBJT_VNODE */
 	&devicepagerops,	/* OBJT_DEVICE */
+	&deadpagerops		/* OBJT_DEAD */
 };
 static int npagers = sizeof(pagertab) / sizeof(pagertab[0]);
 
diff --git a/sys/vm/vnode_pager.c b/sys/vm/vnode_pager.c
index 720db22df93a..7ea6c8656af6 100644
--- a/sys/vm/vnode_pager.c
+++ b/sys/vm/vnode_pager.c
@@ -38,7 +38,7 @@
  * SUCH DAMAGE.
  *
  *	from: @(#)vnode_pager.c	7.5 (Berkeley) 4/20/91
- *	$Id: vnode_pager.c,v 1.89 1998/03/07 21:37:31 dyson Exp $
+ *	$Id: vnode_pager.c,v 1.90 1998/03/09 08:58:53 msmith Exp $
  */
 
 /*
@@ -926,6 +926,8 @@ vnode_pager_lock(object)
 
 		while (vget(object->handle,
 			LK_NOPAUSE | LK_SHARED | LK_RETRY | LK_CANRECURSE, p)) {
+			if ((object->flags & OBJ_DEAD) || (object->type != OBJT_VNODE))
+				return NULL;
 			printf("vnode_pager_lock: retrying\n");
 		}
 		return object->handle;