Index: sys/cddl/compat/opensolaris/kern/opensolaris_kmem.c
===================================================================
--- sys/cddl/compat/opensolaris/kern/opensolaris_kmem.c
+++ sys/cddl/compat/opensolaris/kern/opensolaris_kmem.c
@@ -135,21 +135,21 @@
  * SI_ORDER_SECOND.
  */
 u_int
-kmem_free_target(void)
+kmem_page_free_target(void)
 {
 
 	return (vm_cnt.v_free_target);
 }
 
 u_int
-kmem_free_min(void)
+kmem_page_free_min(void)
 {
 
 	return (vm_cnt.v_free_min);
 }
 
 u_int
-kmem_free_count(void)
+kmem_page_free_count(void)
 {
 
 	return (vm_cnt.v_free_count + vm_cnt.v_cache_count);
@@ -170,12 +170,19 @@
 }
 
 uint64_t
-kmem_used(void)
+kmem_map_used(void)
 {
 
 	return (vmem_size(kmem_arena, VMEM_ALLOC));
 }
 
+uint64_t
+kmem_map_free(void)
+{
+
+    	return (vmem_size(kmem_arena, VMEM_FREE));
+}
+
 static int
 kmem_std_constructor(void *mem, int size __unused, void *private, int flags)
 {
Index: sys/cddl/compat/opensolaris/sys/kmem.h
===================================================================
--- sys/cddl/compat/opensolaris/sys/kmem.h
+++ sys/cddl/compat/opensolaris/sys/kmem.h
@@ -66,16 +66,17 @@
 void *zfs_kmem_alloc(size_t size, int kmflags);
 void zfs_kmem_free(void *buf, size_t size);
 uint64_t kmem_size(void);
-uint64_t kmem_used(void);
+uint64_t kmem_map_used(void);
+uint64_t kmem_map_free(void);
 u_int kmem_page_count(void);
 
 /*
  * The return values from kmem_free_* are only valid once the pagedaemon
  * has been initialised, before then they return 0.
  */
-u_int kmem_free_count(void);
-u_int kmem_free_target(void);
-u_int kmem_free_min(void);
+u_int kmem_page_free_count(void);
+u_int kmem_page_free_target(void);
+u_int kmem_page_free_min(void);
 
 kmem_cache_t *kmem_cache_create(char *name, size_t bufsize, size_t align,
     int (*constructor)(void *, void *, int), void (*destructor)(void *, void *),
Index: sys/cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c
===================================================================
--- sys/cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c
+++ sys/cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c
@@ -210,7 +210,7 @@
 arc_free_target_init(void *unused __unused)
 {
 
-	zfs_arc_free_target = kmem_free_target();
+	zfs_arc_free_target = kmem_page_free_target();
 }
 SYSINIT(arc_free_target_init, SI_SUB_KTHREAD_PAGE, SI_ORDER_ANY,
     arc_free_target_init, NULL);
@@ -245,7 +245,7 @@
 	if (err != 0 || req->newptr == NULL)
 		return (err);
 
-	if (val < kmem_free_min())
+	if (val < kmem_page_free_min())
 		return (EINVAL);
 	if (val > kmem_page_count())
 		return (EINVAL);
@@ -2503,9 +2503,9 @@
 		return (1);
 	}
 
-	if (kmem_free_count() < zfs_arc_free_target) {
+	if (kmem_page_free_count() < zfs_arc_free_target) {
 		DTRACE_PROBE2(arc__reclaim_freetarget, uint64_t,
-		    kmem_free_count(), uint64_t, zfs_arc_free_target);
+		    kmem_page_free_count(), uint64_t, zfs_arc_free_target);
 		return (1);
 	}
 
@@ -2563,9 +2563,9 @@
 #else	/* sun */
 #ifdef __i386__
 	/* i386 has KVA limits that the raw page counts above don't consider */
-	if (kmem_used() > (kmem_size() * 3) / 4) {
+	if (kmem_map_used() > (kmem_size() * 3) / 4) {
 		DTRACE_PROBE2(arc__reclaim_used, uint64_t,
-		    kmem_used(), uint64_t, (kmem_size() * 3) / 4);
+		    kmem_map_used(), uint64_t, (kmem_size() * 3) / 4);
 		return (1);
 	}
 #endif
@@ -3946,8 +3946,7 @@
 arc_memory_throttle(uint64_t reserve, uint64_t txg)
 {
 #ifdef _KERNEL
-	uint64_t available_memory =
-	    ptoa((uintmax_t)vm_cnt.v_free_count + vm_cnt.v_cache_count);
+	uint64_t available_memory = ptob(kmem_page_free_count());
 	static uint64_t page_load = 0;
 	static uint64_t last_txg = 0;
 
@@ -3956,11 +3955,16 @@
 	available_memory =
 	    MIN(available_memory, vmem_size(heap_arena, VMEM_FREE));
 #endif
+#else	/* sun */
+#ifdef __i386__
+	available_memory = MIN(available_memory, ptob(kmem_map_free()));
+#endif
 #endif	/* sun */
 
-	if (vm_cnt.v_free_count + vm_cnt.v_cache_count >
-	    (uint64_t)physmem * arc_lotsfree_percent / 100)
+	if (kmem_page_free_count() >
+	    (uint64_t)physmem * arc_lotsfree_percent / 100) {
 		return (0);
+	}
 
 	if (txg > last_txg) {
 		last_txg = txg;
@@ -3972,8 +3976,10 @@
 	 * continue to let page writes occur as quickly as possible.
 	 */
 	if (curproc == pageproc) {
-		if (page_load > available_memory / 4)
+		if (page_load > MAX(ptob(kmem_page_free_min()),
+		    available_memory) / 4) {
 			return (SET_ERROR(ERESTART));
+		}
 		/* Note: reserve is inflated, so we deflate */
 		page_load += reserve / 8;
 		return (0);