Index: sys/ia64/ia64/pmap.c
===================================================================
--- sys/ia64/ia64/pmap.c	(revision 266482)
+++ sys/ia64/ia64/pmap.c	(working copy)
@@ -932,7 +932,7 @@ free_pv_chunk(struct pv_chunk *pc)
 	PV_STAT(pc_chunk_frees++);
 	/* entire chunk is free, return it */
 	m = PHYS_TO_VM_PAGE(IA64_RR_MASK((vm_offset_t)pc));
-	vm_page_unwire(m, 0);
+	vm_page_unwire(m, VM_PUNWIRE_INACTIVEQ);
 	vm_page_free(m);
 }
 
Index: sys/vm/vm_kern.c
===================================================================
--- sys/vm/vm_kern.c	(revision 266482)
+++ sys/vm/vm_kern.c	(working copy)
@@ -193,7 +193,7 @@ retry:
 				i -= PAGE_SIZE;
 				m = vm_page_lookup(object,
 				    OFF_TO_IDX(offset + i));
-				vm_page_unwire(m, 0);
+				vm_page_unwire(m, VM_PUNWIRE_INACTIVEQ);
 				vm_page_free(m);
 			}
 			vmem_free(vmem, addr, size);
@@ -367,7 +367,7 @@ retry:
 				i -= PAGE_SIZE;
 				m = vm_page_lookup(object,
 						   OFF_TO_IDX(offset + i));
-				vm_page_unwire(m, 0);
+				vm_page_unwire(m, VM_PUNWIRE_INACTIVEQ);
 				vm_page_free(m);
 			}
 			VM_OBJECT_WUNLOCK(object);
@@ -401,7 +401,7 @@ kmem_unback(vm_object_t object, vm_offset_t addr,
 	pmap_remove(kernel_pmap, addr, addr + size);
 	for (i = 0; i < size; i += PAGE_SIZE) {
 		m = vm_page_lookup(object, OFF_TO_IDX(offset + i));
-		vm_page_unwire(m, 0);
+		vm_page_unwire(m, VM_PUNWIRE_INACTIVEQ);
 		vm_page_free(m);
 	}
 	VM_OBJECT_WUNLOCK(object);
Index: sys/vm/vm_fault.c
===================================================================
--- sys/vm/vm_fault.c	(revision 266482)
+++ sys/vm/vm_fault.c	(working copy)
@@ -755,7 +755,8 @@ vnode_locked:
 					vm_page_unlock(fs.first_m);
 					
 					vm_page_lock(fs.m);
-					vm_page_unwire(fs.m, FALSE);
+					vm_page_unwire(fs.m,
+					    VM_PUNWIRE_INACTIVEQ);
 					vm_page_unlock(fs.m);
 				}
 				/*
@@ -917,7 +918,7 @@ vnode_locked:
 		if (wired)
 			vm_page_wire(fs.m);
 		else
-			vm_page_unwire(fs.m, 1);
+			vm_page_unwire(fs.m, VM_PUNWIRE_ACTIVEQ);
 	} else
 		vm_page_activate(fs.m);
 	if (m_hold != NULL) {
@@ -1208,7 +1209,7 @@ vm_fault_unwire(vm_map_t map, vm_offset_t start, v
 			if (!fictitious) {
 				m = PHYS_TO_VM_PAGE(pa);
 				vm_page_lock(m);
-				vm_page_unwire(m, TRUE);
+				vm_page_unwire(m, VM_PUNWIRE_ACTIVEQ);
 				vm_page_unlock(m);
 			}
 		}
@@ -1392,7 +1393,7 @@ again:
 		if (upgrade) {
 			if (src_m != dst_m) {
 				vm_page_lock(src_m);
-				vm_page_unwire(src_m, 0);
+				vm_page_unwire(src_m, VM_PUNWIRE_INACTIVEQ);
 				vm_page_unlock(src_m);
 				vm_page_lock(dst_m);
 				vm_page_wire(dst_m);
Index: sys/vm/vm_page.c
===================================================================
--- sys/vm/vm_page.c	(revision 266482)
+++ sys/vm/vm_page.c	(working copy)
@@ -147,7 +147,7 @@ static uma_zone_t fakepg_zone;
 static struct vnode *vm_page_alloc_init(vm_page_t m);
 static void vm_page_cache_turn_free(vm_page_t m);
 static void vm_page_clear_dirty_mask(vm_page_t m, vm_page_bits_t pagebits);
-static void vm_page_enqueue(int queue, vm_page_t m);
+static void vm_page_enqueue(uint8_t queue, vm_page_t m);
 static void vm_page_init_fakepg(void *dummy);
 static int vm_page_insert_after(vm_page_t m, vm_object_t object,
     vm_pindex_t pindex, vm_page_t mpred);
@@ -2029,8 +2029,8 @@ vm_page_dequeue(vm_page_t m)
 	struct vm_pagequeue *pq;
 
 	vm_page_assert_locked(m);
-	KASSERT(m->queue == PQ_ACTIVE || m->queue == PQ_INACTIVE,
-	    ("vm_page_dequeue: page %p is not queued", m));
+	KASSERT(m->queue < PQ_COUNT, ("vm_page_dequeue: page %p is not queued",
+	    m));
 	pq = vm_page_pagequeue(m);
 	vm_pagequeue_lock(pq);
 	m->queue = PQ_NONE;
@@ -2067,10 +2067,12 @@ vm_page_dequeue_locked(vm_page_t m)
  *	The page must be locked.
  */
 static void
-vm_page_enqueue(int queue, vm_page_t m)
+vm_page_enqueue(uint8_t queue, vm_page_t m)
 {
 	struct vm_pagequeue *pq;
 
+	KASSERT(queue < PQ_COUNT,
+	    ("vm_page_enqueue: invalid queue %d provided", queue));
 	vm_page_lock_assert(m, MA_OWNED);
 	pq = &vm_phys_domain(m)->vmd_pagequeues[queue];
 	vm_pagequeue_lock(pq);
@@ -2330,9 +2332,7 @@ vm_page_wire(vm_page_t m)
  *
  * Release one wiring of the specified page, potentially enabling it to be
  * paged again.  If paging is enabled, then the value of the parameter
- * "activate" determines to which queue the page is added.  If "activate" is
- * non-zero, then the page is added to the active queue.  Otherwise, it is
- * added to the inactive queue.
+ * "queue" determines to which queue the page is added.
  *
  * However, unless the page belongs to an object, it is not enqueued because
  * it cannot be paged out.
@@ -2342,8 +2342,9 @@ vm_page_wire(vm_page_t m)
  * A managed page must be locked.
  */
 void
-vm_page_unwire(vm_page_t m, int activate)
+vm_page_unwire(vm_page_t m, int queue)
 {
+	uint8_t pgqueue;
 
 	if ((m->oflags & VPO_UNMANAGED) == 0)
 		vm_page_lock_assert(m, MA_OWNED);
@@ -2352,6 +2353,17 @@ void
 	    ("vm_page_unwire: fictitious page %p's wire count isn't one", m));
 		return;
 	}
+	switch (queue) {
+	case VM_PUNWIRE_INACTIVEQ:
+		pgqueue = PQ_INACTIVE;
+		break;
+	case VM_PUNWIRE_ACTIVEQ:
+		pgqueue = PQ_ACTIVE;
+		break;
+	default:
+		panic("vm_page_unwire: invalid supplied queue %d for page %p",
+		    queue, m);
+	}
 	if (m->wire_count > 0) {
 		m->wire_count--;
 		if (m->wire_count == 0) {
@@ -2359,9 +2371,9 @@ void
 			if ((m->oflags & VPO_UNMANAGED) != 0 ||
 			    m->object == NULL)
 				return;
-			if (!activate)
+			if (pgqueue == PQ_INACTIVE)
 				m->flags &= ~PG_WINATCFLS;
-			vm_page_enqueue(activate ? PQ_ACTIVE : PQ_INACTIVE, m);
+			vm_page_enqueue(pgqueue, m);
 		}
 	} else
 		panic("vm_page_unwire: page %p's wire count is zero", m);
Index: sys/vm/vm_page.h
===================================================================
--- sys/vm/vm_page.h	(revision 266482)
+++ sys/vm/vm_page.h	(working copy)
@@ -394,6 +394,10 @@ vm_page_t PHYS_TO_VM_PAGE(vm_paddr_t pa);
 #define	VM_ALLOC_COUNT_SHIFT	16
 #define	VM_ALLOC_COUNT(count)	((count) << VM_ALLOC_COUNT_SHIFT)
 
+/* vm_page_unwire() flags. */
+#define	VM_PUNWIRE_INACTIVEQ	0
+#define	VM_PUNWIRE_ACTIVEQ	1
+
 #ifdef M_NOWAIT
 static inline int
 malloc2vm_flags(int malloc_flags)
Index: sys/vm/uma_core.c
===================================================================
--- sys/vm/uma_core.c	(revision 266482)
+++ sys/vm/uma_core.c	(working copy)
@@ -1151,7 +1151,7 @@ noobj_alloc(uma_zone_t zone, int bytes, uint8_t *f
 		 * exit.
 		 */
 		TAILQ_FOREACH_SAFE(p, &alloctail, listq, p_next) {
-			vm_page_unwire(p, 0);
+			vm_page_unwire(p, VM_PUNWIRE_INACTIVEQ);
 			vm_page_free(p); 
 		}
 		return (NULL);
Index: sys/vm/vm_glue.c
===================================================================
--- sys/vm/vm_glue.c	(revision 266482)
+++ sys/vm/vm_glue.c	(working copy)
@@ -418,7 +418,7 @@ vm_thread_stack_dispose(vm_object_t ksobj, vm_offs
 		if (m == NULL)
 			panic("vm_thread_dispose: kstack already missing?");
 		vm_page_lock(m);
-		vm_page_unwire(m, 0);
+		vm_page_unwire(m, VM_PUNWIRE_INACTIVEQ);
 		vm_page_free(m);
 		vm_page_unlock(m);
 	}
@@ -507,7 +507,7 @@ vm_thread_swapout(struct thread *td)
 			panic("vm_thread_swapout: kstack already missing?");
 		vm_page_dirty(m);
 		vm_page_lock(m);
-		vm_page_unwire(m, 0);
+		vm_page_unwire(m, VM_PUNWIRE_INACTIVEQ);
 		vm_page_unlock(m);
 	}
 	VM_OBJECT_WUNLOCK(ksobj);
Index: sys/i386/i386/pmap.c
===================================================================
--- sys/i386/i386/pmap.c	(revision 266482)
+++ sys/i386/i386/pmap.c	(working copy)
@@ -2368,7 +2368,7 @@ free_pv_chunk(struct pv_chunk *pc)
 	/* entire chunk is free, return it */
 	m = PHYS_TO_VM_PAGE(pmap_kextract((vm_offset_t)pc));
 	pmap_qremove((vm_offset_t)pc, 1);
-	vm_page_unwire(m, 0);
+	vm_page_unwire(m, VM_PUNWIRE_INACTIVEQ);
 	vm_page_free(m);
 	pmap_ptelist_free(&pv_vafree, (vm_offset_t)pc);
 }
Index: sys/i386/xen/pmap.c
===================================================================
--- sys/i386/xen/pmap.c	(revision 266482)
+++ sys/i386/xen/pmap.c	(working copy)
@@ -2144,7 +2144,7 @@ free_pv_chunk(struct pv_chunk *pc)
 	/* entire chunk is free, return it */
 	m = PHYS_TO_VM_PAGE(pmap_kextract((vm_offset_t)pc));
 	pmap_qremove((vm_offset_t)pc, 1);
-	vm_page_unwire(m, 0);
+	vm_page_unwire(m, VM_PUNWIRE_INACTIVEQ);
 	vm_page_free(m);
 	pmap_ptelist_free(&pv_vafree, (vm_offset_t)pc);
 }
Index: sys/amd64/amd64/pmap.c
===================================================================
--- sys/amd64/amd64/pmap.c	(revision 266482)
+++ sys/amd64/amd64/pmap.c	(working copy)
@@ -2868,7 +2868,7 @@ free_pv_chunk(struct pv_chunk *pc)
 	/* entire chunk is free, return it */
 	m = PHYS_TO_VM_PAGE(DMAP_TO_PHYS((vm_offset_t)pc));
 	dump_drop_page(m->phys_addr);
-	vm_page_unwire(m, 0);
+	vm_page_unwire(m, VM_PUNWIRE_INACTIVEQ);
 	vm_page_free(m);
 }
 
Index: sys/arm/arm/pmap-v6.c
===================================================================
--- sys/arm/arm/pmap-v6.c	(revision 266482)
+++ sys/arm/arm/pmap-v6.c	(working copy)
@@ -4221,7 +4221,7 @@ pmap_free_pv_chunk(struct pv_chunk *pc)
 	/* entire chunk is free, return it */
 	m = PHYS_TO_VM_PAGE(pmap_kextract((vm_offset_t)pc));
 	pmap_qremove((vm_offset_t)pc, 1);
-	vm_page_unwire(m, 0);
+	vm_page_unwire(m, VM_PUNWIRE_INACTIVEQ);
 	vm_page_free(m);
 	pmap_ptelist_free(&pv_vafree, (vm_offset_t)pc);
 
Index: sys/kern/vfs_bio.c
===================================================================
--- sys/kern/vfs_bio.c	(revision 266482)
+++ sys/kern/vfs_bio.c	(working copy)
@@ -1887,7 +1887,7 @@ vfs_vmio_release(struct buf *bp)
 		 * everything on the inactive queue.
 		 */
 		vm_page_lock(m);
-		vm_page_unwire(m, 0);
+		vm_page_unwire(m, VM_PUNWIRE_INACTIVEQ);
 
 		/*
 		 * Might as well free the page if we can and it has
@@ -3476,7 +3476,7 @@ allocbuf(struct buf *bp, int size)
 
 					bp->b_pages[i] = NULL;
 					vm_page_lock(m);
-					vm_page_unwire(m, 0);
+					vm_page_unwire(m, VM_PUNWIRE_INACTIVEQ);
 					vm_page_unlock(m);
 				}
 				VM_OBJECT_WUNLOCK(bp->b_bufobj->bo_object);
Index: sys/kern/uipc_syscalls.c
===================================================================
--- sys/kern/uipc_syscalls.c	(revision 266482)
+++ sys/kern/uipc_syscalls.c	(working copy)
@@ -1996,7 +1996,7 @@ sf_buf_mext(struct mbuf *mb, void *addr, void *arg
 	m = sf_buf_page(args);
 	sf_buf_free(args);
 	vm_page_lock(m);
-	vm_page_unwire(m, 0);
+	vm_page_unwire(m, VM_PUNWIRE_INACTIVEQ);
 	/*
 	 * Check for the object going away on us. This can
 	 * happen since we don't hold a reference to it.
@@ -2692,7 +2692,7 @@ sendfile_readpage(vm_object_t obj, struct vnode *v
 	} else if (m != NULL) {
 free_page:
 		vm_page_lock(m);
-		vm_page_unwire(m, 0);
+		vm_page_unwire(m, VM_PUNWIRE_INACTIVEQ);
 
 		/*
 		 * See if anyone else might know about this page.  If
@@ -3050,7 +3050,7 @@ retry_space:
 			if (sf == NULL) {
 				SFSTAT_INC(sf_allocfail);
 				vm_page_lock(pg);
-				vm_page_unwire(pg, 0);
+				vm_page_unwire(pg, VM_PUNWIRE_INACTIVEQ);
 				KASSERT(pg->object != NULL,
 				    ("%s: object disappeared", __func__));
 				vm_page_unlock(pg);
Index: sys/mips/mips/pmap.c
===================================================================
--- sys/mips/mips/pmap.c	(revision 266482)
+++ sys/mips/mips/pmap.c	(working copy)
@@ -1535,7 +1535,7 @@ free_pv_chunk(struct pv_chunk *pc)
 	PV_STAT(pc_chunk_frees++);
 	/* entire chunk is free, return it */
 	m = PHYS_TO_VM_PAGE(MIPS_DIRECT_TO_PHYS((vm_offset_t)pc));
-	vm_page_unwire(m, 0);
+	vm_page_unwire(m, VM_PUNWIRE_INACTIVEQ);
 	vm_page_free(m);
 }
 
Index: sys/dev/drm/via_dmablit.c
===================================================================
--- sys/dev/drm/via_dmablit.c	(revision 266482)
+++ sys/dev/drm/via_dmablit.c	(working copy)
@@ -179,7 +179,7 @@ via_free_sg_info(drm_via_sg_info_t *vsg)
 		for (i=0; i < vsg->num_pages; ++i) {
 			page = vsg->pages[i];
 			vm_page_lock(page);
-			vm_page_unwire(page, 0);
+			vm_page_unwire(page, VM_PUNWIRE_INACTIVEQ);
 			vm_page_unlock(page);
 		}
 	case dr_via_pages_alloc:
Index: sys/dev/drm2/i915/i915_gem.c
===================================================================
--- sys/dev/drm2/i915/i915_gem.c	(revision 266482)
+++ sys/dev/drm2/i915/i915_gem.c	(working copy)
@@ -1039,7 +1039,7 @@ i915_gem_swap_io(struct drm_device *dev, struct dr
 			vm_page_dirty(m);
 		vm_page_reference(m);
 		vm_page_lock(m);
-		vm_page_unwire(m, 1);
+		vm_page_unwire(m, VM_PUNWIRE_ACTIVEQ);
 		vm_page_unlock(m);
 		atomic_add_long(&i915_gem_wired_pages_cnt, -1);
 
@@ -2247,7 +2247,7 @@ failed:
 	for (j = 0; j < i; j++) {
 		m = obj->pages[j];
 		vm_page_lock(m);
-		vm_page_unwire(m, 0);
+		vm_page_unwire(m, VM_PUNWIRE_INACTIVEQ);
 		vm_page_unlock(m);
 		atomic_add_long(&i915_gem_wired_pages_cnt, -1);
 	}
@@ -2308,7 +2308,7 @@ i915_gem_object_put_pages_gtt(struct drm_i915_gem_
 		if (obj->madv == I915_MADV_WILLNEED)
 			vm_page_reference(m);
 		vm_page_lock(m);
-		vm_page_unwire(obj->pages[i], 1);
+		vm_page_unwire(obj->pages[i], VM_PUNWIRE_ACTIVEQ);
 		vm_page_unlock(m);
 		atomic_add_long(&i915_gem_wired_pages_cnt, -1);
 	}
@@ -3611,7 +3611,7 @@ i915_gem_detach_phys_object(struct drm_device *dev
 		vm_page_reference(m);
 		vm_page_lock(m);
 		vm_page_dirty(m);
-		vm_page_unwire(m, 0);
+		vm_page_unwire(m, VM_PUNWIRE_INACTIVEQ);
 		vm_page_unlock(m);
 		atomic_add_long(&i915_gem_wired_pages_cnt, -1);
 	}
@@ -3676,7 +3676,7 @@ i915_gem_attach_phys_object(struct drm_device *dev
 
 		vm_page_reference(m);
 		vm_page_lock(m);
-		vm_page_unwire(m, 0);
+		vm_page_unwire(m, VM_PUNWIRE_INACTIVEQ);
 		vm_page_unlock(m);
 		atomic_add_long(&i915_gem_wired_pages_cnt, -1);
 	}
Index: sys/dev/drm2/i915/i915_gem_gtt.c
===================================================================
--- sys/dev/drm2/i915/i915_gem_gtt.c	(revision 266482)
+++ sys/dev/drm2/i915/i915_gem_gtt.c	(working copy)
@@ -206,7 +206,7 @@ i915_gem_cleanup_aliasing_ppgtt(struct drm_device
 	for (i = 0; i < ppgtt->num_pd_entries; i++) {
 		m = ppgtt->pt_pages[i];
 		if (m != NULL) {
-			vm_page_unwire(m, 0);
+			vm_page_unwire(m, VM_PUNWIRE_INACTIVEQ);
 			vm_page_free(m);
 		}
 	}
Index: sys/dev/drm2/ttm/ttm_page_alloc.c
===================================================================
--- sys/dev/drm2/ttm/ttm_page_alloc.c	(revision 266482)
+++ sys/dev/drm2/ttm/ttm_page_alloc.c	(working copy)
@@ -139,7 +139,7 @@ ttm_vm_page_free(vm_page_t m)
 	KASSERT((m->oflags & VPO_UNMANAGED) == 0, ("ttm got unmanaged %p", m));
 	m->flags &= ~PG_FICTITIOUS;
 	m->oflags |= VPO_UNMANAGED;
-	vm_page_unwire(m, 0);
+	vm_page_unwire(m, VM_PUNWIRE_INACTIVEQ);
 	vm_page_free(m);
 }
 
Index: sys/dev/virtio/balloon/virtio_balloon.c
===================================================================
--- sys/dev/virtio/balloon/virtio_balloon.c	(revision 266482)
+++ sys/dev/virtio/balloon/virtio_balloon.c	(working copy)
@@ -450,7 +450,7 @@ static void
 vtballoon_free_page(struct vtballoon_softc *sc, vm_page_t m)
 {
 
-	vm_page_unwire(m, 0);
+	vm_page_unwire(m, VM_PUNWIRE_INACTIVEQ);
 	vm_page_free(m);
 	sc->vtballoon_current_npages--;
 }
Index: sys/dev/agp/agp_i810.c
===================================================================
--- sys/dev/agp/agp_i810.c	(revision 266482)
+++ sys/dev/agp/agp_i810.c	(working copy)
@@ -2009,7 +2009,7 @@ agp_i810_free_memory(device_t dev, struct agp_memo
 			VM_OBJECT_WLOCK(mem->am_obj);
 			m = vm_page_lookup(mem->am_obj, 0);
 			vm_page_lock(m);
-			vm_page_unwire(m, 0);
+			vm_page_unwire(m, VM_PUNWIRE_INACTIVEQ);
 			vm_page_unlock(m);
 			VM_OBJECT_WUNLOCK(mem->am_obj);
 		} else {
Index: sys/dev/agp/agp.c
===================================================================
--- sys/dev/agp/agp.c	(revision 266482)
+++ sys/dev/agp/agp.c	(working copy)
@@ -629,7 +629,7 @@ bad:
 		if (k >= i)
 			vm_page_xunbusy(m);
 		vm_page_lock(m);
-		vm_page_unwire(m, 0);
+		vm_page_unwire(m, VM_PUNWIRE_INACTIVEQ);
 		vm_page_unlock(m);
 	}
 	VM_OBJECT_WUNLOCK(mem->am_obj);
@@ -663,7 +663,7 @@ agp_generic_unbind_memory(device_t dev, struct agp
 	for (i = 0; i < mem->am_size; i += PAGE_SIZE) {
 		m = vm_page_lookup(mem->am_obj, atop(i));
 		vm_page_lock(m);
-		vm_page_unwire(m, 0);
+		vm_page_unwire(m, VM_PUNWIRE_INACTIVEQ);
 		vm_page_unlock(m);
 	}
 	VM_OBJECT_WUNLOCK(mem->am_obj);
Index: sys/dev/cxgbe/tom/t4_ddp.c
===================================================================
--- sys/dev/cxgbe/tom/t4_ddp.c	(revision 266482)
+++ sys/dev/cxgbe/tom/t4_ddp.c	(working copy)
@@ -869,7 +869,7 @@ unwire_ddp_buffer(struct ddp_buffer *db)
 	for (i = 0; i < db->npages; i++) {
 		p = db->pages[i];
 		vm_page_lock(p);
-		vm_page_unwire(p, 0);
+		vm_page_unwire(p, VM_PUNWIRE_INACTIVEQ);
 		vm_page_unlock(p);
 	}
 }
Index: sys/dev/ti/if_ti.c
===================================================================
--- sys/dev/ti/if_ti.c	(revision 266482)
+++ sys/dev/ti/if_ti.c	(working copy)
@@ -1616,7 +1616,7 @@ ti_newbuf_jumbo(struct ti_softc *sc, int idx, stru
 			}
 			sf[i] = sf_buf_alloc(frame, SFB_NOWAIT);
 			if (sf[i] == NULL) {
-				vm_page_unwire(frame, 0);
+				vm_page_unwire(frame, VM_PUNWIRE_INACTIVEQ);
 				vm_page_free(frame);
 				device_printf(sc->ti_dev, "buffer allocation "
 				    "failed -- packet dropped!\n");
Index: sys/dev/xen/balloon/balloon.c
===================================================================
--- sys/dev/xen/balloon/balloon.c	(revision 266482)
+++ sys/dev/xen/balloon/balloon.c	(working copy)
@@ -255,7 +255,7 @@ increase_reservation(unsigned long nr_pages)
 
 		set_phys_to_machine(pfn, frame_list[i]);
 
-		vm_page_unwire(page, 0);
+		vm_page_unwire(page, VM_PUNWIRE_INACTIVEQ);
 		vm_page_free(page);
 	}
 
@@ -297,7 +297,7 @@ decrease_reservation(unsigned long nr_pages)
 
 		set_phys_to_machine(pfn, INVALID_P2M_ENTRY);
 		if (balloon_append(page) != 0) {
-			vm_page_unwire(page, 0);
+			vm_page_unwire(page, VM_PUNWIRE_INACTIVEQ);
 			vm_page_free(page);
 
 			nr_pages = i;
Index: sys/net/bpf_zerocopy.c
===================================================================
--- sys/net/bpf_zerocopy.c	(revision 266482)
+++ sys/net/bpf_zerocopy.c	(working copy)
@@ -114,7 +114,7 @@ zbuf_page_free(vm_page_t pp)
 {
 
 	vm_page_lock(pp);
-	vm_page_unwire(pp, 0);
+	vm_page_unwire(pp, VM_PUNWIRE_INACTIVEQ);
 	if (pp->wire_count == 0 && pp->object == NULL)
 		vm_page_free(pp);
 	vm_page_unlock(pp);