Changed the registry name from zfs_abd_prealloc_percent to zfs_prealloc_percent

Setting zfs_prealloc_percent=0 will disable the prealloc feature

Author: arun-kv

include/os/windows/zfs/sys/kstat_windows.h

@@ -150,7 +150,7 @@ typedef struct windows_kstat {
 	kstat_named_t zfs_removal_suspend_progress;
 	kstat_named_t cpu_avx_supported;
 	kstat_named_t zvol_io_threads;
-	kstat_named_t zfs_abd_prealloc_percent;
+	kstat_named_t zfs_prealloc_percent;
 } windows_kstat_t;
 
 
@@ -262,7 +262,7 @@ extern int zfs_autoimport_disable;
 extern int zfs_removal_suspend_progress;
 extern int cpu_avx_supported;
 extern int zvol_threads;
-extern int zfs_abd_prealloc_percent;
+extern int zfs_prealloc_percent;
 
 int  kstat_windows_init(void *);
 void kstat_windows_fini(void);

module/os/windows/spl/spl-kmem.c

@@ -132,6 +132,10 @@ extern uint64_t		zfs_active_rwlock;
 extern uint64_t		total_memory;
 extern uint64_t		real_total_memory;
 
+extern kmem_cache_t *abd_chunk_cache;
+extern uint64_t zfs_arc_max;
+extern int zfs_prealloc_percent;
+
 #define	MULT 1
 
 static const char *KMEM_VA_PREFIX = "kmem_va";
@@ -4304,10 +4308,7 @@ spl_free_set_pressure(int64_t new_p)
 		// and any spl_free_set_and_wait_pressure() threads
 		cv_broadcast(&spl_free_thread_cv);
 	}
-	if (new_p > 0)
-		spl_free_last_pressure = zfs_lbolt();
-	else
-		spl_free_last_pressure = zfs_lbolt();
+	spl_free_last_pressure = zfs_lbolt();
 }
 
 void
@@ -4923,10 +4924,6 @@ spl_event_thread(void *notused)
 	thread_exit();
 }
 
-extern kmem_cache_t *abd_chunk_cache;
-extern uint64_t zfs_arc_max;
-extern int zfs_abd_prealloc_percent;
-
 static void
 spl_abd_prealloc_thread(void *notused)
 {
@@ -4952,13 +4949,14 @@ spl_abd_prealloc_thread(void *notused)
 			delay(hz);
 			continue;
 		}
-		node = (abd_prealloc_node_t *)kmem_cache_alloc(abd_chunk_cache, KM_SLEEP);
-		list_insert_tail(&abd_prealloc_list, node);
 
 		if (segkmem_total_mem_allocated >=
-                    (zfs_arc_max * zfs_abd_prealloc_percent) / 100) {
+                    (zfs_arc_max * zfs_prealloc_percent) / 100) {
                         break;
                 }
+
+		node = (abd_prealloc_node_t *)kmem_cache_alloc(abd_chunk_cache, KM_SLEEP);
+		list_insert_tail(&abd_prealloc_list, node);
 	}
 
 	while ((node = list_remove_head(&abd_prealloc_list)) != NULL) {
@@ -4969,7 +4967,7 @@ spl_abd_prealloc_thread(void *notused)
 	dprintf("SPL: %s thread_exit\n", __func__);
 
 	KdPrintEx((DPFLTR_IHVDRIVER_ID, DPFLTR_ERROR_LEVEL, "SPL: abd prealloc done segkmem_total_mem_allocated: %lld total_memory: %lld zfs_arc_max: %llu zfs_prealloc_percent: %d%\n",
-	    segkmem_total_mem_allocated, total_memory, zfs_arc_max, zfs_abd_prealloc_percent));
+	    segkmem_total_mem_allocated, total_memory, zfs_arc_max, zfs_prealloc_percent));
 	thread_exit();
 }
 
@@ -5401,11 +5399,13 @@ spl_kmem_thread_init(void)
 	(void) thread_create(NULL, 0, spl_free_thread, 0, 0, 0, 0, 92);
 	spl_free_thread_running = TRUE;
 
-	//spl_event_thread_exit = FALSE;
-	//(void) thread_create(NULL, 0, spl_event_thread, 0, 0, 0, 0, 92);
-
-	spl_abd_prealloc_thread_exit = FALSE;
-	(void) thread_create(NULL, 0, spl_abd_prealloc_thread, 0, 0, 0, 0, 92);
+	if (zfs_prealloc_percent) {
+		spl_abd_prealloc_thread_exit = FALSE;
+		(void) thread_create(NULL, 0, spl_abd_prealloc_thread, 0, 0, 0, 0, 92);
+	} else {
+		spl_event_thread_exit = FALSE;
+		(void) thread_create(NULL, 0, spl_event_thread, 0, 0, 0, 0, 92);
+	}
 }
 
 void

module/os/windows/spl/spl-vmem.c

@@ -449,6 +449,7 @@ extern void spl_free_set_emergency_pressure(int64_t p);
 extern uint64_t segkmem_total_mem_allocated;
 extern uint64_t total_memory;
 extern uint64_t zfs_arc_max;
+extern int zfs_prealloc_percent;
 
 /*
  * Get a vmem_seg_t from the global segfree list.
@@ -1734,19 +1735,22 @@ vmem_xfree(vmem_t *vmp, void *vaddr, size_t size)
 	}
 
 	// calling vm_source_free will free the memory to windows, we
-	// don;t want to do this unless we are near the arc limit
-	boolean_t skip_sfree = true;
-	if (segkmem_total_mem_allocated >
-		(zfs_arc_max * 102) / 100) {
-		skip_sfree = false;
-        }
+	// don't want to do this unless we are crossing the arc limit when
+	// zfs_prealloc_percent is enabled.
+	boolean_t allow_vm_source_free = true;
+	if (zfs_prealloc_percent) {
+		if (segkmem_total_mem_allocated <
+			(zfs_arc_max * 102) / 100) {
+			allow_vm_source_free = false;
+		}
+	}
 
 	/*
 	 * If the entire span is free, return it to the source.
 	 */
 	if (vsp->vs_aprev->vs_import && vmp->vm_source_free != NULL &&
 	    vsp->vs_aprev->vs_type == VMEM_SPAN &&
-	    vsp->vs_anext->vs_type == VMEM_SPAN && !skip_sfree) {
+	    vsp->vs_anext->vs_type == VMEM_SPAN && allow_vm_source_free) {
 		vaddr = (void *)vsp->vs_start;
 		size = VS_SIZE(vsp);
 		ASSERT(size == VS_SIZE(vsp->vs_aprev));

module/os/windows/spl/spl-windows.c

@@ -53,12 +53,14 @@ volatile unsigned int vm_page_speculative_count = 5500;
 
 uint64_t spl_GetPhysMem(void);
 uint64_t spl_GetZfsTotalMemory(PUNICODE_STRING RegistryPath);
+uint64_t spl_getZfsPreallocSize(PUNICODE_STRING RegistryPath);
 
 #include <sys/types.h>
 #include <Trace.h>
 
 // Size in bytes of the memory allocated in seg_kmem
 extern uint64_t	segkmem_total_mem_allocated;
+extern int zfs_prealloc_percent;
 #define	MAXHOSTNAMELEN 64
 extern char hostname[MAXHOSTNAMELEN];
 
@@ -528,6 +530,9 @@ spl_start(PUNICODE_STRING RegistryPath)
 	spl_mutex_subsystem_init();
 	spl_kmem_init(total_memory);
 
+	// lets get the registry value now, because the zfs loads the registry little later
+	zfs_prealloc_percent = spl_getZfsPreallocSize(RegistryPath);
+
 	spl_vnode_init();
 	spl_kmem_thread_init();
 	spl_kmem_mp_init();
@@ -755,3 +760,91 @@ spl_GetZfsTotalMemory(PUNICODE_STRING RegistryPath)
 	ZwClose(h);
 	return (newvalue);
 }
+
+uint64_t
+spl_getZfsPreallocSize(PUNICODE_STRING RegistryPath)
+{
+	OBJECT_ATTRIBUTES		ObjectAttributes;
+	HANDLE				h;
+	NTSTATUS			status;
+	uint64_t			newvalue = 0;
+
+	InitializeObjectAttributes(&ObjectAttributes,
+	    RegistryPath,
+	    OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
+	    NULL,
+	    NULL);
+
+	status = ZwOpenKey(&h, // KeyHandle
+	    KEY_ALL_ACCESS, // DesiredAccess
+	    &ObjectAttributes); // ObjectAttributes
+
+	if (!NT_SUCCESS(status)) {
+		dprintf("%s: Unable to open Registry %wZ: 0x%x. "
+		    "Going with defaults.\n", __func__, RegistryPath, status);
+		return (0);
+	}
+
+	ULONG index = 0;
+	ULONG length = 0;
+	PKEY_VALUE_FULL_INFORMATION    regBuffer = NULL;
+
+	for (index = 0; status != STATUS_NO_MORE_ENTRIES; index++) {
+		// Get the buffer size necessary
+		status = ZwEnumerateValueKey(h, index, KeyValueFullInformation,
+		    NULL, 0, &length);
+
+		if ((status != STATUS_BUFFER_TOO_SMALL) &&
+		    (status != STATUS_BUFFER_OVERFLOW))
+			break; // Something is wrong - or we finished
+
+		// Allocate space to hold
+		regBuffer = (PKEY_VALUE_FULL_INFORMATION)ExAllocatePoolWithTag(
+		    NonPagedPoolNx, length, 'zfsr');
+
+		if (regBuffer == NULL)
+			break;
+
+		status = ZwEnumerateValueKey(h, index, KeyValueFullInformation,
+		    regBuffer, length, &length);
+		if (!NT_SUCCESS(status)) {
+			break;
+		}
+		// Convert name to straight ascii so we compare with kstat
+		ULONG outlen = 0;
+		char keyname[KSTAT_STRLEN + 1] = { 0 };
+		status = RtlUnicodeToUTF8N(keyname, KSTAT_STRLEN, &outlen,
+		    regBuffer->Name, regBuffer->NameLength);
+
+		// Conversion failed? move along..
+		if (status != STATUS_SUCCESS && status
+		    != STATUS_SOME_NOT_MAPPED)
+			break;
+
+		// Output string is only null terminated if input is,
+		// so do so now.
+		keyname[outlen] = 0;
+		if (strcasecmp("zfs_prealloc_percent", keyname) == 0) {
+			if (regBuffer->Type != REG_DWORD ||
+			    regBuffer->DataLength != sizeof (uint32_t)) {
+				dprintf("%s: registry '%s' did not match. "
+				    "Type needs to be REG_QWORD. (8 bytes)\n",
+				    __func__, keyname);
+			} else {
+				newvalue = *(uint32_t *)((uint8_t *)regBuffer
+				    + regBuffer->DataOffset);
+				dprintf("%s: zfs_prealloc_percent is set to:"
+				    " %llu\n", __func__, newvalue);
+			}
+			break;
+		}
+		ExFreePool(regBuffer);
+		regBuffer = NULL;
+	}
+
+	if (regBuffer)
+		ExFreePool(regBuffer);
+
+	ZwClose(h);
+	return (newvalue);
+}

module/os/windows/zfs/arc_os.c

@@ -696,7 +696,7 @@ arc_kstat_update_windows(kstat_t *ksp, int rw)
 		zfs_arc_average_blocksize =
 		    ks->arc_zfs_arc_average_blocksize.value.ui64;
 		zvol_threads = ks->zvol_io_threads.value.ui32;
-		zfs_abd_prealloc_percent = ks->zfs_abd_prealloc_percent.value.ui32;
+		zfs_prealloc_percent = ks->zfs_prealloc_percent.value.ui32;
 
 #ifdef _KERNEL
 		if (ks->zfs_total_memory_limit.value.ui64 > total_memory &&
@@ -732,7 +732,7 @@ arc_kstat_update_windows(kstat_t *ksp, int rw)
 		ks->arc_zfs_arc_average_blocksize.value.ui64 =
 		    zfs_arc_average_blocksize;
 		ks->zvol_io_threads.value.ui32 = zvol_threads;
-		ks->zfs_abd_prealloc_percent.value.ui32 = zfs_abd_prealloc_percent;
+		ks->zfs_prealloc_percent.value.ui32 = zfs_prealloc_percent;
 
 #ifdef _KERNEL
 		ks->zfs_total_memory_limit.value.ui64 = total_memory;

module/os/windows/zfs/zfs_kstat_windows.c

@@ -174,7 +174,7 @@ windows_kstat_t windows_kstat = {
 	{ "zfs_removal_suspend_progress",	KSTAT_DATA_INT32 },
 	{ "cpu_avx_supported",			KSTAT_DATA_UINT32 },
 	{ "zvol_io_threads",			KSTAT_DATA_UINT32 },
-	{ "zfs_abd_prealloc_percent",		KSTAT_DATA_UINT32 },
+	{ "zfs_prealloc_percent",		KSTAT_DATA_UINT32 },
 };
 
 
@@ -384,8 +384,8 @@ windows_kstat_update(kstat_t *ksp, int rw)
 		    ks->zfs_removal_suspend_progress.value.i32;
 		cpu_avx_supported =
 		    ks->cpu_avx_supported.value.ui32;
-		zfs_abd_prealloc_percent =
-		    ks->zfs_abd_prealloc_percent.value.ui32;
+		zfs_prealloc_percent =
+		    ks->zfs_prealloc_percent.value.ui32;
 	} else {
 
 		/* kstat READ */
@@ -576,8 +576,8 @@ windows_kstat_update(kstat_t *ksp, int rw)
 		    cpu_avx_supported;
 		ks->zvol_io_threads.value.ui32 =
 		    zvol_threads;
-		ks->zfs_abd_prealloc_percent.value.ui32 =
-		    zfs_abd_prealloc_percent;
+		ks->zfs_prealloc_percent.value.ui32 =
+		    zfs_prealloc_percent;
 	}
 	arc_kstat_update_windows(ksp, rw);
 	return (0);

module/os/windows/zfs/zvol_os.c

@@ -46,7 +46,7 @@ unsigned int zvol_request_sync = 0;
 unsigned int zvol_prefetch_bytes = (128 * 1024);
 unsigned long zvol_max_discard_blocks = 16384;
 int zvol_threads = 0;
-int zfs_abd_prealloc_percent = 10;
+int zfs_prealloc_percent = 0;
 
 taskq_t *zvol_taskq;