 @@ -1,14 +1,14 @@
-/*	$NetBSD: subr_vmem.c,v 1.106 2021/08/17 22:00:32 andvar Exp $	*/
+/*	$NetBSD: subr_vmem.c,v 1.107 2022/02/27 14:24:11 riastradh 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.106 2021/08/17 22:00:32 andvar Exp $");
+__KERNEL_RCSID(0, "$NetBSD: subr_vmem.c,v 1.107 2022/02/27 14:24:11 riastradh Exp $");
 #if defined(_KERNEL) && defined(_KERNEL_OPT)
 #include "opt_ddb.h"
 #endif /* defined(_KERNEL) && defined(_KERNEL_OPT) */
 #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 */
 @@ -1085,26 +1085,30 @@ vmem_alloc(vmem_t *vm, vmem_size_t size,
 		qcache_t *qc = vm->vm_qcache[qidx - 1];
 		p = pool_cache_get(qc->qc_cache, vmf_to_prf(flags));
 		if (addrp != NULL)
 			*addrp = (vmem_addr_t)p;
 		error = (p == NULL) ? ENOMEM : 0;
 		goto out;
+	}
 #endif /* defined(QCACHE) */
 	error = vmem_xalloc(vm, size, 0, 0, 0, VMEM_ADDR_MIN, VMEM_ADDR_MAX,
 	    flags, addrp);
 out:
 	KASSERTMSG(error || addrp == NULL ||
 	    (*addrp & vm->vm_quantum_mask) == 0,
 	    "vmem %s mask=0x%jx addr=0x%jx",
 	    vm->vm_name, (uintmax_t)vm->vm_quantum_mask, (uintmax_t)*addrp);
 	KASSERT(error == 0 || (flags & VM_SLEEP) == 0);
 	return error;
+}
 int
 vmem_xalloc(vmem_t *vm, const vmem_size_t size0, vmem_size_t align,
     const vmem_size_t phase, const vmem_size_t nocross,
     const vmem_addr_t minaddr, const vmem_addr_t maxaddr, const vm_flag_t flags,
     vmem_addr_t *addrp)
+{
 	struct vmem_freelist *list;
 	struct vmem_freelist *first;
 	struct vmem_freelist *end;
 @@ -1275,63 +1279,74 @@ gotit:
 		bt_insbusy(vm, bt);
 		vmem_check(vm);
 		bt_free(vm, btnew);
 		btnew = bt;
+	}
 	if (btnew2 != NULL) {
 		bt_free(vm, btnew2);
+	}
 	KASSERT(btnew->bt_size >= size);
 	btnew->bt_type = BT_TYPE_BUSY;
 	if (addrp != NULL)
 		*addrp = btnew->bt_start;
 	VMEM_UNLOCK(vm);
 	KASSERTMSG(addrp == NULL ||
 	    (*addrp & vm->vm_quantum_mask) == 0,
 	    "vmem %s mask=0x%jx addr=0x%jx",
 	    vm->vm_name, (uintmax_t)vm->vm_quantum_mask, (uintmax_t)*addrp);
 	return 0;
+}
 /*
  * vmem_free: free the resource to the arena.
  */
 void
 vmem_free(vmem_t *vm, vmem_addr_t addr, vmem_size_t size)
+{
 	KASSERT(size > 0);
 	KASSERTMSG((addr & vm->vm_quantum_mask) == 0,
 	    "vmem %s mask=0x%jx addr=0x%jx",
 	    vm->vm_name, (uintmax_t)vm->vm_quantum_mask, (uintmax_t)addr);
 #if defined(QCACHE)
 	if (size <= vm->vm_qcache_max) {
 		int qidx = (size + vm->vm_quantum_mask) >> vm->vm_quantum_shift;
 		qcache_t *qc = vm->vm_qcache[qidx - 1];
 		pool_cache_put(qc->qc_cache, (void *)addr);
 		return;
+	}
 #endif /* defined(QCACHE) */
 	vmem_xfree(vm, addr, size);
+}
 void
 vmem_xfree(vmem_t *vm, vmem_addr_t addr, vmem_size_t size)
+{
 	bt_t *bt;
 	KASSERT(size > 0);
 	KASSERTMSG((addr & vm->vm_quantum_mask) == 0,
 	    "vmem %s mask=0x%jx addr=0x%jx",
 	    vm->vm_name, (uintmax_t)vm->vm_quantum_mask, (uintmax_t)addr);
 	VMEM_LOCK(vm);
 	bt = bt_lookupbusy(vm, addr);
-	KASSERT(bt != NULL);
+	KASSERTMSG(bt != NULL, "vmem %s addr 0x%jx size 0x%jx",
 	    vm->vm_name, (uintmax_t)addr, (uintmax_t)size);
 	KASSERT(bt->bt_start == addr);
 	KASSERT(bt->bt_size == vmem_roundup_size(vm, size) ||
 	    bt->bt_size - vmem_roundup_size(vm, size) <= vm->vm_quantum_mask);
 	/* vmem_xfree_bt() drops the lock. */
 	vmem_xfree_bt(vm, bt);
+}
 void
 vmem_xfreeall(vmem_t *vm)
+{
 	bt_t *bt;