--- Gnu-Mach/vm/vm_pageout.c	2020/09/02 04:42:52	1.1.1.2
+++ Gnu-Mach/vm/vm_pageout.c	2020/09/02 04:50:01	1.1.1.5
@@ -34,23 +34,24 @@
  *	The proverbial page-out daemon.
  */
 
-#include <mach_pagemap.h>
-#include <norma_vm.h>
-
+#include <device/net_io.h>
 #include <mach/mach_types.h>
 #include <mach/memory_object.h>
-#include "memory_object_default.h"
-#include "memory_object_user.h"
+#include <vm/memory_object_default.user.h>
+#include <vm/memory_object_user.user.h>
 #include <mach/vm_param.h>
 #include <mach/vm_statistics.h>
 #include <kern/counters.h>
+#include <kern/debug.h>
+#include <kern/slab.h>
+#include <kern/task.h>
 #include <kern/thread.h>
 #include <vm/pmap.h>
 #include <vm/vm_map.h>
 #include <vm/vm_object.h>
 #include <vm/vm_page.h>
 #include <vm/vm_pageout.h>
-#include <machine/vm_tuning.h>
+#include <machine/locore.h>
 
 
 
@@ -96,7 +97,7 @@
  */
 
 #ifndef	VM_PAGE_FREE_TARGET
-#define	VM_PAGE_FREE_TARGET(free)	(15 + (free) / 80)
+#define	VM_PAGE_FREE_TARGET(free)	(150 + (free) * 10 / 100)
 #endif	/* VM_PAGE_FREE_TARGET */
 
 /*
@@ -105,7 +106,7 @@
  */
 
 #ifndef	VM_PAGE_FREE_MIN
-#define	VM_PAGE_FREE_MIN(free)	(10 + (free) / 100)
+#define	VM_PAGE_FREE_MIN(free)	(100 + (free) * 8 / 100)
 #endif	/* VM_PAGE_FREE_MIN */
 
 /*      When vm_page_external_count exceeds vm_page_external_limit, 
@@ -131,7 +132,7 @@
  *	operation by dipping into the reserved pool of pages.  */
 
 #ifndef	VM_PAGE_FREE_RESERVED
-#define	VM_PAGE_FREE_RESERVED			50
+#define	VM_PAGE_FREE_RESERVED			500
 #endif	/* VM_PAGE_FREE_RESERVED */
 
 /*
@@ -143,7 +144,7 @@
  */
 
 #ifndef	VM_PAGEOUT_RESERVED_INTERNAL
-#define	VM_PAGEOUT_RESERVED_INTERNAL(reserve)	((reserve) - 25)
+#define	VM_PAGEOUT_RESERVED_INTERNAL(reserve)	((reserve) - 250)
 #endif	/* VM_PAGEOUT_RESERVED_INTERNAL */
 
 /*
@@ -155,12 +156,9 @@
  */
 
 #ifndef	VM_PAGEOUT_RESERVED_REALLY
-#define	VM_PAGEOUT_RESERVED_REALLY(reserve)	((reserve) - 40)
+#define	VM_PAGEOUT_RESERVED_REALLY(reserve)	((reserve) - 400)
 #endif	/* VM_PAGEOUT_RESERVED_REALLY */
 
-extern void vm_pageout_continue();
-extern void vm_pageout_scan_continue();
-
 unsigned int vm_pageout_reserved_internal = 0;
 unsigned int vm_pageout_reserved_really = 0;
 
@@ -190,14 +188,6 @@ unsigned int vm_pageout_inactive_dirty =
 unsigned int vm_pageout_inactive_double = 0;	/* debugging */
 unsigned int vm_pageout_inactive_cleaned_external = 0;
 
-#if	NORMA_VM
-/*
- * Define them here, since they won't be defined by memory_object_user.h.
- */
-extern kern_return_t memory_object_data_initialize();
-extern kern_return_t memory_object_data_write();
-#endif	/* NORMA_VM */
-
 /*
  *	Routine:	vm_pageout_setup
  *	Purpose:
@@ -236,16 +226,16 @@ extern kern_return_t memory_object_data_
  *		not busy on exit.
  */
 vm_page_t
-vm_pageout_setup(m, paging_offset, new_object, new_offset, flush)
-	register vm_page_t	m;
-	vm_offset_t		paging_offset;
-	register vm_object_t	new_object;
-	vm_offset_t		new_offset;
-	boolean_t		flush;
+vm_pageout_setup(
+	vm_page_t		m,
+	vm_offset_t		paging_offset,
+	vm_object_t		new_object,
+	vm_offset_t		new_offset,
+	boolean_t		flush)
 {
-	register vm_object_t	old_object = m->object;
-	register vm_page_t	holding_page = 0; /*'=0'to quiet gcc warnings*/
-	register vm_page_t	new_m;
+	vm_object_t	old_object = m->object;
+	vm_page_t	holding_page = 0; /*'=0'to quiet gcc warnings*/
+	vm_page_t	new_m;
 
 	assert(m->busy && !m->absent && !m->fictitious);
 
@@ -423,15 +413,15 @@ vm_pageout_setup(m, paging_offset, new_o
  *		copy to a new page in a new object, if not.
  */
 void
-vm_pageout_page(m, initial, flush)
-	register vm_page_t	m;
-	boolean_t		initial;
-	boolean_t		flush;
+vm_pageout_page(
+	vm_page_t		m,
+	boolean_t		initial,
+	boolean_t		flush)
 {
 	vm_map_copy_t		copy;
-	register vm_object_t	old_object;
-	register vm_object_t	new_object;
-	register vm_page_t	holding_page;
+	vm_object_t		old_object;
+	vm_object_t		new_object;
+	vm_page_t		holding_page;
 	vm_offset_t		paging_offset;
 	kern_return_t		rc;
 	boolean_t		precious_clean;
@@ -517,7 +507,7 @@ vm_pageout_page(m, initial, flush)
  *	vm_page_free_wanted == 0.
  */
 
-void vm_pageout_scan()
+void vm_pageout_scan(void)
 {
 	unsigned int burst_count;
 	unsigned int want_pages;
@@ -551,23 +541,24 @@ void vm_pageout_scan()
 	 *	into an internal object and then immediately double-page it,
 	 *	sending it to the default pager.
 	 *
-	 *	consider_zone_gc should be last, because the other operations
-	 *	might return memory to zones.  When we pause we use
+	 *	slab_collect should be last, because the other operations
+	 *	might return memory to caches.  When we pause we use
 	 *	vm_pageout_scan_continue as our continuation, so we will
 	 *	reenter vm_pageout_scan periodically and attempt to reclaim
 	 *	internal memory even if we never reach vm_page_free_target.
 	 */
 
-    Restart:
 	stack_collect();
 	net_kmsg_collect();
 	consider_task_collect();
+	if (0)	/* XXX: pcb_collect doesn't do anything yet, so it is
+		   pointless to call consider_thread_collect.  */
 	consider_thread_collect();
-	consider_zone_gc();
+	slab_collect();
 
 	for (burst_count = 0;;) {
-		register vm_page_t m;
-		register vm_object_t object;
+		vm_page_t m;
+		vm_object_t object;
 		unsigned int free_count;
 
 		/*
@@ -585,7 +576,7 @@ void vm_pageout_scan()
 
 		while ((vm_page_inactive_count < vm_page_inactive_target) &&
 		       !queue_empty(&vm_page_queue_active)) {
-			register vm_object_t obj;
+			vm_object_t obj;
 
 			vm_pageout_active++;
 			m = (vm_page_t) queue_first(&vm_page_queue_active);
@@ -686,18 +677,8 @@ void vm_pageout_scan()
 			thread_will_wait_with_timeout(current_thread(), msecs);
 			counter(c_vm_pageout_scan_block++);
 			thread_block(vm_pageout_scan_continue);
-#ifndef CONTINUATIONS
-			/*
-			 *	Unfortunately, we don't have call_continuation
-			 *	so we can't rely on tail-recursion.
-			 */
-
-			vm_pageout_scan_continue();
-			goto Restart;
-#else	/* CONTINUATIONS */
 			call_continuation(vm_pageout_scan_continue);
 			/*NOTREACHED*/
-#endif	/* CONTINUATIONS */
 		}
 
 		vm_pageout_inactive++;
@@ -712,7 +693,7 @@ void vm_pageout_scan()
 		    if (want_pages || m->external)
 		      break;
 		    
-		    m = (vm_page_t) queue_next (m);
+		    m = (vm_page_t) queue_next (&m->pageq);
 		    if (!m)
 		      goto pause;
 		  }
@@ -781,6 +762,7 @@ void vm_pageout_scan()
 			vm_object_unlock(object);
 			vm_page_activate(m);
 			vm_stat.reactivations++;
+			current_task()->reactivations++;
 			vm_page_unlock_queues();
 			vm_pageout_inactive_used++;
 			continue;
@@ -873,7 +855,7 @@ void vm_pageout_scan()
 	}
 }
 
-void vm_pageout_scan_continue()
+void vm_pageout_scan_continue(void)
 {
 	/*
 	 *	We just paused to let the pagers catch up.
@@ -896,17 +878,15 @@ void vm_pageout_scan_continue()
 	}
 	vm_page_unlock_queues();
 
-#ifdef	CONTINUATIONS
 	vm_pageout_continue();
 	/*NOTREACHED*/
-#endif	/* CONTINUATIONS */
 }
 
 /*
  *	vm_pageout is the high level pageout daemon.
  */
 
-void vm_pageout_continue()
+void vm_pageout_continue(void)
 {
 	/*
 	 *	The pageout daemon is never done, so loop forever.
@@ -928,12 +908,13 @@ void vm_pageout_continue()
 	}
 }
 
-void vm_pageout()
+void vm_pageout(void)
 {
 	int		free_after_reserve;
 
 	current_thread()->vm_privilege = TRUE;
 	stack_privilege(current_thread());
+	thread_set_own_priority(0);
 
 	/*
 	 *	Initialize some paging parameters.