Pull up following revision(s) (requested by mlelstv in ticket #1521): share/man/man9/kmem.9: revision 1.20 via patch share/man/man9/vmem.9: revision 1.16 sys/kern/subr_kmem.c: revision 1.62 sys/kern/subr_vmem.c: revision 1.94 fix vmem_alloc() to never return an error for VM_SLEEP requests, thus fixing kmem_alloc() to never return NULL for KM_SLEEP requests. instead these operations will retry forever, which was the intent.

(snj)

 @@ -1,14 +1,14 @@
-/*	$NetBSD: subr_kmem.c,v 1.60 2014/07/22 07:38:41 maxv Exp $	*/
+/*	$NetBSD: subr_kmem.c,v 1.60.2.1 2017/12/03 10:25:02 snj Exp $	*/
 /*-
  * Copyright (c) 2009 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Andrew Doran.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -90,27 +90,27 @@
  *	A kernel with "option DEBUG" has "kmguard" debugging feature compiled
  *	in. See the comment in uvm/uvm_kmguard.c for what kind of bugs it tries
  *	to detect.  Even if compiled in, it's disabled by default because it's
  *	very expensive.  You can enable it on boot by:
  *		boot -d
  *		db> w kmem_guard_depth 0t30000
  *		db> c
+ *
  *	The default value of kmem_guard_depth is 0, which means disabled.
  *	It can be changed by KMEM_GUARD_DEPTH kernel config option.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: subr_kmem.c,v 1.60 2014/07/22 07:38:41 maxv Exp $");
+__KERNEL_RCSID(0, "$NetBSD: subr_kmem.c,v 1.60.2.1 2017/12/03 10:25:02 snj Exp $");
 #include <sys/param.h>
 #include <sys/callback.h>
 #include <sys/kmem.h>
 #include <sys/pool.h>
 #include <sys/debug.h>
 #include <sys/lockdebug.h>
 #include <sys/cpu.h>
 #include <uvm/uvm_extern.h>
 #include <uvm/uvm_map.h>
 #include <uvm/uvm_kmguard.h>
 @@ -363,43 +363,51 @@ kmem_intr_free(void *p, size_t requested
+}
 /* ---- kmem API */
 /*
  * kmem_alloc: allocate wired memory.
  * => must not be called from interrupt context.
  */
 void *
 kmem_alloc(size_t size, km_flag_t kmflags)
+{
 	void *v;
 	KASSERTMSG((!cpu_intr_p() && !cpu_softintr_p()),
 	    "kmem(9) should not be used from the interrupt context");
-	return kmem_intr_alloc(size, kmflags);
+	v = kmem_intr_alloc(size, kmflags);
 	KASSERT(v || (kmflags & KM_NOSLEEP) != 0);
 	return v;
+}
 /*
  * kmem_zalloc: allocate zeroed wired memory.
  * => must not be called from interrupt context.
  */
 void *
 kmem_zalloc(size_t size, km_flag_t kmflags)
+{
 	void *v;
 	KASSERTMSG((!cpu_intr_p() && !cpu_softintr_p()),
 	    "kmem(9) should not be used from the interrupt context");
-	return kmem_intr_zalloc(size, kmflags);
+	v = kmem_intr_zalloc(size, kmflags);
 	KASSERT(v || (kmflags & KM_NOSLEEP) != 0);
 	return v;
+}
 /*
  * kmem_free: free wired memory allocated by kmem_alloc.
  * => must not be called from interrupt context.
  */
 void
 kmem_free(void *p, size_t size)
+{
 	KASSERT(!cpu_intr_p());
 	KASSERT(!cpu_softintr_p());

 @@ -1,14 +1,14 @@
-/*	$NetBSD: subr_vmem.c,v 1.92 2014/04/02 18:09:10 para Exp $	*/
+/*	$NetBSD: subr_vmem.c,v 1.92.4.1 2017/12/03 10:25:02 snj Exp $	*/
 /*-
  * Copyright (c)2006,2007,2008,2009 YAMAMOTO Takashi,
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
 @@ -36,27 +36,27 @@
  * - 	A pool(9) is used for vmem boundary tags
  * - 	During a pool get call the global vmem_btag_refill_lock is taken,
  *	to serialize access to the allocation reserve, but no other
  *	vmem arena locks.
  * -	During pool_put calls no vmem mutexes are locked.
  * - 	pool_drain doesn't hold the pool's mutex while releasing memory to
  * 	its backing therefore no interferance with any vmem mutexes.
  * -	The boundary tag pool is forced to put page headers into pool pages
  *  	(PR_PHINPAGE) and not off page to avoid pool recursion.
  *  	(due to sizeof(bt_t) it should be the case anyway)
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: subr_vmem.c,v 1.92 2014/04/02 18:09:10 para Exp $");
+__KERNEL_RCSID(0, "$NetBSD: subr_vmem.c,v 1.92.4.1 2017/12/03 10:25:02 snj Exp $");
 #if defined(_KERNEL)
 #include "opt_ddb.h"
 #endif /* defined(_KERNEL) */
 #include <sys/param.h>
 #include <sys/hash.h>
 #include <sys/queue.h>
 #include <sys/bitops.h>
 #if defined(_KERNEL)
 #include <sys/systm.h>
 #include <sys/kernel.h>	/* hz */
 @@ -184,29 +184,39 @@ static struct vmem_btag static_bts[STATI
 static int static_bt_count = STATIC_BT_COUNT;
 static struct vmem kmem_va_meta_arena_store;
 vmem_t *kmem_va_meta_arena;
 static struct vmem kmem_meta_arena_store;
 vmem_t *kmem_meta_arena = NULL;
 static kmutex_t vmem_btag_refill_lock;
 static kmutex_t vmem_btag_lock;
 static LIST_HEAD(, vmem_btag) vmem_btag_freelist;
 static size_t vmem_btag_freelist_count = 0;
 static struct pool vmem_btag_pool;
 static void
 vmem_kick_pdaemon(void)
+{
 #if defined(_KERNEL)
 	mutex_spin_enter(&uvm_fpageqlock);
 	uvm_kick_pdaemon();
 	mutex_spin_exit(&uvm_fpageqlock);
 #endif
+}
 /* ---- boundary tag */
-static int bt_refill(vmem_t *vm, vm_flag_t flags);
+static int bt_refill(vmem_t *vm);
 static void *
 pool_page_alloc_vmem_meta(struct pool *pp, int flags)
+{
 	const vm_flag_t vflags = (flags & PR_WAITOK) ? VM_SLEEP: VM_NOSLEEP;
 	vmem_addr_t va;
 	int ret;
 	ret = vmem_alloc(kmem_meta_arena, pp->pr_alloc->pa_pagesz,
 	    (vflags & ~VM_FITMASK) | VM_INSTANTFIT | VM_POPULATING, &va);
 	return ret ? NULL : (void *)va;
+}
 @@ -216,32 +226,30 @@ pool_page_free_vmem_meta(struct pool *pp
+{
 	vmem_free(kmem_meta_arena, (vmem_addr_t)v, pp->pr_alloc->pa_pagesz);
+}
 /* allocator for vmem-pool metadata */
 struct pool_allocator pool_allocator_vmem_meta = {
 	.pa_alloc = pool_page_alloc_vmem_meta,
 	.pa_free = pool_page_free_vmem_meta,
 	.pa_pagesz = 0
 };
 static int
-bt_refill(vmem_t *vm, vm_flag_t flags)
+bt_refill(vmem_t *vm)
+{
 	bt_t *bt;
 	KASSERT(flags & VM_NOSLEEP);
 	VMEM_LOCK(vm);
 	if (vm->vm_nfreetags > BT_MINRESERVE) {
 		VMEM_UNLOCK(vm);
 		return 0;
+	}
 	mutex_enter(&vmem_btag_lock);
 	while (!LIST_EMPTY(&vmem_btag_freelist) &&
 	    vm->vm_nfreetags <= BT_MINRESERVE) {
 		bt = LIST_FIRST(&vmem_btag_freelist);
 		LIST_REMOVE(bt, bt_freelist);
 		LIST_INSERT_HEAD(&vm->vm_freetags, bt, bt_freelist);
 		vm->vm_nfreetags++;
 @@ -260,46 +268,57 @@ bt_refill(vmem_t *vm, vm_flag_t flags)
 			break;
 		LIST_INSERT_HEAD(&vm->vm_freetags, bt, bt_freelist);
 		vm->vm_nfreetags++;
+	}
 	if (vm->vm_nfreetags <= BT_MINRESERVE) {
 		VMEM_UNLOCK(vm);
 		return ENOMEM;
+	}
 	VMEM_UNLOCK(vm);
 	if (kmem_meta_arena != NULL) {
-		bt_refill(kmem_arena, (flags & ~VM_FITMASK)
+		(void)bt_refill(kmem_arena);
-		    | VM_INSTANTFIT | VM_POPULATING);
+		(void)bt_refill(kmem_va_meta_arena);
-		bt_refill(kmem_va_meta_arena, (flags & ~VM_FITMASK)
+		(void)bt_refill(kmem_meta_arena);
 		    | VM_INSTANTFIT | VM_POPULATING);
 		bt_refill(kmem_meta_arena, (flags & ~VM_FITMASK)
 		    | VM_INSTANTFIT | VM_POPULATING);
+	}
 	return 0;
+}
 static bt_t *
 bt_alloc(vmem_t *vm, vm_flag_t flags)
+{
 	bt_t *bt;
 	VMEM_LOCK(vm);
 	while (vm->vm_nfreetags <= BT_MINRESERVE && (flags & VM_POPULATING) == 0) {
 		VMEM_UNLOCK(vm);
-		if (bt_refill(vm, VM_NOSLEEP | VM_INSTANTFIT)) {
+		if (bt_refill(vm)) {
-			return NULL;
+			if ((flags & VM_NOSLEEP) != 0) {
 				return NULL;
+			}
 			/*
 			 * It would be nice to wait for something specific here
 			 * but there are multiple ways that a retry could
 			 * succeed and we can't wait for multiple things
 			 * simultaneously.  So we'll just sleep for an arbitrary
 			 * short period of time and retry regardless.
 			 * This should be a very rare case.
 			 */
 			vmem_kick_pdaemon();
 			kpause("btalloc", false, 1, NULL);
+		}
 		VMEM_LOCK(vm);
+	}
 	bt = LIST_FIRST(&vm->vm_freetags);
 	LIST_REMOVE(bt, bt_freelist);
 	vm->vm_nfreetags--;
 	VMEM_UNLOCK(vm);
 	return bt;
+}
 static void
 bt_free(vmem_t *vm, bt_t *bt)
 @@ -930,27 +949,27 @@ vmem_init(vmem_t *vm, const char *name,
 	memset(&vm->vm_hash0, 0, sizeof(struct vmem_hashlist));
 	vm->vm_hashsize = 1;
 	vm->vm_hashlist = &vm->vm_hash0;
 	if (size != 0) {
 		if (vmem_add(vm, base, size, flags) != 0) {
 			vmem_destroy1(vm);
 			return NULL;
+		}
+	}
 #if defined(_KERNEL)
 	if (flags & VM_BOOTSTRAP) {
-		bt_refill(vm, VM_NOSLEEP);
+		bt_refill(vm);
+	}
 	mutex_enter(&vmem_list_lock);
 	LIST_INSERT_HEAD(&vmem_list, vm, vm_alllist);
 	mutex_exit(&vmem_list_lock);
 #endif /* defined(_KERNEL) */
 	return vm;
+}
 /*
 @@ -1167,31 +1186,27 @@ retry:
 		 * XXX should try to import a region large enough to
 		 * satisfy restrictions?
 		 */
 		goto fail;
+	}
 	/* XXX eeek, minaddr & maxaddr not respected */
 	if (vmem_import(vm, size, flags) == 0) {
 		goto retry;
+	}
 	/* XXX */
 	if ((flags & VM_SLEEP) != 0) {
-#if defined(_KERNEL)
+		vmem_kick_pdaemon();
 		mutex_spin_enter(&uvm_fpageqlock);
 		uvm_kick_pdaemon();
 		mutex_spin_exit(&uvm_fpageqlock);
 #endif
 		VMEM_LOCK(vm);
 		VMEM_CONDVAR_WAIT(vm);
 		VMEM_UNLOCK(vm);
 		goto retry;
+	}
 fail:
 	bt_free(vm, btnew);
 	bt_free(vm, btnew2);
 	return ENOMEM;
 gotit:
 	KASSERT(bt->bt_type == BT_TYPE_FREE);
 	KASSERT(bt->bt_size >= size);

 @@ -1,41 +1,41 @@
-.\"	$NetBSD: kmem.9,v 1.14 2013/11/26 20:47:26 rmind Exp $
+.\"	$NetBSD: kmem.9,v 1.14.4.1 2017/12/03 10:25:02 snj Exp $
 .\"
 .\" Copyright (c)2006 YAMAMOTO Takashi,
 .\" All rights reserved.
 .\"
 .\" Redistribution and use in source and binary forms, with or without
 .\" modification, are permitted provided that the following conditions
 .\" are met:
 .\" 1. Redistributions of source code must retain the above copyright
 .\"    notice, this list of conditions and the following disclaimer.
 .\" 2. Redistributions in binary form must reproduce the above copyright
 .\"    notice, this list of conditions and the following disclaimer in the
 .\"    documentation and/or other materials provided with the distribution.
 .\"
 .\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 .\" ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
 .\" ------------------------------------------------------------
-.Dd November 26, 2013
+.Dd October 31, 2017
 .Dt KMEM 9
 .Os
 .\" ------------------------------------------------------------
 .Sh NAME
 .Nm kmem
 .Nd kernel wired memory allocator
 .\" ------------------------------------------------------------
 .Sh SYNOPSIS
 .In sys/kmem.h
 .\" - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 .Ft void *
 .Fn kmem_alloc \
 "size_t size" "km_flag_t kmflags"
 @@ -65,26 +65,29 @@
 .Sh DESCRIPTION
 .Fn kmem_alloc
 allocates kernel wired memory.
 It takes the following arguments.
 .Bl -tag -width kmflags
 .It Fa size
 Specify the size of allocation in bytes.
 .It Fa kmflags
 Either of the following:
 .Bl -tag -width KM_NOSLEEP
 .It KM_SLEEP
 If the allocation cannot be satisfied immediately, sleep until enough
 memory is available.
 If
 .Dv KM_SLEEP
 is specified, then the allocation cannot fail.
 .It KM_NOSLEEP
 Don't sleep.
 Immediately return
 .Dv NULL
 if there is not enough memory available.
 It should only be used when failure to allocate will not have harmful,
 user-visible effects.
 .Pp
 .Bf -symbolic
 Use of
 .Dv KM_NOSLEEP
 is strongly discouraged as it can create transient, hard to debug failures
 that occur when the system is under memory pressure.