 @@ -1,1574 +1,1574 @@
-/*	$NetBSD: uvm_map.c,v 1.284 2009/11/07 07:27:49 cegger Exp $	*/
+/*	$NetBSD: uvm_map.c,v 1.285 2009/12/14 21:19:47 matt Exp $	*/
 /*
  * Copyright (c) 1997 Charles D. Cranor and Washington University.
  * Copyright (c) 1991, 1993, The Regents of the University of California.
+ *
  * All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * The Mach Operating System project at Carnegie-Mellon University.
+ *
  * 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.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
  *	This product includes software developed by Charles D. Cranor,
  *      Washington University, the University of California, Berkeley and
  *      its contributors.
  * 4. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
+ *
  *	@(#)vm_map.c    8.3 (Berkeley) 1/12/94
  * from: Id: uvm_map.c,v 1.1.2.27 1998/02/07 01:16:54 chs Exp
+ *
+ *
  * Copyright (c) 1987, 1990 Carnegie-Mellon University.
  * All rights reserved.
+ *
  * Permission to use, copy, modify and distribute this software and
  * its documentation is hereby granted, provided that both the copyright
  * notice and this permission notice appear in all copies of the
  * software, derivative works or modified versions, and any portions
  * thereof, and that both notices appear in supporting documentation.
+ *
  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
+ *
  * Carnegie Mellon requests users of this software to return to
+ *
  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
  *  School of Computer Science
  *  Carnegie Mellon University
  *  Pittsburgh PA 15213-3890
+ *
  * any improvements or extensions that they make and grant Carnegie the
  * rights to redistribute these changes.
  */
 /*
  * uvm_map.c: uvm map operations
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: uvm_map.c,v 1.284 2009/11/07 07:27:49 cegger Exp $");
+__KERNEL_RCSID(0, "$NetBSD: uvm_map.c,v 1.285 2009/12/14 21:19:47 matt Exp $");
 #include "opt_ddb.h"
 #include "opt_uvmhist.h"
 #include "opt_uvm.h"
 #include "opt_sysv.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/mman.h>
 #include <sys/proc.h>
 #include <sys/malloc.h>
 #include <sys/pool.h>
 #include <sys/kernel.h>
 #include <sys/mount.h>
 #include <sys/vnode.h>
 #include <sys/lockdebug.h>
 #include <sys/atomic.h>
 #ifdef SYSVSHM
 #include <sys/shm.h>
 #endif
 #include <uvm/uvm.h>
 #include <uvm/uvm_readahead.h>
 #if defined(DDB) || defined(DEBUGPRINT)
 #include <uvm/uvm_ddb.h>
 #endif
 #if !defined(UVMMAP_COUNTERS)
 #define	UVMMAP_EVCNT_DEFINE(name)	/* nothing */
 #define UVMMAP_EVCNT_INCR(ev)		/* nothing */
 #define UVMMAP_EVCNT_DECR(ev)		/* nothing */
 #else /* defined(UVMMAP_NOCOUNTERS) */
 #include <sys/evcnt.h>
 #define	UVMMAP_EVCNT_DEFINE(name) \
 struct evcnt uvmmap_evcnt_##name = EVCNT_INITIALIZER(EVCNT_TYPE_MISC, NULL, \
     "uvmmap", #name); \
 EVCNT_ATTACH_STATIC(uvmmap_evcnt_##name);
 #define	UVMMAP_EVCNT_INCR(ev)		uvmmap_evcnt_##ev.ev_count++
 #define	UVMMAP_EVCNT_DECR(ev)		uvmmap_evcnt_##ev.ev_count--
 #endif /* defined(UVMMAP_NOCOUNTERS) */
 UVMMAP_EVCNT_DEFINE(ubackmerge)
 UVMMAP_EVCNT_DEFINE(uforwmerge)
 UVMMAP_EVCNT_DEFINE(ubimerge)
 UVMMAP_EVCNT_DEFINE(unomerge)
 UVMMAP_EVCNT_DEFINE(kbackmerge)
 UVMMAP_EVCNT_DEFINE(kforwmerge)
 UVMMAP_EVCNT_DEFINE(kbimerge)
 UVMMAP_EVCNT_DEFINE(knomerge)
 UVMMAP_EVCNT_DEFINE(map_call)
 UVMMAP_EVCNT_DEFINE(mlk_call)
 UVMMAP_EVCNT_DEFINE(mlk_hint)
 UVMMAP_EVCNT_DEFINE(mlk_list)
 UVMMAP_EVCNT_DEFINE(mlk_tree)
 UVMMAP_EVCNT_DEFINE(mlk_treeloop)
 UVMMAP_EVCNT_DEFINE(mlk_listloop)
 UVMMAP_EVCNT_DEFINE(uke_alloc)
 UVMMAP_EVCNT_DEFINE(uke_free)
 UVMMAP_EVCNT_DEFINE(ukh_alloc)
 UVMMAP_EVCNT_DEFINE(ukh_free)
 const char vmmapbsy[] = "vmmapbsy";
 /*
  * cache for vmspace structures.
  */
 static struct pool_cache uvm_vmspace_cache;
 /*
  * cache for dynamically-allocated map entries.
  */
 static struct pool_cache uvm_map_entry_cache;
 MALLOC_DEFINE(M_VMMAP, "VM map", "VM map structures");
 MALLOC_DEFINE(M_VMPMAP, "VM pmap", "VM pmap");
 #ifdef PMAP_GROWKERNEL
 /*
  * This global represents the end of the kernel virtual address
  * space.  If we want to exceed this, we must grow the kernel
  * virtual address space dynamically.
+ *
  * Note, this variable is locked by kernel_map's lock.
  */
 vaddr_t uvm_maxkaddr;
 #endif
 /*
  * macros
  */
 /*
  * VM_MAP_USE_KMAPENT: determine if uvm_kmapent_alloc/free is used
  * for the vm_map.
  */
 extern struct vm_map *pager_map; /* XXX */
 #define	VM_MAP_USE_KMAPENT_FLAGS(flags) \
 	(((flags) & VM_MAP_INTRSAFE) != 0)
 #define	VM_MAP_USE_KMAPENT(map) \
 	(VM_MAP_USE_KMAPENT_FLAGS((map)->flags) || (map) == kernel_map)
 /*
  * UVM_ET_ISCOMPATIBLE: check some requirements for map entry merging
  */
 #define	UVM_ET_ISCOMPATIBLE(ent, type, uobj, meflags, \
     prot, maxprot, inh, adv, wire) \
 	((ent)->etype == (type) && \
 	(((ent)->flags ^ (meflags)) & (UVM_MAP_NOMERGE | UVM_MAP_QUANTUM)) \
 	== 0 && \
 	(ent)->object.uvm_obj == (uobj) && \
 	(ent)->protection == (prot) && \
 	(ent)->max_protection == (maxprot) && \
 	(ent)->inheritance == (inh) && \
 	(ent)->advice == (adv) && \
 	(ent)->wired_count == (wire))
 /*
  * uvm_map_entry_link: insert entry into a map
+ *
  * => map must be locked
  */
 #define uvm_map_entry_link(map, after_where, entry) do { \
 	uvm_mapent_check(entry); \
 	(map)->nentries++; \
 	(entry)->prev = (after_where); \
 	(entry)->next = (after_where)->next; \
 	(entry)->prev->next = (entry); \
 	(entry)->next->prev = (entry); \
 	uvm_rb_insert((map), (entry)); \
 } while (/*CONSTCOND*/ 0)
 /*
  * uvm_map_entry_unlink: remove entry from a map
+ *
  * => map must be locked
  */
 #define uvm_map_entry_unlink(map, entry) do { \
 	KASSERT((entry) != (map)->first_free); \
 	KASSERT((entry) != (map)->hint); \
 	uvm_mapent_check(entry); \
 	(map)->nentries--; \
 	(entry)->next->prev = (entry)->prev; \
 	(entry)->prev->next = (entry)->next; \
 	uvm_rb_remove((map), (entry)); \
 } while (/*CONSTCOND*/ 0)
 /*
  * SAVE_HINT: saves the specified entry as the hint for future lookups.
+ *
  * => map need not be locked.
  */
 #define SAVE_HINT(map, check, value) do { \
 	if ((map)->hint == (check)) \
 		(map)->hint = (value); \
 } while (/*CONSTCOND*/ 0)
 /*
  * clear_hints: ensure that hints don't point to the entry.
+ *
  * => map must be write-locked.
  */
 static void
 clear_hints(struct vm_map *map, struct vm_map_entry *ent)
+{
 	SAVE_HINT(map, ent, ent->prev);
 	if (map->first_free == ent) {
 		map->first_free = ent->prev;
+	}
+}
 /*
  * VM_MAP_RANGE_CHECK: check and correct range
+ *
  * => map must at least be read locked
  */
 #define VM_MAP_RANGE_CHECK(map, start, end) do { \
 	if (start < vm_map_min(map))		\
 		start = vm_map_min(map);	\
 	if (end > vm_map_max(map))		\
 		end = vm_map_max(map);		\
 	if (start > end)			\
 		start = end;			\
 } while (/*CONSTCOND*/ 0)
 /*
  * local prototypes
  */
 static struct vm_map_entry *
 		uvm_mapent_alloc(struct vm_map *, int);
 static struct vm_map_entry *
 		uvm_mapent_alloc_split(struct vm_map *,
 		    const struct vm_map_entry *, int,
 		    struct uvm_mapent_reservation *);
 static void	uvm_mapent_copy(struct vm_map_entry *, struct vm_map_entry *);
 static void	uvm_mapent_free(struct vm_map_entry *);
 #if defined(DEBUG)
 static void	_uvm_mapent_check(const struct vm_map_entry *, const char *,
 		    int);
 #define	uvm_mapent_check(map)	_uvm_mapent_check(map, __FILE__, __LINE__)
 #else /* defined(DEBUG) */
 #define	uvm_mapent_check(e)	/* nothing */
 #endif /* defined(DEBUG) */
 static struct vm_map_entry *
 		uvm_kmapent_alloc(struct vm_map *, int);
 static void	uvm_kmapent_free(struct vm_map_entry *);
 static vsize_t	uvm_kmapent_overhead(vsize_t);
 static void	uvm_map_entry_unwire(struct vm_map *, struct vm_map_entry *);
 static void	uvm_map_reference_amap(struct vm_map_entry *, int);
 static int	uvm_map_space_avail(vaddr_t *, vsize_t, voff_t, vsize_t, int,
 		    struct vm_map_entry *);
 static void	uvm_map_unreference_amap(struct vm_map_entry *, int);
 int _uvm_map_sanity(struct vm_map *);
 int _uvm_tree_sanity(struct vm_map *);
 static vsize_t uvm_rb_maxgap(const struct vm_map_entry *);
 CTASSERT(offsetof(struct vm_map_entry, rb_node) == 0);
 #define	ROOT_ENTRY(map)		((struct vm_map_entry *)(map)->rb_tree.rbt_root)
 #define	LEFT_ENTRY(entry)	((struct vm_map_entry *)(entry)->rb_node.rb_left)
 #define	RIGHT_ENTRY(entry)	((struct vm_map_entry *)(entry)->rb_node.rb_right)
 #define	PARENT_ENTRY(map, entry) \
 	(ROOT_ENTRY(map) == (entry) \
 	    ? NULL \
 	    : (struct vm_map_entry *)RB_FATHER(&(entry)->rb_node))
 static int
 uvm_map_compare_nodes(const struct rb_node *nparent,
 	const struct rb_node *nkey)
+{
 	const struct vm_map_entry *eparent = (const void *) nparent;
 	const struct vm_map_entry *ekey = (const void *) nkey;
 	KASSERT(eparent->start < ekey->start || eparent->start >= ekey->end);
 	KASSERT(ekey->start < eparent->start || ekey->start >= eparent->end);
 	if (ekey->start < eparent->start)
 		return -1;
 	if (ekey->start >= eparent->end)
 		return 1;
 	return 0;
+}
 static int
 uvm_map_compare_key(const struct rb_node *nparent, const void *vkey)
+{
 	const struct vm_map_entry *eparent = (const void *) nparent;
 	const vaddr_t va = *(const vaddr_t *) vkey;
 	if (va < eparent->start)
 		return -1;
 	if (va >= eparent->end)
 		return 1;
 	return 0;
+}
 static const struct rb_tree_ops uvm_map_tree_ops = {
 	.rbto_compare_nodes = uvm_map_compare_nodes,
 	.rbto_compare_key = uvm_map_compare_key,
 };
 static inline vsize_t
 uvm_rb_gap(const struct vm_map_entry *entry)
+{
 	KASSERT(entry->next != NULL);
 	return entry->next->start - entry->end;
+}
 static vsize_t
 uvm_rb_maxgap(const struct vm_map_entry *entry)
+{
 	struct vm_map_entry *child;
 	vsize_t maxgap = entry->gap;
 	/*
 	 * We need maxgap to be the largest gap of us or any of our
 	 * descendents.  Since each of our children's maxgap is the
 	 * cached value of their largest gap of themselves or their
 	 * descendents, we can just use that value and avoid recursing
 	 * down the tree to calculate it.
 	 */
 	if ((child = LEFT_ENTRY(entry)) != NULL && maxgap < child->maxgap)
 		maxgap = child->maxgap;
 	if ((child = RIGHT_ENTRY(entry)) != NULL && maxgap < child->maxgap)
 		maxgap = child->maxgap;
 	return maxgap;
+}
 static void
 uvm_rb_fixup(struct vm_map *map, struct vm_map_entry *entry)
+{
 	struct vm_map_entry *parent;
 	KASSERT(entry->gap == uvm_rb_gap(entry));
 	entry->maxgap = uvm_rb_maxgap(entry);
 	while ((parent = PARENT_ENTRY(map, entry)) != NULL) {
 		struct vm_map_entry *brother;
 		vsize_t maxgap = parent->gap;
 		KDASSERT(parent->gap == uvm_rb_gap(parent));
 		if (maxgap < entry->maxgap)
 			maxgap = entry->maxgap;
 		/*
 		 * Since we work our towards the root, we know entry's maxgap
 		 * value is ok but its brothers may now be out-of-date due
 		 * rebalancing.  So refresh it.
 		 */
 		brother = (struct vm_map_entry *)parent->rb_node.rb_nodes[RB_POSITION(&entry->rb_node) ^ RB_DIR_OTHER];
 		if (brother != NULL) {
 			KDASSERT(brother->gap == uvm_rb_gap(brother));
 			brother->maxgap = uvm_rb_maxgap(brother);
 			if (maxgap < brother->maxgap)
 				maxgap = brother->maxgap;
+		}
 		parent->maxgap = maxgap;
 		entry = parent;
+	}
+}
 static void
 uvm_rb_insert(struct vm_map *map, struct vm_map_entry *entry)
+{
 	entry->gap = entry->maxgap = uvm_rb_gap(entry);
 	if (entry->prev != &map->header)
 		entry->prev->gap = uvm_rb_gap(entry->prev);
 	if (!rb_tree_insert_node(&map->rb_tree, &entry->rb_node))
 		panic("uvm_rb_insert: map %p: duplicate entry?", map);
 	/*
 	 * If the previous entry is not our immediate left child, then it's an
 	 * ancestor and will be fixed up on the way to the root.  We don't
 	 * have to check entry->prev against &map->header since &map->header
 	 * will never be in the tree.
 	 */
 	uvm_rb_fixup(map,
 	    LEFT_ENTRY(entry) == entry->prev ? entry->prev : entry);
+}
 static void
 uvm_rb_remove(struct vm_map *map, struct vm_map_entry *entry)
+{
 	struct vm_map_entry *prev_parent = NULL, *next_parent = NULL;
 	/*
 	 * If we are removing an interior node, then an adjacent node will
 	 * be used to replace its position in the tree.  Therefore we will
 	 * need to fixup the tree starting at the parent of the replacement
 	 * node.  So record their parents for later use.
 	 */
 	if (entry->prev != &map->header)
 		prev_parent = PARENT_ENTRY(map, entry->prev);
 	if (entry->next != &map->header)
 		next_parent = PARENT_ENTRY(map, entry->next);
 	rb_tree_remove_node(&map->rb_tree, &entry->rb_node);
 	/*
 	 * If the previous node has a new parent, fixup the tree starting
 	 * at the previous node's old parent.
 	 */
 	if (entry->prev != &map->header) {
 		/*
 		 * Update the previous entry's gap due to our absence.
 		 */
 		entry->prev->gap = uvm_rb_gap(entry->prev);
 		uvm_rb_fixup(map, entry->prev);
 		if (prev_parent != NULL
 		    && prev_parent != entry
 		    && prev_parent != PARENT_ENTRY(map, entry->prev))
 			uvm_rb_fixup(map, prev_parent);
+	}
 	/*
 	 * If the next node has a new parent, fixup the tree starting
 	 * at the next node's old parent.
 	 */
 	if (entry->next != &map->header) {
 		uvm_rb_fixup(map, entry->next);
 		if (next_parent != NULL
 		    && next_parent != entry
 		    && next_parent != PARENT_ENTRY(map, entry->next))
 			uvm_rb_fixup(map, next_parent);
+	}
+}
 #if defined(DEBUG)
 int uvm_debug_check_map = 0;
 int uvm_debug_check_rbtree = 0;
 #define uvm_map_check(map, name) \
 	_uvm_map_check((map), (name), __FILE__, __LINE__)
 static void
 _uvm_map_check(struct vm_map *map, const char *name,
     const char *file, int line)
+{
 	if ((uvm_debug_check_map && _uvm_map_sanity(map)) ||
 	    (uvm_debug_check_rbtree && _uvm_tree_sanity(map))) {
 		panic("uvm_map_check failed: \"%s\" map=%p (%s:%d)",
 		    name, map, file, line);
+	}
+}
 #else /* defined(DEBUG) */
 #define uvm_map_check(map, name)	/* nothing */
 #endif /* defined(DEBUG) */
 #if defined(DEBUG) || defined(DDB)
 int
 _uvm_map_sanity(struct vm_map *map)
+{
 	bool first_free_found = false;
 	bool hint_found = false;
 	const struct vm_map_entry *e;
 	struct vm_map_entry *hint = map->hint;
 	e = &map->header;
 	for (;;) {
 		if (map->first_free == e) {
 			first_free_found = true;
 		} else if (!first_free_found && e->next->start > e->end) {
 			printf("first_free %p should be %p\n",
 			    map->first_free, e);
 			return -1;
+		}
 		if (hint == e) {
 			hint_found = true;
+		}
 		e = e->next;
 		if (e == &map->header) {
 			break;
+		}
+	}
 	if (!first_free_found) {
 		printf("stale first_free\n");
 		return -1;
+	}
 	if (!hint_found) {
 		printf("stale hint\n");
 		return -1;
+	}
 	return 0;
+}
 int
 _uvm_tree_sanity(struct vm_map *map)
+{
 	struct vm_map_entry *tmp, *trtmp;
 	int n = 0, i = 1;
 	for (tmp = map->header.next; tmp != &map->header; tmp = tmp->next) {
 		if (tmp->gap != uvm_rb_gap(tmp)) {
 			printf("%d/%d gap %lx != %lx %s\n",
 			    n + 1, map->nentries,
 			    (ulong)tmp->gap, (ulong)uvm_rb_gap(tmp),
 			    tmp->next == &map->header ? "(last)" : "");
 			goto error;
+		}
 		/*
 		 * If any entries are out of order, tmp->gap will be unsigned
 		 * and will likely exceed the size of the map.
 		 */
 		if (tmp->gap >= vm_map_max(map) - vm_map_min(map)) {
 			printf("too large gap %zu\n", (size_t)tmp->gap);
 			goto error;
+		}
 		n++;
+	}
 	if (n != map->nentries) {
 		printf("nentries: %d vs %d\n", n, map->nentries);
 		goto error;
+	}
 	trtmp = NULL;
 	for (tmp = map->header.next; tmp != &map->header; tmp = tmp->next) {
 		if (tmp->maxgap != uvm_rb_maxgap(tmp)) {
 			printf("maxgap %lx != %lx\n",
 			    (ulong)tmp->maxgap,
 			    (ulong)uvm_rb_maxgap(tmp));
 			goto error;
+		}
 		if (trtmp != NULL && trtmp->start >= tmp->start) {
-			printf("corrupt: 0x%lx >= 0x%lx\n",
+			printf("corrupt: 0x%"PRIxVADDR"x >= 0x%"PRIxVADDR"x\n",
 			    trtmp->start, tmp->start);
 			goto error;
+		}
 		trtmp = tmp;
+	}
 	for (tmp = map->header.next; tmp != &map->header;
 	    tmp = tmp->next, i++) {
 		trtmp = (void *) rb_tree_iterate(&map->rb_tree, &tmp->rb_node,
 		    RB_DIR_LEFT);
 		if (trtmp == NULL)
 			trtmp = &map->header;
 		if (tmp->prev != trtmp) {
 			printf("lookup: %d: %p->prev=%p: %p\n",
 			    i, tmp, tmp->prev, trtmp);
 			goto error;
+		}
 		trtmp = (void *) rb_tree_iterate(&map->rb_tree, &tmp->rb_node,
 		    RB_DIR_RIGHT);
 		if (trtmp == NULL)
 			trtmp = &map->header;
 		if (tmp->next != trtmp) {
 			printf("lookup: %d: %p->next=%p: %p\n",
 			    i, tmp, tmp->next, trtmp);
 			goto error;
+		}
 		trtmp = (void *)rb_tree_find_node(&map->rb_tree, &tmp->start);
 		if (trtmp != tmp) {
 			printf("lookup: %d: %p - %p: %p\n", i, tmp, trtmp,
 			    PARENT_ENTRY(map, tmp));
 			goto error;
+		}
+	}
 	return (0);
  error:
 	return (-1);
+}
 #endif /* defined(DEBUG) || defined(DDB) */
 #ifdef DIAGNOSTIC
 static struct vm_map *uvm_kmapent_map(struct vm_map_entry *);
 #endif
 /*
  * vm_map_lock: acquire an exclusive (write) lock on a map.
+ *
  * => Note that "intrsafe" maps use only exclusive, spin locks.
+ *
  * => The locking protocol provides for guaranteed upgrade from shared ->
  *    exclusive by whichever thread currently has the map marked busy.
  *    See "LOCKING PROTOCOL NOTES" in uvm_map.h.  This is horrible; among
  *    other problems, it defeats any fairness guarantees provided by RW
  *    locks.
  */
 void
 vm_map_lock(struct vm_map *map)
+{
 	if ((map->flags & VM_MAP_INTRSAFE) != 0) {
 		mutex_spin_enter(&map->mutex);
 		return;
+	}
 	for (;;) {
 		rw_enter(&map->lock, RW_WRITER);
 		if (map->busy == NULL)
 			break;
 		if (map->busy == curlwp)
 			break;
 		mutex_enter(&map->misc_lock);
 		rw_exit(&map->lock);
 		if (map->busy != NULL)
 			cv_wait(&map->cv, &map->misc_lock);
 		mutex_exit(&map->misc_lock);
+	}
 	map->timestamp++;
+}
 /*
  * vm_map_lock_try: try to lock a map, failing if it is already locked.
  */
 bool
 vm_map_lock_try(struct vm_map *map)
+{
 	if ((map->flags & VM_MAP_INTRSAFE) != 0)
 		return mutex_tryenter(&map->mutex);
 	if (!rw_tryenter(&map->lock, RW_WRITER))
 		return false;
 	if (map->busy != NULL) {
 		rw_exit(&map->lock);
 		return false;
+	}
 	map->timestamp++;
 	return true;
+}
 /*
  * vm_map_unlock: release an exclusive lock on a map.
  */
 void
 vm_map_unlock(struct vm_map *map)
+{
 	if ((map->flags & VM_MAP_INTRSAFE) != 0)
 		mutex_spin_exit(&map->mutex);
 	else {
 		KASSERT(rw_write_held(&map->lock));
 		KASSERT(map->busy == NULL || map->busy == curlwp);
 		rw_exit(&map->lock);
+	}
+}
 /*
  * vm_map_unbusy: mark the map as unbusy, and wake any waiters that
  *     want an exclusive lock.
  */
 void
 vm_map_unbusy(struct vm_map *map)
+{
 	KASSERT(map->busy == curlwp);
 	/*
 	 * Safe to clear 'busy' and 'waiters' with only a read lock held:
+	 *
 	 * o they can only be set with a write lock held
 	 * o writers are blocked out with a read or write hold
 	 * o at any time, only one thread owns the set of values
 	 */
 	mutex_enter(&map->misc_lock);
 	map->busy = NULL;
 	cv_broadcast(&map->cv);
 	mutex_exit(&map->misc_lock);
+}
 /*
  * vm_map_lock_read: acquire a shared (read) lock on a map.
  */
 void
 vm_map_lock_read(struct vm_map *map)
+{
 	KASSERT((map->flags & VM_MAP_INTRSAFE) == 0);
 	rw_enter(&map->lock, RW_READER);
+}
 /*
  * vm_map_unlock_read: release a shared lock on a map.
  */
 void
 vm_map_unlock_read(struct vm_map *map)
+{
 	KASSERT((map->flags & VM_MAP_INTRSAFE) == 0);
 	rw_exit(&map->lock);
+}
 /*
  * vm_map_busy: mark a map as busy.
+ *
  * => the caller must hold the map write locked
  */
 void
 vm_map_busy(struct vm_map *map)
+{
 	KASSERT(rw_write_held(&map->lock));
 	KASSERT(map->busy == NULL);
 	map->busy = curlwp;
+}
 /*
  * vm_map_locked_p: return true if the map is write locked.
+ *
  * => only for debug purposes like KASSERTs.
  * => should not be used to verify that a map is not locked.
  */
 bool
 vm_map_locked_p(struct vm_map *map)
+{
 	if ((map->flags & VM_MAP_INTRSAFE) != 0) {
 		return mutex_owned(&map->mutex);
 	} else {
 		return rw_write_held(&map->lock);
+	}
+}
 /*
  * uvm_mapent_alloc: allocate a map entry
  */
 static struct vm_map_entry *
 uvm_mapent_alloc(struct vm_map *map, int flags)
+{
 	struct vm_map_entry *me;
 	int pflags = (flags & UVM_FLAG_NOWAIT) ? PR_NOWAIT : PR_WAITOK;
 	UVMHIST_FUNC("uvm_mapent_alloc"); UVMHIST_CALLED(maphist);
 	if (VM_MAP_USE_KMAPENT(map)) {
 		me = uvm_kmapent_alloc(map, flags);
 	} else {
 		me = pool_cache_get(&uvm_map_entry_cache, pflags);
 		if (__predict_false(me == NULL))
 			return NULL;
 		me->flags = 0;
+	}
 	UVMHIST_LOG(maphist, "<- new entry=0x%x [kentry=%d]", me,
 	    ((map->flags & VM_MAP_INTRSAFE) != 0 || map == kernel_map), 0, 0);
 	return (me);
+}
 /*
  * uvm_mapent_alloc_split: allocate a map entry for clipping.
+ *
  * => map must be locked by caller if UVM_MAP_QUANTUM is set.
  */
 static struct vm_map_entry *
 uvm_mapent_alloc_split(struct vm_map *map,
     const struct vm_map_entry *old_entry, int flags,
     struct uvm_mapent_reservation *umr)
+{
 	struct vm_map_entry *me;
 	KASSERT(!VM_MAP_USE_KMAPENT(map) ||
 	    (old_entry->flags & UVM_MAP_QUANTUM) || !UMR_EMPTY(umr));
 	if (old_entry->flags & UVM_MAP_QUANTUM) {
 		struct vm_map_kernel *vmk = vm_map_to_kernel(map);
 		KASSERT(vm_map_locked_p(map));
 		me = vmk->vmk_merged_entries;
 		KASSERT(me);
 		vmk->vmk_merged_entries = me->next;
 		KASSERT(me->flags & UVM_MAP_QUANTUM);
 	} else {
 		me = uvm_mapent_alloc(map, flags);
+	}
 	return me;
+}
 /*
  * uvm_mapent_free: free map entry
  */
 static void
 uvm_mapent_free(struct vm_map_entry *me)
+{
 	UVMHIST_FUNC("uvm_mapent_free"); UVMHIST_CALLED(maphist);
 	UVMHIST_LOG(maphist,"<- freeing map entry=0x%x [flags=%d]",
 		me, me->flags, 0, 0);
 	if (me->flags & UVM_MAP_KERNEL) {
 		uvm_kmapent_free(me);
 	} else {
 		pool_cache_put(&uvm_map_entry_cache, me);
+	}
+}
 /*
  * uvm_mapent_free_merged: free merged map entry
+ *
  * => keep the entry if needed.
  * => caller shouldn't hold map locked if VM_MAP_USE_KMAPENT(map) is true.
  * => map should be locked if UVM_MAP_QUANTUM is set.
  */
 static void
 uvm_mapent_free_merged(struct vm_map *map, struct vm_map_entry *me)
+{
 	KASSERT(!(me->flags & UVM_MAP_KERNEL) || uvm_kmapent_map(me) == map);
 	if (me->flags & UVM_MAP_QUANTUM) {
 		/*
 		 * keep this entry for later splitting.
 		 */
 		struct vm_map_kernel *vmk;
 		KASSERT(vm_map_locked_p(map));
 		KASSERT(VM_MAP_IS_KERNEL(map));
 		KASSERT(!VM_MAP_USE_KMAPENT(map) ||
 		    (me->flags & UVM_MAP_KERNEL));
 		vmk = vm_map_to_kernel(map);
 		me->next = vmk->vmk_merged_entries;
 		vmk->vmk_merged_entries = me;
 	} else {
 		uvm_mapent_free(me);
+	}
+}
 /*
  * uvm_mapent_copy: copy a map entry, preserving flags
  */
 static inline void
 uvm_mapent_copy(struct vm_map_entry *src, struct vm_map_entry *dst)
+{
 	memcpy(dst, src, ((char *)&src->uvm_map_entry_stop_copy) -
 	    ((char *)src));
+}
 /*
  * uvm_mapent_overhead: calculate maximum kva overhead necessary for
  * map entries.
+ *
  * => size and flags are the same as uvm_km_suballoc's ones.
  */
 vsize_t
 uvm_mapent_overhead(vsize_t size, int flags)
+{
 	if (VM_MAP_USE_KMAPENT_FLAGS(flags)) {
 		return uvm_kmapent_overhead(size);
+	}
 	return 0;
+}
 #if defined(DEBUG)
 static void
 _uvm_mapent_check(const struct vm_map_entry *entry, const char *file, int line)
+{
 	if (entry->start >= entry->end) {
 		goto bad;
+	}
 	if (UVM_ET_ISOBJ(entry)) {
 		if (entry->object.uvm_obj == NULL) {
 			goto bad;
+		}
 	} else if (UVM_ET_ISSUBMAP(entry)) {
 		if (entry->object.sub_map == NULL) {
 			goto bad;
+		}
 	} else {
 		if (entry->object.uvm_obj != NULL ||
 		    entry->object.sub_map != NULL) {
 			goto bad;
+		}
+	}
 	if (!UVM_ET_ISOBJ(entry)) {
 		if (entry->offset != 0) {
 			goto bad;
+		}
+	}
 	return;
 bad:
 	panic("%s: bad entry %p (%s:%d)", __func__, entry, file, line);
+}
 #endif /* defined(DEBUG) */
 /*
  * uvm_map_entry_unwire: unwire a map entry
+ *
  * => map should be locked by caller
  */
 static inline void
 uvm_map_entry_unwire(struct vm_map *map, struct vm_map_entry *entry)
+{
 	entry->wired_count = 0;
 	uvm_fault_unwire_locked(map, entry->start, entry->end);
+}
 /*
  * wrapper for calling amap_ref()
  */
 static inline void
 uvm_map_reference_amap(struct vm_map_entry *entry, int flags)
+{
 	amap_ref(entry->aref.ar_amap, entry->aref.ar_pageoff,
 	    (entry->end - entry->start) >> PAGE_SHIFT, flags);
+}
 /*
  * wrapper for calling amap_unref()
  */
 static inline void
 uvm_map_unreference_amap(struct vm_map_entry *entry, int flags)
+{
 	amap_unref(entry->aref.ar_amap, entry->aref.ar_pageoff,
 	    (entry->end - entry->start) >> PAGE_SHIFT, flags);
+}
 /*
  * uvm_map_init: init mapping system at boot time.
  */
 void
 uvm_map_init(void)
+{
 #if defined(UVMHIST)
 	static struct uvm_history_ent maphistbuf[100];
 	static struct uvm_history_ent pdhistbuf[100];
 #endif
 	/*
 	 * first, init logging system.
 	 */
 	UVMHIST_FUNC("uvm_map_init");
 	UVMHIST_INIT_STATIC(maphist, maphistbuf);
 	UVMHIST_INIT_STATIC(pdhist, pdhistbuf);
 	UVMHIST_CALLED(maphist);
 	UVMHIST_LOG(maphist,"<starting uvm map system>", 0, 0, 0, 0);
 	/*
 	 * initialize the global lock for kernel map entry.
 	 */
 	mutex_init(&uvm_kentry_lock, MUTEX_DRIVER, IPL_VM);
 	/*
 	 * initialize caches.
 	 */
 	pool_cache_bootstrap(&uvm_map_entry_cache, sizeof(struct vm_map_entry),
 , 0, 0, "vmmpepl", NULL, IPL_NONE, NULL, NULL, NULL);
 	pool_cache_bootstrap(&uvm_vmspace_cache, sizeof(struct vmspace),
 , 0, 0, "vmsppl", NULL, IPL_NONE, NULL, NULL, NULL);
+}
 /*
  * clippers
  */
 /*
  * uvm_mapent_splitadj: adjust map entries for splitting, after uvm_mapent_copy.
  */
 static void
 uvm_mapent_splitadj(struct vm_map_entry *entry1, struct vm_map_entry *entry2,
     vaddr_t splitat)
+{
 	vaddr_t adj;
 	KASSERT(entry1->start < splitat);
 	KASSERT(splitat < entry1->end);
 	adj = splitat - entry1->start;
 	entry1->end = entry2->start = splitat;
 	if (entry1->aref.ar_amap) {
 		amap_splitref(&entry1->aref, &entry2->aref, adj);
+	}
 	if (UVM_ET_ISSUBMAP(entry1)) {
 		/* ... unlikely to happen, but play it safe */
 		 uvm_map_reference(entry1->object.sub_map);
 	} else if (UVM_ET_ISOBJ(entry1)) {
 		KASSERT(entry1->object.uvm_obj != NULL); /* suppress coverity */
 		entry2->offset += adj;
 		if (entry1->object.uvm_obj->pgops &&
 		    entry1->object.uvm_obj->pgops->pgo_reference)
 			entry1->object.uvm_obj->pgops->pgo_reference(
 			    entry1->object.uvm_obj);
+	}
+}
 /*
  * uvm_map_clip_start: ensure that the entry begins at or after
  *	the starting address, if it doesn't we split the entry.
+ *
  * => caller should use UVM_MAP_CLIP_START macro rather than calling
  *    this directly
  * => map must be locked by caller
  */
 void
 uvm_map_clip_start(struct vm_map *map, struct vm_map_entry *entry,
     vaddr_t start, struct uvm_mapent_reservation *umr)
+{
 	struct vm_map_entry *new_entry;
 	/* uvm_map_simplify_entry(map, entry); */ /* XXX */
 	uvm_map_check(map, "clip_start entry");
 	uvm_mapent_check(entry);
 	/*
 	 * Split off the front portion.  note that we must insert the new
 	 * entry BEFORE this one, so that this entry has the specified
 	 * starting address.
 	 */
 	new_entry = uvm_mapent_alloc_split(map, entry, 0, umr);
 	uvm_mapent_copy(entry, new_entry); /* entry -> new_entry */
 	uvm_mapent_splitadj(new_entry, entry, start);
 	uvm_map_entry_link(map, entry->prev, new_entry);
 	uvm_map_check(map, "clip_start leave");
+}
 /*
  * uvm_map_clip_end: ensure that the entry ends at or before
  *	the ending address, if it does't we split the reference
+ *
  * => caller should use UVM_MAP_CLIP_END macro rather than calling
  *    this directly
  * => map must be locked by caller
  */
 void
 uvm_map_clip_end(struct vm_map *map, struct vm_map_entry *entry, vaddr_t end,
     struct uvm_mapent_reservation *umr)
+{
 	struct vm_map_entry *new_entry;
 	uvm_map_check(map, "clip_end entry");
 	uvm_mapent_check(entry);
 	/*
 	 *	Create a new entry and insert it
 	 *	AFTER the specified entry
 	 */
 	new_entry = uvm_mapent_alloc_split(map, entry, 0, umr);
 	uvm_mapent_copy(entry, new_entry); /* entry -> new_entry */
 	uvm_mapent_splitadj(entry, new_entry, end);
 	uvm_map_entry_link(map, entry, new_entry);
 	uvm_map_check(map, "clip_end leave");
+}
 static void
 vm_map_drain(struct vm_map *map, uvm_flag_t flags)
+{
 	if (!VM_MAP_IS_KERNEL(map)) {
 		return;
+	}
 	uvm_km_va_drain(map, flags);
+}
 /*
  *   M A P   -   m a i n   e n t r y   p o i n t
  */
 /*
  * uvm_map: establish a valid mapping in a map
+ *
  * => assume startp is page aligned.
  * => assume size is a multiple of PAGE_SIZE.
  * => assume sys_mmap provides enough of a "hint" to have us skip
  *	over text/data/bss area.
  * => map must be unlocked (we will lock it)
  * => <uobj,uoffset> value meanings (4 cases):
  *	 [1] <NULL,uoffset>		== uoffset is a hint for PMAP_PREFER
  *	 [2] <NULL,UVM_UNKNOWN_OFFSET>	== don't PMAP_PREFER
  *	 [3] <uobj,uoffset>		== normal mapping
  *	 [4] <uobj,UVM_UNKNOWN_OFFSET>	== uvm_map finds offset based on VA
+ *
  *    case [4] is for kernel mappings where we don't know the offset until
  *    we've found a virtual address.   note that kernel object offsets are
  *    always relative to vm_map_min(kernel_map).
+ *
  * => if `align' is non-zero, we align the virtual address to the specified
  *	alignment.
  *	this is provided as a mechanism for large pages.
+ *
  * => XXXCDC: need way to map in external amap?
  */
 int
 uvm_map(struct vm_map *map, vaddr_t *startp /* IN/OUT */, vsize_t size,
     struct uvm_object *uobj, voff_t uoffset, vsize_t align, uvm_flag_t flags)
+{
 	struct uvm_map_args args;
 	struct vm_map_entry *new_entry;
 	int error;
 	KASSERT((flags & UVM_FLAG_QUANTUM) == 0 || VM_MAP_IS_KERNEL(map));
 	KASSERT((size & PAGE_MASK) == 0);
 	/*
 	 * for pager_map, allocate the new entry first to avoid sleeping
 	 * for memory while we have the map locked.
+	 *
 	 * Also, because we allocate entries for in-kernel maps
 	 * a bit differently (cf. uvm_kmapent_alloc/free), we need to
 	 * allocate them before locking the map.
 	 */
 	new_entry = NULL;
 	if (VM_MAP_USE_KMAPENT(map) || (flags & UVM_FLAG_QUANTUM) ||
 	    map == pager_map) {
 		new_entry = uvm_mapent_alloc(map, (flags & UVM_FLAG_NOWAIT));
 		if (__predict_false(new_entry == NULL))
 			return ENOMEM;
 		if (flags & UVM_FLAG_QUANTUM)
 			new_entry->flags |= UVM_MAP_QUANTUM;
+	}
 	if (map == pager_map)
 		flags |= UVM_FLAG_NOMERGE;
 	error = uvm_map_prepare(map, *startp, size, uobj, uoffset, align,
 	    flags, &args);
 	if (!error) {
 		error = uvm_map_enter(map, &args, new_entry);
 		*startp = args.uma_start;
 	} else if (new_entry) {
 		uvm_mapent_free(new_entry);
+	}
 #if defined(DEBUG)
 	if (!error && VM_MAP_IS_KERNEL(map)) {
 		uvm_km_check_empty(map, *startp, *startp + size);
+	}
 #endif /* defined(DEBUG) */
 	return error;
+}
 int
 uvm_map_prepare(struct vm_map *map, vaddr_t start, vsize_t size,
     struct uvm_object *uobj, voff_t uoffset, vsize_t align, uvm_flag_t flags,
     struct uvm_map_args *args)
+{
 	struct vm_map_entry *prev_entry;
 	vm_prot_t prot = UVM_PROTECTION(flags);
 	vm_prot_t maxprot = UVM_MAXPROTECTION(flags);
 	UVMHIST_FUNC("uvm_map_prepare");
 	UVMHIST_CALLED(maphist);
 	UVMHIST_LOG(maphist, "(map=0x%x, start=0x%x, size=%d, flags=0x%x)",
 	    map, start, size, flags);
 	UVMHIST_LOG(maphist, "  uobj/offset 0x%x/%d", uobj, uoffset,0,0);
 	/*
 	 * detect a popular device driver bug.
 	 */
 	KASSERT(doing_shutdown || curlwp != NULL ||
 	    (map->flags & VM_MAP_INTRSAFE));
 	/*
 	 * zero-sized mapping doesn't make any sense.
 	 */
 	KASSERT(size > 0);
 	KASSERT((~flags & (UVM_FLAG_NOWAIT | UVM_FLAG_WAITVA)) != 0);
 	uvm_map_check(map, "map entry");
 	/*
 	 * check sanity of protection code
 	 */
 	if ((prot & maxprot) != prot) {
 		UVMHIST_LOG(maphist, "<- prot. failure:  prot=0x%x, max=0x%x",
 		prot, maxprot,0,0);
 		return EACCES;
+	}
 	/*
 	 * figure out where to put new VM range
 	 */
 retry:
 	if (vm_map_lock_try(map) == false) {
 		if ((flags & UVM_FLAG_TRYLOCK) != 0 &&
 		    (map->flags & VM_MAP_INTRSAFE) == 0) {
 			return EAGAIN;
+		}
 		vm_map_lock(map); /* could sleep here */
+	}
 	prev_entry = uvm_map_findspace(map, start, size, &start,
 	    uobj, uoffset, align, flags);
 	if (prev_entry == NULL) {
 		unsigned int timestamp;
 		timestamp = map->timestamp;
 		UVMHIST_LOG(maphist,"waiting va timestamp=0x%x",
 			    timestamp,0,0,0);
 		map->flags |= VM_MAP_WANTVA;
 		vm_map_unlock(map);
 		/*
 		 * try to reclaim kva and wait until someone does unmap.
 		 * fragile locking here, so we awaken every second to
 		 * recheck the condition.
 		 */
 		vm_map_drain(map, flags);
 		mutex_enter(&map->misc_lock);
 		while ((map->flags & VM_MAP_WANTVA) != 0 &&
 		   map->timestamp == timestamp) {
 			if ((flags & UVM_FLAG_WAITVA) == 0) {
 				mutex_exit(&map->misc_lock);
 				UVMHIST_LOG(maphist,
 				    "<- uvm_map_findspace failed!", 0,0,0,0);
 				return ENOMEM;
 			} else {
 				cv_timedwait(&map->cv, &map->misc_lock, hz);
+			}
+		}
 		mutex_exit(&map->misc_lock);
 		goto retry;
+	}
 #ifdef PMAP_GROWKERNEL
 	/*
 	 * If the kernel pmap can't map the requested space,
 	 * then allocate more resources for it.
 	 */
 	if (map == kernel_map && uvm_maxkaddr < (start + size))
 		uvm_maxkaddr = pmap_growkernel(start + size);
 #endif
 	UVMMAP_EVCNT_INCR(map_call);
 	/*
 	 * if uobj is null, then uoffset is either a VAC hint for PMAP_PREFER
 	 * [typically from uvm_map_reserve] or it is UVM_UNKNOWN_OFFSET.   in
 	 * either case we want to zero it  before storing it in the map entry
 	 * (because it looks strange and confusing when debugging...)
+	 *
 	 * if uobj is not null
 	 *   if uoffset is not UVM_UNKNOWN_OFFSET then we have a normal mapping
 	 *      and we do not need to change uoffset.
 	 *   if uoffset is UVM_UNKNOWN_OFFSET then we need to find the offset
 	 *      now (based on the starting address of the map).   this case is
 	 *      for kernel object mappings where we don't know the offset until
 	 *      the virtual address is found (with uvm_map_findspace).   the
 	 *      offset is the distance we are from the start of the map.
 	 */
 	if (uobj == NULL) {
 		uoffset = 0;
 	} else {
 		if (uoffset == UVM_UNKNOWN_OFFSET) {
 			KASSERT(UVM_OBJ_IS_KERN_OBJECT(uobj));
 			uoffset = start - vm_map_min(kernel_map);
+		}
+	}
 	args->uma_flags = flags;
 	args->uma_prev = prev_entry;
 	args->uma_start = start;
 	args->uma_size = size;
 	args->uma_uobj = uobj;
 	args->uma_uoffset = uoffset;
 	UVMHIST_LOG(maphist, "<- done!", 0,0,0,0);
 	return 0;
+}
 int
 uvm_map_enter(struct vm_map *map, const struct uvm_map_args *args,
     struct vm_map_entry *new_entry)
+{
 	struct vm_map_entry *prev_entry = args->uma_prev;
 	struct vm_map_entry *dead = NULL;
 	const uvm_flag_t flags = args->uma_flags;
 	const vm_prot_t prot = UVM_PROTECTION(flags);
 	const vm_prot_t maxprot = UVM_MAXPROTECTION(flags);
 	const vm_inherit_t inherit = UVM_INHERIT(flags);
 	const int amapwaitflag = (flags & UVM_FLAG_NOWAIT) ?
 	    AMAP_EXTEND_NOWAIT : 0;
 	const int advice = UVM_ADVICE(flags);
 	const int meflagval = (flags & UVM_FLAG_QUANTUM) ?
 	    UVM_MAP_QUANTUM : 0;
 	vaddr_t start = args->uma_start;
 	vsize_t size = args->uma_size;
 	struct uvm_object *uobj = args->uma_uobj;
 	voff_t uoffset = args->uma_uoffset;
 	const int kmap = (vm_map_pmap(map) == pmap_kernel());
 	int merged = 0;
 	int error;
 	int newetype;
 	UVMHIST_FUNC("uvm_map_enter");
 	UVMHIST_CALLED(maphist);
 	UVMHIST_LOG(maphist, "(map=0x%x, start=0x%x, size=%d, flags=0x%x)",
 	    map, start, size, flags);
 	UVMHIST_LOG(maphist, "  uobj/offset 0x%x/%d", uobj, uoffset,0,0);
 	KASSERT(map->hint == prev_entry); /* bimerge case assumes this */
 	if (flags & UVM_FLAG_QUANTUM) {
 		KASSERT(new_entry);
 		KASSERT(new_entry->flags & UVM_MAP_QUANTUM);
+	}
 	if (uobj)
 		newetype = UVM_ET_OBJ;
 	else
 		newetype = 0;
 	if (flags & UVM_FLAG_COPYONW) {
 		newetype |= UVM_ET_COPYONWRITE;
 		if ((flags & UVM_FLAG_OVERLAY) == 0)
 			newetype |= UVM_ET_NEEDSCOPY;
+	}
 	/*
 	 * try and insert in map by extending previous entry, if possible.
 	 * XXX: we don't try and pull back the next entry.   might be useful
 	 * for a stack, but we are currently allocating our stack in advance.
 	 */
 	if (flags & UVM_FLAG_NOMERGE)
 		goto nomerge;
 	if (prev_entry->end == start &&
 	    prev_entry != &map->header &&
 	    UVM_ET_ISCOMPATIBLE(prev_entry, newetype, uobj, meflagval,
 	    prot, maxprot, inherit, advice, 0)) {
 		if (uobj && prev_entry->offset +
 		    (prev_entry->end - prev_entry->start) != uoffset)
 			goto forwardmerge;
 		/*
 		 * can't extend a shared amap.  note: no need to lock amap to
 		 * look at refs since we don't care about its exact value.
 		 * if it is one (i.e. we have only reference) it will stay there
 		 */
 		if (prev_entry->aref.ar_amap &&
 		    amap_refs(prev_entry->aref.ar_amap) != 1) {
 			goto forwardmerge;
+		}
 		if (prev_entry->aref.ar_amap) {
 			error = amap_extend(prev_entry, size,
 			    amapwaitflag | AMAP_EXTEND_FORWARDS);
 			if (error)
 				goto nomerge;
+		}
 		if (kmap) {
 			UVMMAP_EVCNT_INCR(kbackmerge);
 		} else {
 			UVMMAP_EVCNT_INCR(ubackmerge);
+		}
 		UVMHIST_LOG(maphist,"  starting back merge", 0, 0, 0, 0);
 		/*
 		 * drop our reference to uobj since we are extending a reference
 		 * that we already have (the ref count can not drop to zero).
 		 */
 		if (uobj && uobj->pgops->pgo_detach)
 			uobj->pgops->pgo_detach(uobj);
 		/*
 		 * Now that we've merged the entries, note that we've grown
 		 * and our gap has shrunk.  Then fix the tree.
 		 */
 		prev_entry->end += size;
 		prev_entry->gap -= size;
 		uvm_rb_fixup(map, prev_entry);
 		uvm_map_check(map, "map backmerged");
 		UVMHIST_LOG(maphist,"<- done (via backmerge)!", 0, 0, 0, 0);
 		merged++;
+	}
 forwardmerge:
 	if (prev_entry->next->start == (start + size) &&
 	    prev_entry->next != &map->header &&
 	    UVM_ET_ISCOMPATIBLE(prev_entry->next, newetype, uobj, meflagval,
 	    prot, maxprot, inherit, advice, 0)) {
 		if (uobj && prev_entry->next->offset != uoffset + size)
 			goto nomerge;
 		/*
 		 * can't extend a shared amap.  note: no need to lock amap to
 		 * look at refs since we don't care about its exact value.
 		 * if it is one (i.e. we have only reference) it will stay there.
+		 *
 		 * note that we also can't merge two amaps, so if we
 		 * merged with the previous entry which has an amap,
 		 * and the next entry also has an amap, we give up.
+		 *
 		 * Interesting cases:
 		 * amap, new, amap -> give up second merge (single fwd extend)
 		 * amap, new, none -> double forward extend (extend again here)
 		 * none, new, amap -> double backward extend (done here)
 		 * uobj, new, amap -> single backward extend (done here)
+		 *
 		 * XXX should we attempt to deal with someone refilling
 		 * the deallocated region between two entries that are
 		 * backed by the same amap (ie, arefs is 2, "prev" and
 		 * "next" refer to it, and adding this allocation will
 		 * close the hole, thus restoring arefs to 1 and
 		 * deallocating the "next" vm_map_entry)?  -- @@@
 		 */
 		if (prev_entry->next->aref.ar_amap &&
 		    (amap_refs(prev_entry->next->aref.ar_amap) != 1 ||
 		     (merged && prev_entry->aref.ar_amap))) {
 			goto nomerge;
+		}
 		if (merged) {
 			/*
 			 * Try to extend the amap of the previous entry to
 			 * cover the next entry as well.  If it doesn't work
 			 * just skip on, don't actually give up, since we've
 			 * already completed the back merge.
 			 */
 			if (prev_entry->aref.ar_amap) {
 				if (amap_extend(prev_entry,
 				    prev_entry->next->end -
 				    prev_entry->next->start,
 				    amapwaitflag | AMAP_EXTEND_FORWARDS))
 					goto nomerge;
+			}
 			/*
 			 * Try to extend the amap of the *next* entry
 			 * back to cover the new allocation *and* the
 			 * previous entry as well (the previous merge
 			 * didn't have an amap already otherwise we
 			 * wouldn't be checking here for an amap).  If
 			 * it doesn't work just skip on, again, don't
 			 * actually give up, since we've already
 			 * completed the back merge.
 			 */
 			else if (prev_entry->next->aref.ar_amap) {
 				if (amap_extend(prev_entry->next,
 				    prev_entry->end -
 				    prev_entry->start,
 				    amapwaitflag | AMAP_EXTEND_BACKWARDS))
 					goto nomerge;
+			}
 		} else {
 			/*
 			 * Pull the next entry's amap backwards to cover this
 			 * new allocation.
 			 */
 			if (prev_entry->next->aref.ar_amap) {
 				error = amap_extend(prev_entry->next, size,
 				    amapwaitflag | AMAP_EXTEND_BACKWARDS);
 				if (error)
 					goto nomerge;
+			}
+		}
 		if (merged) {
 			if (kmap) {
 				UVMMAP_EVCNT_DECR(kbackmerge);
 				UVMMAP_EVCNT_INCR(kbimerge);
 			} else {
 				UVMMAP_EVCNT_DECR(ubackmerge);
 				UVMMAP_EVCNT_INCR(ubimerge);
+			}
 		} else {
 			if (kmap) {
 				UVMMAP_EVCNT_INCR(kforwmerge);
 			} else {
 				UVMMAP_EVCNT_INCR(uforwmerge);
+			}
+		}
 		UVMHIST_LOG(maphist,"  starting forward merge", 0, 0, 0, 0);
 		/*
 		 * drop our reference to uobj since we are extending a reference
 		 * that we already have (the ref count can not drop to zero).
 		 * (if merged, we've already detached)
 		 */
 		if (uobj && uobj->pgops->pgo_detach && !merged)