Index: sys/vm/vm_map.c
===================================================================
--- sys/vm/vm_map.c	(revision 362180)
+++ sys/vm/vm_map.c	(working copy)
@@ -3097,7 +3097,7 @@ vm_map_wire_locked(vm_map_t map, vm_offset_t start
 	u_long npages;
 	u_int last_timestamp;
 	int rv;
-	boolean_t need_wakeup, result, user_wire;
+	boolean_t need_wakeup, result, user_wire, user_wire_limit;
 	vm_prot_t prot;
 
 	VM_MAP_ASSERT_LOCKED(map);
@@ -3108,6 +3108,7 @@ vm_map_wire_locked(vm_map_t map, vm_offset_t start
 	if (flags & VM_MAP_WIRE_WRITE)
 		prot |= VM_PROT_WRITE;
 	user_wire = (flags & VM_MAP_WIRE_USER) ? TRUE : FALSE;
+	user_wire_limit = (flags & VM_MAP_WIRE_USER_LIMIT) ? TRUE : FALSE;
 	VM_MAP_RANGE_CHECK(map, start, end);
 	if (!vm_map_lookup_entry(map, start, &first_entry)) {
 		if (flags & VM_MAP_WIRE_HOLESOK)
@@ -3188,7 +3189,8 @@ vm_map_wire_locked(vm_map_t map, vm_offset_t start
 			entry->wired_count++;
 
 			npages = atop(entry->end - entry->start);
-			if (user_wire && !vm_map_wire_user_count_add(npages)) {
+			if (user_wire_limit &&
+			    !vm_map_wire_user_count_add(npages)) {
 				vm_map_wire_entry_failure(map, entry,
 				    entry->start);
 				end = entry->end;
@@ -3250,7 +3252,7 @@ vm_map_wire_locked(vm_map_t map, vm_offset_t start
 			last_timestamp = map->timestamp;
 			if (rv != KERN_SUCCESS) {
 				vm_map_wire_entry_failure(map, entry, faddr);
-				if (user_wire)
+				if (user_wire_limit)
 					vm_map_wire_user_count_sub(npages);
 				end = entry->end;
 				goto done;
@@ -3319,7 +3321,7 @@ done:
 			 */
 			if (entry->wired_count == 1) {
 				vm_map_entry_unwire(map, entry);
-				if (user_wire)
+				if (user_wire_limit)
 					vm_map_wire_user_count_sub(
 					    atop(entry->end - entry->start));
 			} else
@@ -4455,7 +4457,8 @@ retry:
 	if (rv == KERN_SUCCESS && (map->flags & MAP_WIREFUTURE) != 0) {
 		rv = vm_map_wire_locked(map, grow_start,
 		    grow_start + grow_amount,
-		    VM_MAP_WIRE_USER | VM_MAP_WIRE_NOHOLES);
+		    VM_MAP_WIRE_USER | VM_MAP_WIRE_USER_LIMIT |
+		    VM_MAP_WIRE_NOHOLES);
 	}
 	vm_map_lock_downgrade(map);
 
Index: sys/vm/vm_map.h
===================================================================
--- sys/vm/vm_map.h	(revision 362180)
+++ sys/vm/vm_map.h	(working copy)
@@ -397,6 +397,8 @@ long vmspace_resident_count(struct vmspace *vmspac
 
 #define VM_MAP_WIRE_WRITE	4	/* Validate writable. */
 
+#define	VM_MAP_WIRE_USER_LIMIT	8	/* Enfore the user wiring limit */
+
 #ifdef _KERNEL
 boolean_t vm_map_check_protection (vm_map_t, vm_offset_t, vm_offset_t, vm_prot_t);
 vm_map_t vm_map_create(pmap_t, vm_offset_t, vm_offset_t);
Index: sys/vm/vm_mmap.c
===================================================================
--- sys/vm/vm_mmap.c	(revision 362180)
+++ sys/vm/vm_mmap.c	(working copy)
@@ -1046,7 +1046,7 @@ kern_mlock(struct proc *proc, struct ucred *cred,
 	}
 #endif
 	error = vm_map_wire(map, start, end,
-	    VM_MAP_WIRE_USER | VM_MAP_WIRE_NOHOLES);
+	    VM_MAP_WIRE_USER | VM_MAP_WIRE_USER_LIMIT | VM_MAP_WIRE_NOHOLES);
 #ifdef RACCT
 	if (racct_enable && error != KERN_SUCCESS) {
 		PROC_LOCK(proc);
@@ -1111,7 +1111,8 @@ sys_mlockall(struct thread *td, struct mlockall_ar
 		 * calling vm_fault_wire() for each page in the region.
 		 */
 		error = vm_map_wire(map, vm_map_min(map), vm_map_max(map),
-		    VM_MAP_WIRE_USER|VM_MAP_WIRE_HOLESOK);
+		    VM_MAP_WIRE_USER | VM_MAP_WIRE_USER_LIMIT |
+		    VM_MAP_WIRE_HOLESOK);
 		if (error == KERN_SUCCESS)
 			error = 0;
 		else if (error == KERN_RESOURCE_SHORTAGE)
@@ -1589,6 +1590,7 @@ vm_mmap_object(vm_map_t map, vm_offset_t *addr, vm
 			if ((map->flags & MAP_WIREFUTURE) != 0)
 				(void)vm_map_wire_locked(map, *addr,
 				    *addr + size, VM_MAP_WIRE_USER |
+				    VM_MAP_WIRE_USER_LIMIT |
 				    ((flags & MAP_STACK) ? VM_MAP_WIRE_HOLESOK :
 				    VM_MAP_WIRE_NOHOLES));
 			vm_map_unlock(map);
Index: sys/vm/vm_unix.c
===================================================================
--- sys/vm/vm_unix.c	(revision 362180)
+++ sys/vm/vm_unix.c	(working copy)
@@ -185,7 +185,8 @@ kern_break(struct thread *td, uintptr_t *addr)
 		    0);
 		if (rv == KERN_SUCCESS && (map->flags & MAP_WIREFUTURE) != 0) {
 			rv = vm_map_wire_locked(map, old, new,
-			    VM_MAP_WIRE_USER | VM_MAP_WIRE_NOHOLES);
+			    VM_MAP_WIRE_USER | VM_MAP_WIRE_USER_LIMIT |
+			    VM_MAP_WIRE_NOHOLES);
 			if (rv != KERN_SUCCESS)
 				vm_map_delete(map, old, new);
 		}