* include/mach/memory_object.h: Add MEMORY_OBJECT_COPY_VMPRIV to mark objects that can't be blocked even if dirty page limits has been exceeded.k0ro/advisory_pageout/master

* vm/memory_object.c (memory_object_data_supply): Mark pages provided by user as external.
* (memory_object_lock_request): Lock page queues before cleaning holding pages.
* (memory_object_set_attributes_common): Deal with MEMORY_OBJECT_COPY_VMPRIV.

* vm/vm_fault.c (vm_fault_page): If the number of potentially dirty pages has reached a certain static number, either request a pageout or block the thread.
* (vm_fault_page): Force an early request for a real page instead of a fictitious one.

* vm/vm_object.h (struct vm_object): New flag vm_privileged that relates with MEMORY_OBJECT_COPY_PRIV.
* vm/vm_object.c (vm_object_bootstrap): Initialize vm_privileged property as FALSE.

* vm/vm_page.h: Add variables vm_page_too_dirty, vm_page_dirty_count and vm_page_external_target.

* vm/vm_pageout.c: Adjust VM_PAGE_FREE_TARGET, VM_PAGE_FREE_MIN and VM_PAGE_EXTERNAL_LIMIT. Make vm_page_external_target signed.
* (vm_pageout_setup): Write lock cleaned pages. Adjust dirty page counters.
* (vm_pageout_scan): Try freeing clean external pages first. Disable broken old code.

* vm/vm_resident.c: Add variables vm_page_too_dirty and vm_page_dirty_count.
* (vm_page_convert.c): Propagate external argument to converted page.
* (vm_page_grab): Don't use old external page limits.
* (vm_page_grab_contiguous_pages): Likewise.
* (vm_page_wait): Likewise.
* (vm_page_release): Don't adjust external count.
* (vm_page_free): Adjust external and external-dirty counters here. Wake up blocked threads.

1 files changed, 25 insertions, 1 deletions

diff --git a/vm/vm_fault.c b/vm/vm_fault.c
index cce043a1..1f911d84 100644
--- a/vm/vm_fault.c
+++ b/vm/vm_fault.c
@@ -509,6 +509,7 @@ vm_fault_return_t vm_fault_page(first_object, first_offset,
 			if (access_required & m->page_lock) {
 				if ((access_required & m->unlock_request) != access_required) {
 					vm_prot_t	new_unlock_request;
+					vm_size_t	ugly_hack = PAGE_SIZE;
 					kern_return_t	rc;
 
 					if (!object->pager_ready) {
@@ -518,6 +519,25 @@ vm_fault_return_t vm_fault_page(first_object, first_offset,
 						goto block_and_backoff;
 					}
 
+					/* XXX - These limits should be dynamic */
+					if (vm_page_dirty_count > 3000) {
+						if (!object->vm_privileged) {
+							printf("blocking not vm_privileged object\n");
+							vm_page_too_dirty++;
+							assert_wait((event_t)&vm_page_too_dirty, FALSE);
+							goto block_and_backoff;
+						}
+						else {
+							printf("NOT blocking vm_privileged object\n");
+						}
+					}
+					else if (vm_page_dirty_count > 2700 && !object->vm_privileged) {
+						ugly_hack++;
+					}
+
+					m->overwriting = TRUE;
+					vm_page_dirty_count++;
+
 					new_unlock_request = m->unlock_request =
 						(access_required | m->unlock_request);
 					vm_object_unlock(object);
@@ -525,7 +545,7 @@ vm_fault_return_t vm_fault_page(first_object, first_offset,
 						object->pager,
 						object->pager_request,
 						offset + object->paging_offset,
-						PAGE_SIZE,
+						ugly_hack,
 						new_unlock_request))
 					     != KERN_SUCCESS) {
 					     	printf("vm_fault: memory_object_data_unlock failed\n");
@@ -587,6 +607,10 @@ vm_fault_return_t vm_fault_page(first_object, first_offset,
 				vm_fault_cleanup(object, first_m);
 				return(VM_FAULT_FICTITIOUS_SHORTAGE);
 			}
+			else if (m->fictitious && !vm_page_convert(m, TRUE)) {
+				VM_PAGE_FREE(m);
+				vm_fault_cleanup(object, first_m);
+			}
 
 			vm_page_lock_queues();
 			vm_page_insert(m, object, offset);