 @@ -1,2218 +1,2218 @@
-/*	$NetBSD: machdep.c,v 1.216 2016/05/12 06:45:16 maxv Exp $	*/
+/*	$NetBSD: machdep.c,v 1.217 2016/05/15 10:35:54 maxv Exp $	*/
 /*-
  * Copyright (c) 1996, 1997, 1998, 2000, 2006, 2007, 2008, 2011
  *     The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Charles M. Hannum and by Jason R. Thorpe of the Numerical Aerospace
  * Simulation Facility, NASA Ames Research Center.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Coyote Point Systems, Inc. which was written under contract to Coyote
  * Point by Jed Davis and Devon O'Dell.
+ *
  * 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
  */
 /*
  * Copyright (c) 2006 Mathieu Ropert <mro@adviseo.fr>
+ *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
  * copyright notice and this permission notice appear in all copies.
+ *
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 /*
  * Copyright (c) 2007 Manuel Bouyer.
+ *
  * 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 ``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 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.
+ *
  */
 /*-
  * Copyright (c) 1982, 1987, 1990 The Regents of the University of California.
  * All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * William Jolitz.
+ *
  * 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. 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.
+ *
  *	@(#)machdep.c	7.4 (Berkeley) 6/3/91
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: machdep.c,v 1.216 2016/05/12 06:45:16 maxv Exp $");
+__KERNEL_RCSID(0, "$NetBSD: machdep.c,v 1.217 2016/05/15 10:35:54 maxv Exp $");
 /* #define XENDEBUG_LOW  */
 #include "opt_modular.h"
 #include "opt_user_ldt.h"
 #include "opt_ddb.h"
 #include "opt_kgdb.h"
 #include "opt_cpureset_delay.h"
 #include "opt_mtrr.h"
 #include "opt_realmem.h"
 #include "opt_xen.h"
 #ifndef XEN
 #include "opt_physmem.h"
 #endif
 #include "isa.h"
 #include "pci.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/signal.h>
 #include <sys/signalvar.h>
 #include <sys/kernel.h>
 #include <sys/cpu.h>
 #include <sys/exec.h>
 #include <sys/exec_aout.h>	/* for MID_* */
 #include <sys/reboot.h>
 #include <sys/conf.h>
 #include <sys/mbuf.h>
 #include <sys/msgbuf.h>
 #include <sys/mount.h>
 #include <sys/core.h>
 #include <sys/kcore.h>
 #include <sys/ucontext.h>
 #include <machine/kcore.h>
 #include <sys/ras.h>
 #include <sys/syscallargs.h>
 #include <sys/ksyms.h>
 #include <sys/device.h>
 #include <sys/lwp.h>
 #include <sys/proc.h>
 #ifdef KGDB
 #include <sys/kgdb.h>
 #endif
 #include <dev/cons.h>
 #include <dev/mm.h>
 #include <uvm/uvm.h>
 #include <uvm/uvm_page.h>
 #include <sys/sysctl.h>
 #include <machine/cpu.h>
 #include <machine/cpufunc.h>
 #include <machine/gdt.h>
 #include <machine/intr.h>
 #include <machine/pio.h>
 #include <machine/psl.h>
 #include <machine/reg.h>
 #include <machine/specialreg.h>
 #include <machine/bootinfo.h>
 #include <x86/fpu.h>
 #include <machine/mtrr.h>
 #include <machine/mpbiosvar.h>
 #include <x86/cputypes.h>
 #include <x86/cpuvar.h>
 #include <x86/machdep.h>
 #include <x86/x86/tsc.h>
 #include <dev/isa/isareg.h>
 #include <machine/isa_machdep.h>
 #include <dev/ic/i8042reg.h>
 #ifdef XEN
 #include <xen/xen.h>
 #include <xen/hypervisor.h>
 #include <xen/evtchn.h>
 #endif
 #ifdef DDB
 #include <machine/db_machdep.h>
 #include <ddb/db_extern.h>
 #include <ddb/db_output.h>
 #include <ddb/db_interface.h>
 #endif
 #include "acpica.h"
 #if NACPICA > 0
 #include <dev/acpi/acpivar.h>
 #define ACPI_MACHDEP_PRIVATE
 #include <machine/acpi_machdep.h>
 #endif
 #include "isa.h"
 #include "isadma.h"
 #include "ksyms.h"
 /* the following is used externally (sysctl_hw) */
 char machine[] = "amd64";		/* CPU "architecture" */
 char machine_arch[] = "x86_64";		/* machine == machine_arch */
 extern struct bi_devmatch *x86_alldisks;
 extern int x86_ndisks;
 #ifdef CPURESET_DELAY
 int	cpureset_delay = CPURESET_DELAY;
 #else
 int     cpureset_delay = 2000; /* default to 2s */
 #endif
 int	cpu_class = CPUCLASS_686;
 #ifdef MTRR
 struct mtrr_funcs *mtrr_funcs;
 #endif
 uint64_t	dumpmem_low;
 uint64_t	dumpmem_high;
 int	cpu_class;
 int	use_pae;
 #ifndef NO_SPARSE_DUMP
 int sparse_dump = 1;
 paddr_t max_paddr = 0;
 unsigned char *sparse_dump_physmap;
 #endif
 char *dump_headerbuf, *dump_headerbuf_ptr;
 #define dump_headerbuf_size PAGE_SIZE
 #define dump_headerbuf_end (dump_headerbuf + dump_headerbuf_size)
 #define dump_headerbuf_avail (dump_headerbuf_end - dump_headerbuf_ptr)
 daddr_t dump_header_blkno;
 size_t dump_nmemsegs;
 size_t dump_npages;
 size_t dump_header_size;
 size_t dump_totalbytesleft;
 vaddr_t	msgbuf_vaddr;
 paddr_t msgbuf_paddr;
 struct {
 	paddr_t paddr;
 	psize_t sz;
 } msgbuf_p_seg[VM_PHYSSEG_MAX];
 unsigned int msgbuf_p_cnt = 0;
 vaddr_t	idt_vaddr;
 paddr_t	idt_paddr;
 vaddr_t lo32_vaddr;
 paddr_t lo32_paddr;
 vaddr_t module_start, module_end;
 static struct vm_map module_map_store;
 extern struct vm_map *module_map;
 vaddr_t kern_end;
 struct vm_map *phys_map = NULL;
 extern	paddr_t avail_start, avail_end;
 #ifdef XEN
 extern  paddr_t pmap_pa_start, pmap_pa_end;
 #endif
 #ifndef XEN
 void (*delay_func)(unsigned int) = i8254_delay;
 void (*initclock_func)(void) = i8254_initclocks;
 #else /* XEN */
 void (*delay_func)(unsigned int) = xen_delay;
 void (*initclock_func)(void) = xen_initclocks;
 #endif
 /*
  * Size of memory segments, before any memory is stolen.
  */
 phys_ram_seg_t mem_clusters[VM_PHYSSEG_MAX];
 int	mem_cluster_cnt;
 char	x86_64_doubleflt_stack[4096];
 int	cpu_dump(void);
 int	cpu_dumpsize(void);
 u_long	cpu_dump_mempagecnt(void);
 void	dodumpsys(void);
 void	dumpsys(void);
 extern int time_adjusted;	/* XXX no common header */
 void dump_misc_init(void);
 void dump_seg_prep(void);
 int dump_seg_iter(int (*)(paddr_t, paddr_t));
 #ifndef NO_SPARSE_DUMP
 void sparse_dump_reset(void);
 void sparse_dump_mark(void);
 void cpu_dump_prep_sparse(void);
 #endif
 void dump_header_start(void);
 int dump_header_flush(void);
 int dump_header_addbytes(const void*, size_t);
 int dump_header_addseg(paddr_t, paddr_t);
 int dump_header_finish(void);
 int dump_seg_count_range(paddr_t, paddr_t);
 int dumpsys_seg(paddr_t, paddr_t);
 void	init_x86_64(paddr_t);
 static int valid_user_selector(struct lwp *, uint64_t);
 /*
  * Machine-dependent startup code
  */
 void
 cpu_startup(void)
+{
 	int x, y;
 	vaddr_t minaddr, maxaddr;
 	psize_t sz;
 	/*
 	 * For console drivers that require uvm and pmap to be initialized,
 	 * we'll give them one more chance here...
 	 */
 	consinit();
 	/*
 	 * Initialize error message buffer (et end of core).
 	 */
 	if (msgbuf_p_cnt == 0)
 		panic("msgbuf paddr map has not been set up");
 	for (x = 0, sz = 0; x < msgbuf_p_cnt; sz += msgbuf_p_seg[x++].sz)
 		continue;
 	msgbuf_vaddr = uvm_km_alloc(kernel_map, sz, 0,
 	    UVM_KMF_VAONLY);
 	if (msgbuf_vaddr == 0)
 		panic("failed to valloc msgbuf_vaddr");
 	/* msgbuf_paddr was init'd in pmap */
 	for (y = 0, sz = 0; y < msgbuf_p_cnt; y++) {
 		for (x = 0; x < btoc(msgbuf_p_seg[y].sz); x++, sz += PAGE_SIZE)
 			pmap_kenter_pa((vaddr_t)msgbuf_vaddr + sz,
 				       msgbuf_p_seg[y].paddr + x * PAGE_SIZE,
 				       VM_PROT_READ | UVM_PROT_WRITE, 0);
+	}
 	pmap_update(pmap_kernel());
 	initmsgbuf((void *)msgbuf_vaddr, round_page(sz));
 	minaddr = 0;
 	/*
 	 * Allocate a submap for physio
 	 */
 	phys_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr,
 				   VM_PHYS_SIZE, 0, false, NULL);
 	uvm_map_setup(&module_map_store, module_start, module_end, 0);
 	module_map_store.pmap = pmap_kernel();
 	module_map = &module_map_store;
 	/* Say hello. */
 	banner();
 #if NISA > 0 || NPCI > 0
 	/* Safe for i/o port / memory space allocation to use malloc now. */
 	x86_bus_space_mallocok();
 #endif
 	gdt_init();
 	x86_64_proc0_tss_ldt_init();
 	cpu_init_tss(&cpu_info_primary);
 #if !defined(XEN)
 	ltr(cpu_info_primary.ci_tss_sel);
 #endif /* !defined(XEN) */
 	x86_startup();
+}
 #ifdef XEN
 /* used in assembly */
 void hypervisor_callback(void);
 void failsafe_callback(void);
 void x86_64_switch_context(struct pcb *);
 void x86_64_tls_switch(struct lwp *);
 void
 x86_64_switch_context(struct pcb *new)
+{
 	HYPERVISOR_stack_switch(GSEL(GDATA_SEL, SEL_KPL), new->pcb_rsp0);
 	struct physdev_op physop;
 	physop.cmd = PHYSDEVOP_SET_IOPL;
 	physop.u.set_iopl.iopl = new->pcb_iopl;
 	HYPERVISOR_physdev_op(&physop);
+}
 void
 x86_64_tls_switch(struct lwp *l)
+{
 	struct cpu_info *ci = curcpu();
 	struct pcb *pcb = lwp_getpcb(l);
 	struct trapframe *tf = l->l_md.md_regs;
 	/*
 	 * Raise the IPL to IPL_HIGH.
 	 * FPU IPIs can alter the LWP's saved cr0.  Dropping the priority
 	 * is deferred until mi_switch(), when cpu_switchto() returns.
 	 */
 	(void)splhigh();
 	/*
 	 * If our floating point registers are on a different CPU,
 	 * set CR0_TS so we'll trap rather than reuse bogus state.
 	 */
 	if (l != ci->ci_fpcurlwp) {
 		HYPERVISOR_fpu_taskswitch(1);
+	}
 	/* Update TLS segment pointers */
 	if (pcb->pcb_flags & PCB_COMPAT32) {
 		update_descriptor(&curcpu()->ci_gdt[GUFS_SEL], &pcb->pcb_fs);
 		update_descriptor(&curcpu()->ci_gdt[GUGS_SEL], &pcb->pcb_gs);
 		setfs(tf->tf_fs);
 		HYPERVISOR_set_segment_base(SEGBASE_GS_USER_SEL, tf->tf_gs);
 	} else {
 		setfs(0);
 		HYPERVISOR_set_segment_base(SEGBASE_GS_USER_SEL, 0);
 		HYPERVISOR_set_segment_base(SEGBASE_FS, pcb->pcb_fs);
 		HYPERVISOR_set_segment_base(SEGBASE_GS_USER, pcb->pcb_gs);
+	}
+}
 #endif /* XEN */
 /*
  * Set up proc0's TSS and LDT.
  */
 void
 x86_64_proc0_tss_ldt_init(void)
+{
 	struct lwp *l = &lwp0;
 	struct pcb *pcb = lwp_getpcb(l);
 	pcb->pcb_flags = 0;
 	pcb->pcb_fs = 0;
 	pcb->pcb_gs = 0;
 	pcb->pcb_rsp0 = (uvm_lwp_getuarea(l) + USPACE - 16) & ~0xf;
 	pcb->pcb_iopl = SEL_KPL;
 	pmap_kernel()->pm_ldt_sel = GSYSSEL(GLDT_SEL, SEL_KPL);
 	pcb->pcb_cr0 = rcr0() & ~CR0_TS;
 	l->l_md.md_regs = (struct trapframe *)pcb->pcb_rsp0 - 1;
 #if !defined(XEN)
 	lldt(pmap_kernel()->pm_ldt_sel);
 #else
+	{
 	struct physdev_op physop;
 	xen_set_ldt((vaddr_t) ldtstore, LDT_SIZE >> 3);
 	/* Reset TS bit and set kernel stack for interrupt handlers */
 	HYPERVISOR_fpu_taskswitch(1);
 	HYPERVISOR_stack_switch(GSEL(GDATA_SEL, SEL_KPL), pcb->pcb_rsp0);
 	physop.cmd = PHYSDEVOP_SET_IOPL;
 	physop.u.set_iopl.iopl = pcb->pcb_iopl;
 	HYPERVISOR_physdev_op(&physop);
+	}
 #endif /* XEN */
+}
 /*
  * Set up TSS and I/O bitmap.
  */
 void
 cpu_init_tss(struct cpu_info *ci)
+{
 	struct x86_64_tss *tss = &ci->ci_tss;
 	uintptr_t p;
 	tss->tss_iobase = IOMAP_INVALOFF << 16;
 	/* tss->tss_ist[0] is filled by cpu_intr_init */
 	/* double fault */
 	tss->tss_ist[1] = (uint64_t)x86_64_doubleflt_stack + PAGE_SIZE - 16;
 	/* NMI */
 	p = uvm_km_alloc(kernel_map, PAGE_SIZE, 0, UVM_KMF_WIRED);
 	tss->tss_ist[2] = p + PAGE_SIZE - 16;
 	ci->ci_tss_sel = tss_alloc(tss);
+}
 void
 buildcontext(struct lwp *l, void *catcher, void *f)
+{
 	struct trapframe *tf = l->l_md.md_regs;
 	tf->tf_ds = GSEL(GUDATA_SEL, SEL_UPL);
 	tf->tf_es = GSEL(GUDATA_SEL, SEL_UPL);
 	tf->tf_fs = GSEL(GUDATA_SEL, SEL_UPL);
 	tf->tf_gs = GSEL(GUDATA_SEL, SEL_UPL);
 	tf->tf_rip = (uint64_t)catcher;
 	tf->tf_cs = GSEL(GUCODE_SEL, SEL_UPL);
 	tf->tf_rflags &= ~PSL_CLEARSIG;
 	tf->tf_rsp = (uint64_t)f;
 	tf->tf_ss = GSEL(GUDATA_SEL, SEL_UPL);
 	/* Ensure FP state is sane */
 	fpu_save_area_reset(l);
+}
 void
 sendsig_sigcontext(const ksiginfo_t *ksi, const sigset_t *mask)
+{
 	printf("sendsig_sigcontext: illegal\n");
 	sigexit(curlwp, SIGILL);
+}
 void
 sendsig_siginfo(const ksiginfo_t *ksi, const sigset_t *mask)
+{
 	struct lwp *l = curlwp;
 	struct proc *p = l->l_proc;
 	struct sigacts *ps = p->p_sigacts;
 	int onstack, error;
 	int sig = ksi->ksi_signo;
 	struct sigframe_siginfo *fp, frame;
 	sig_t catcher = SIGACTION(p, sig).sa_handler;
 	struct trapframe *tf = l->l_md.md_regs;
 	char *sp;
 	KASSERT(mutex_owned(p->p_lock));
 	/* Do we need to jump onto the signal stack? */
 	onstack =
 	    (l->l_sigstk.ss_flags & (SS_DISABLE | SS_ONSTACK)) == 0 &&
 	    (SIGACTION(p, sig).sa_flags & SA_ONSTACK) != 0;
 	/* Allocate space for the signal handler context. */
 	if (onstack)
 		sp = ((char *)l->l_sigstk.ss_sp + l->l_sigstk.ss_size);
 	else
 		/* AMD64 ABI 128-bytes "red zone". */
 		sp = (char *)tf->tf_rsp - 128;
 	sp -= sizeof(struct sigframe_siginfo);
 	/* Round down the stackpointer to a multiple of 16 for the ABI. */
 	fp = (struct sigframe_siginfo *)(((unsigned long)sp & ~15) - 8);
 	frame.sf_ra = (uint64_t)ps->sa_sigdesc[sig].sd_tramp;
 	frame.sf_si._info = ksi->ksi_info;
 	frame.sf_uc.uc_flags = _UC_SIGMASK;
 	frame.sf_uc.uc_sigmask = *mask;
 	frame.sf_uc.uc_link = l->l_ctxlink;
 	frame.sf_uc.uc_flags |= (l->l_sigstk.ss_flags & SS_ONSTACK)
 	    ? _UC_SETSTACK : _UC_CLRSTACK;
 	memset(&frame.sf_uc.uc_stack, 0, sizeof(frame.sf_uc.uc_stack));
 	sendsig_reset(l, sig);
 	mutex_exit(p->p_lock);
 	cpu_getmcontext(l, &frame.sf_uc.uc_mcontext, &frame.sf_uc.uc_flags);
 	/* Copyout all the fp regs, the signal handler might expect them. */
 	error = copyout(&frame, fp, sizeof frame);
 	mutex_enter(p->p_lock);
 	if (error != 0) {
 		/*
 		 * Process has trashed its stack; give it an illegal
 		 * instruction to halt it in its tracks.
 		 */
 		sigexit(l, SIGILL);
 		/* NOTREACHED */
+	}
 	buildcontext(l, catcher, fp);
 	tf->tf_rdi = sig;
 	tf->tf_rsi = (uint64_t)&fp->sf_si;
 	tf->tf_rdx = tf->tf_r15 = (uint64_t)&fp->sf_uc;
 	/* Remember that we're now on the signal stack. */
 	if (onstack)
 		l->l_sigstk.ss_flags |= SS_ONSTACK;
 	if ((vaddr_t)catcher >= VM_MAXUSER_ADDRESS) {
 		/*
 		 * process has given an invalid address for the
 		 * handler. Stop it, but do not do it before so
 		 * we can return the right info to userland (or in core dump)
 		 */
 		sigexit(l, SIGILL);
 		/* NOTREACHED */
+	}
+}
 struct pcb dumppcb;
 void
 cpu_reboot(int howto, char *bootstr)
+{
 	static bool syncdone = false;
 	int s = IPL_NONE;
 	__USE(s);	/* ugly otherwise */
 	if (cold) {
 		howto |= RB_HALT;
 		goto haltsys;
+	}
 	boothowto = howto;
 	/* i386 maybe_dump() */
 	/*
 	 * If we've panic'd, don't make the situation potentially
 	 * worse by syncing or unmounting the file systems.
 	 */
 	if ((howto & RB_NOSYNC) == 0 && panicstr == NULL) {
 		if (!syncdone) {
 			syncdone = true;
 			/* XXX used to force unmount as well, here */
 			vfs_sync_all(curlwp);
 			/*
 			 * If we've been adjusting the clock, the todr
 			 * will be out of synch; adjust it now.
+			 *
 			 * XXX used to do this after unmounting all
 			 * filesystems with vfs_shutdown().
 			 */
 			if (time_adjusted != 0)
 				resettodr();
+		}
 		while (vfs_unmountall1(curlwp, false, false) ||
 		       config_detach_all(boothowto) ||
 		       vfs_unmount_forceone(curlwp))
 			;	/* do nothing */
 	} else
 		suspendsched();
 	pmf_system_shutdown(boothowto);
 	/* Disable interrupts. */
 	s = splhigh();
 	/* Do a dump if requested. */
 	if ((howto & (RB_DUMP | RB_HALT)) == RB_DUMP)
 		dumpsys();
 haltsys:
 	doshutdownhooks();
         if ((howto & RB_POWERDOWN) == RB_POWERDOWN) {
 #if NACPICA > 0
 		if (s != IPL_NONE)
 			splx(s);
 		acpi_enter_sleep_state(ACPI_STATE_S5);
 #endif
 #ifdef XEN
 		HYPERVISOR_shutdown();
 #endif /* XEN */
+	}
 	cpu_broadcast_halt();
 	if (howto & RB_HALT) {
 #if NACPICA > 0
 		acpi_disable();
 #endif
 		printf("\n");
 		printf("The operating system has halted.\n");
 		printf("Please press any key to reboot.\n\n");
 		cnpollc(1);	/* for proper keyboard command handling */
 		if (cngetc() == 0) {
 			/* no console attached, so just hlt */
 			printf("No keyboard - cannot reboot after all.\n");
 			for(;;) {
 				x86_hlt();
+			}
+		}
 		cnpollc(0);
+	}
 	printf("rebooting...\n");
 	if (cpureset_delay > 0)
 		delay(cpureset_delay * 1000);
 	cpu_reset();
 	for(;;) ;
 	/*NOTREACHED*/
+}
 /*
  * XXXfvdl share dumpcode.
  */
 /*
  * Perform assorted dump-related initialization tasks.  Assumes that
  * the maximum physical memory address will not increase afterwards.
  */
 void
 dump_misc_init(void)
+{
 #ifndef NO_SPARSE_DUMP
 	int i;
 #endif
 	if (dump_headerbuf != NULL)
 		return; /* already called */
 #ifndef NO_SPARSE_DUMP
 	for (i = 0; i < mem_cluster_cnt; ++i) {
 		paddr_t top = mem_clusters[i].start + mem_clusters[i].size;
 		if (max_paddr < top)
 			max_paddr = top;
+	}
 #ifdef DEBUG
 	printf("dump_misc_init: max_paddr = 0x%lx\n",
 	    (unsigned long)max_paddr);
 #endif
 	if (max_paddr == 0) {
 		printf("Your machine does not initialize mem_clusters; "
 		    "sparse_dumps disabled\n");
 		sparse_dump = 0;
 	} else {
 		sparse_dump_physmap = (void *)uvm_km_alloc(kernel_map,
 		    roundup(max_paddr / (PAGE_SIZE * NBBY), PAGE_SIZE),
 		    PAGE_SIZE, UVM_KMF_WIRED|UVM_KMF_ZERO);
+	}
 #endif
 	dump_headerbuf = (void *)uvm_km_alloc(kernel_map,
 	    dump_headerbuf_size,
 	    PAGE_SIZE, UVM_KMF_WIRED|UVM_KMF_ZERO);
 	/* XXXjld should check for failure here, disable dumps if so. */
+}
 #ifndef NO_SPARSE_DUMP
 /*
  * Clear the set of pages to include in a sparse dump.
  */
 void
 sparse_dump_reset(void)
+{
 	memset(sparse_dump_physmap, 0,
 	    roundup(max_paddr / (PAGE_SIZE * NBBY), PAGE_SIZE));
+}
 /*
  * Include or exclude pages in a sparse dump.
  */
 void
 sparse_dump_mark(void)
+{
 	paddr_t p, pstart, pend;
 	struct vm_page *pg;
 	int i;
 	/*
 	 * Mark all memory pages, then unmark pages that are uninteresting.
 	 * Dereferenceing pg->uobject might crash again if another CPU
 	 * frees the object out from under us, but we can't lock anything
 	 * so it's a risk we have to take.
 	 */
 	for (i = 0; i < mem_cluster_cnt; ++i) {
 		pstart = mem_clusters[i].start / PAGE_SIZE;
 		pend = pstart + mem_clusters[i].size / PAGE_SIZE;
 		for (p = pstart; p < pend; p++) {
 			setbit(sparse_dump_physmap, p);
+		}
+	}
 	for (i = 0; i < vm_nphysseg; i++) {
 		struct vm_physseg *seg = VM_PHYSMEM_PTR(i);
 		for (pg = seg->pgs; pg < seg->lastpg; pg++) {
 			if (pg->uanon || (pg->pqflags & PQ_FREE) ||
 			    (pg->uobject && pg->uobject->pgops)) {
 				p = VM_PAGE_TO_PHYS(pg) / PAGE_SIZE;
 				clrbit(sparse_dump_physmap, p);
+			}
+		}
+	}
+}
 /*
  * Machine-dependently decides on the contents of a sparse dump, using
  * the above.
  */
 void
 cpu_dump_prep_sparse(void)
+{
 	sparse_dump_reset();
 	/* XXX could the alternate recursive page table be skipped? */
 	sparse_dump_mark();
 	/* Memory for I/O buffers could be unmarked here, for example. */
 	/* The kernel text could also be unmarked, but gdb would be upset. */
+}
 #endif
 /*
  * Abstractly iterate over the collection of memory segments to be
  * dumped; the callback lacks the customary environment-pointer
  * argument because none of the current users really need one.
+ *
  * To be used only after dump_seg_prep is called to set things up.
  */
 int
 dump_seg_iter(int (*callback)(paddr_t, paddr_t))
+{
 	int error, i;
 #define CALLBACK(start,size) do {     \
 	error = callback(start,size); \
 	if (error)                    \
 		return error;         \
 } while(0)
 	for (i = 0; i < mem_cluster_cnt; ++i) {
 #ifndef NO_SPARSE_DUMP
 		/*
 		 * The bitmap is scanned within each memory segment,
 		 * rather than over its entire domain, in case any
 		 * pages outside of the memory proper have been mapped
 		 * into kva; they might be devices that wouldn't
 		 * appreciate being arbitrarily read, and including
 		 * them could also break the assumption that a sparse
 		 * dump will always be smaller than a full one.
 		 */
 		if (sparse_dump && sparse_dump_physmap) {
 			paddr_t p, start, end;
 			int lastset;
 			start = mem_clusters[i].start;
 			end = start + mem_clusters[i].size;
 			start = rounddown(start, PAGE_SIZE); /* unnecessary? */
 			lastset = 0;
 			for (p = start; p < end; p += PAGE_SIZE) {
 				int thisset = isset(sparse_dump_physmap,
 				    p/PAGE_SIZE);
 				if (!lastset && thisset)
 					start = p;
 				if (lastset && !thisset)
 					CALLBACK(start, p - start);
 				lastset = thisset;
+			}
 			if (lastset)
 				CALLBACK(start, p - start);
 		} else
 #endif
 			CALLBACK(mem_clusters[i].start, mem_clusters[i].size);
+	}
 	return 0;
 #undef CALLBACK
+}
 /*
  * Prepare for an impending core dump: decide what's being dumped and
  * how much space it will take up.
  */
 void
 dump_seg_prep(void)
+{
 #ifndef NO_SPARSE_DUMP
 	if (sparse_dump && sparse_dump_physmap)
 		cpu_dump_prep_sparse();
 #endif
 	dump_nmemsegs = 0;
 	dump_npages = 0;
 	dump_seg_iter(dump_seg_count_range);
 	dump_header_size = ALIGN(sizeof(kcore_seg_t)) +
 	    ALIGN(sizeof(cpu_kcore_hdr_t)) +
 	    ALIGN(dump_nmemsegs * sizeof(phys_ram_seg_t));
 	dump_header_size = roundup(dump_header_size, dbtob(1));
 	/*
 	 * savecore(8) will read this to decide how many pages to
 	 * copy, and cpu_dumpconf has already used the pessimistic
 	 * value to set dumplo, so it's time to tell the truth.
 	 */
 	dumpsize = dump_npages; /* XXX could these just be one variable? */
+}
 int
 dump_seg_count_range(paddr_t start, paddr_t size)
+{
 	++dump_nmemsegs;
 	dump_npages += size / PAGE_SIZE;
 	return 0;
+}
 /*
  * A sparse dump's header may be rather large, due to the number of
  * "segments" emitted.  These routines manage a simple output buffer,
  * so that the header can be written to disk incrementally.
  */
 void
 dump_header_start(void)
+{
 	dump_headerbuf_ptr = dump_headerbuf;
 	dump_header_blkno = dumplo;
+}
 int
 dump_header_flush(void)
+{
 	const struct bdevsw *bdev;
 	size_t to_write;
 	int error;
 	bdev = bdevsw_lookup(dumpdev);
 	to_write = roundup(dump_headerbuf_ptr - dump_headerbuf, dbtob(1));
 	error = bdev->d_dump(dumpdev, dump_header_blkno,
 	    dump_headerbuf, to_write);
 	dump_header_blkno += btodb(to_write);
 	dump_headerbuf_ptr = dump_headerbuf;
 	return error;
+}
 int
 dump_header_addbytes(const void* vptr, size_t n)
+{
 	const char* ptr = vptr;
 	int error;
 	while (n > dump_headerbuf_avail) {
 		memcpy(dump_headerbuf_ptr, ptr, dump_headerbuf_avail);
 		ptr += dump_headerbuf_avail;
 		n -= dump_headerbuf_avail;
 		dump_headerbuf_ptr = dump_headerbuf_end;
 		error = dump_header_flush();
 		if (error)
 			return error;
+	}
 	memcpy(dump_headerbuf_ptr, ptr, n);
 	dump_headerbuf_ptr += n;
 	return 0;
+}
 int
 dump_header_addseg(paddr_t start, paddr_t size)
+{
 	phys_ram_seg_t seg = { start, size };
 	return dump_header_addbytes(&seg, sizeof(seg));
+}
 int
 dump_header_finish(void)
+{
 	memset(dump_headerbuf_ptr, 0, dump_headerbuf_avail);
 	return dump_header_flush();
+}
 /*
  * These variables are needed by /sbin/savecore
  */
 uint32_t	dumpmag = 0x8fca0101;	/* magic number */
 int 	dumpsize = 0;		/* pages */
 long	dumplo = 0; 		/* blocks */
 /*
  * cpu_dumpsize: calculate size of machine-dependent kernel core dump headers
  * for a full (non-sparse) dump.
  */
 int
 cpu_dumpsize(void)
+{
 	int size;
 	size = ALIGN(sizeof(kcore_seg_t)) + ALIGN(sizeof(cpu_kcore_hdr_t)) +
 	    ALIGN(mem_cluster_cnt * sizeof(phys_ram_seg_t));
 	if (roundup(size, dbtob(1)) != dbtob(1))
 		return (-1);
 	return (1);
+}
 /*
  * cpu_dump_mempagecnt: calculate the size of RAM (in pages) to be dumped
  * for a full (non-sparse) dump.
  */
 u_long
 cpu_dump_mempagecnt(void)
+{
 	u_long i, n;
 	n = 0;
 	for (i = 0; i < mem_cluster_cnt; i++)
 		n += atop(mem_clusters[i].size);
 	return (n);
+}
 /*
  * cpu_dump: dump the machine-dependent kernel core dump headers.
  */
 int
 cpu_dump(void)
+{
 	kcore_seg_t seg;
 	cpu_kcore_hdr_t cpuhdr;
 	const struct bdevsw *bdev;
 	bdev = bdevsw_lookup(dumpdev);
 	if (bdev == NULL)
 		return (ENXIO);
 	/*
 	 * Generate a segment header.
 	 */
 	CORE_SETMAGIC(seg, KCORE_MAGIC, MID_MACHINE, CORE_CPU);
 	seg.c_size = dump_header_size - ALIGN(sizeof(seg));
 	(void)dump_header_addbytes(&seg, ALIGN(sizeof(seg)));
 	/*
 	 * Add the machine-dependent header info.
 	 */
 	cpuhdr.ptdpaddr = PDPpaddr;
 	cpuhdr.nmemsegs = dump_nmemsegs;
 	(void)dump_header_addbytes(&cpuhdr, ALIGN(sizeof(cpuhdr)));
 	/*
 	 * Write out the memory segment descriptors.
 	 */
 	return dump_seg_iter(dump_header_addseg);
+}
 /*
  * Doadump comes here after turning off memory management and
  * getting on the dump stack, either when called above, or by
  * the auto-restart code.
  */
 #define BYTES_PER_DUMP  PAGE_SIZE /* must be a multiple of pagesize XXX small */
 static vaddr_t dumpspace;
 vaddr_t
 reserve_dumppages(vaddr_t p)
+{
 	dumpspace = p;
 	return (p + BYTES_PER_DUMP);
+}
 int
 dumpsys_seg(paddr_t maddr, paddr_t bytes)
+{
 	u_long i, m, n;
 	daddr_t blkno;
 	const struct bdevsw *bdev;
 	int (*dump)(dev_t, daddr_t, void *, size_t);
 	int error;
 	if (dumpdev == NODEV)
 		return ENODEV;
 	bdev = bdevsw_lookup(dumpdev);
 	if (bdev == NULL || bdev->d_psize == NULL)
 		return ENODEV;
 	dump = bdev->d_dump;
 	blkno = dump_header_blkno;
 	for (i = 0; i < bytes; i += n, dump_totalbytesleft -= n) {
 		/* Print out how many MBs we have left to go. */
 		if ((dump_totalbytesleft % (1024*1024)) == 0)
 			printf_nolog("%lu ", (unsigned long)
 			    (dump_totalbytesleft / (1024 * 1024)));
 		/* Limit size for next transfer. */
 		n = bytes - i;
 		if (n > BYTES_PER_DUMP)
 			n = BYTES_PER_DUMP;
 		for (m = 0; m < n; m += NBPG)
 			pmap_kenter_pa(dumpspace + m, maddr + m,
 			    VM_PROT_READ, 0);
 		pmap_update(pmap_kernel());
 		error = (*dump)(dumpdev, blkno, (void *)dumpspace, n);
 		pmap_kremove_local(dumpspace, n);
 		if (error)
 			return error;
 		maddr += n;
 		blkno += btodb(n);		/* XXX? */
 #if 0	/* XXX this doesn't work.  grr. */
 		/* operator aborting dump? */
 		if (sget() != NULL)
 			return EINTR;
 #endif
+	}
 	dump_header_blkno = blkno;
 	return 0;
+}
 void
 dodumpsys(void)
+{
 	const struct bdevsw *bdev;
 	int dumpend, psize;
 	int error;
 	if (dumpdev == NODEV)
 		return;
 	bdev = bdevsw_lookup(dumpdev);
 	if (bdev == NULL || bdev->d_psize == NULL)
 		return;
 	/*
 	 * For dumps during autoconfiguration,
 	 * if dump device has already configured...
 	 */
 	if (dumpsize == 0)
 		cpu_dumpconf();
 	printf("\ndumping to dev %llu,%llu (offset=%ld, size=%d):",
 	    (unsigned long long)major(dumpdev),
 	    (unsigned long long)minor(dumpdev), dumplo, dumpsize);
 	if (dumplo <= 0 || dumpsize <= 0) {
 		printf(" not possible\n");
 		return;
+	}
 	psize = bdev_size(dumpdev);
 	printf("\ndump ");
 	if (psize == -1) {
 		printf("area unavailable\n");
 		return;
+	}
 #if 0	/* XXX this doesn't work.  grr. */
 	/* toss any characters present prior to dump */
 	while (sget() != NULL); /*syscons and pccons differ */
 #endif
 	dump_seg_prep();
 	dumpend = dumplo + btodb(dump_header_size) + ctod(dump_npages);
 	if (dumpend > psize) {
 		printf("failed: insufficient space (%d < %d)\n",
 		    psize, dumpend);
 		goto failed;
+	}
 	dump_header_start();
 	if ((error = cpu_dump()) != 0)
 		goto err;
 	if ((error = dump_header_finish()) != 0)
 		goto err;
 	if (dump_header_blkno != dumplo + btodb(dump_header_size)) {
 		printf("BAD header size (%ld [written] != %ld [expected])\n",
 		    (long)(dump_header_blkno - dumplo),
 		    (long)btodb(dump_header_size));
 		goto failed;
+	}
 	dump_totalbytesleft = roundup(ptoa(dump_npages), BYTES_PER_DUMP);
 	error = dump_seg_iter(dumpsys_seg);
 	if (error == 0 && dump_header_blkno != dumpend) {
 		printf("BAD dump size (%ld [written] != %ld [expected])\n",
 		    (long)(dumpend - dumplo),
 		    (long)(dump_header_blkno - dumplo));
 		goto failed;
+	}
 err:
 	switch (error) {
 	case ENXIO:
 		printf("device bad\n");
 		break;
 	case EFAULT:
 		printf("device not ready\n");
 		break;
 	case EINVAL:
 		printf("area improper\n");
 		break;
 	case EIO:
 		printf("i/o error\n");
 		break;
 	case EINTR:
 		printf("aborted from console\n");
 		break;
 	case 0:
 		printf("succeeded\n");
 		break;
 	default:
 		printf("error %d\n", error);
 		break;
+	}
 failed:
 	printf("\n\n");
 	delay(5000000);		/* 5 seconds */
+}
 /*
  * This is called by main to set dumplo and dumpsize.
  * Dumps always skip the first PAGE_SIZE of disk space
  * in case there might be a disk label stored there.
  * If there is extra space, put dump at the end to
  * reduce the chance that swapping trashes it.
+ *
  * Sparse dumps can't placed as close to the end as possible, because
  * savecore(8) has to know where to start reading in the dump device
  * before it has access to any of the crashed system's state.
+ *
  * Note also that a sparse dump will never be larger than a full one:
  * in order to add a phys_ram_seg_t to the header, at least one page
  * must be removed.
  */
 void
 cpu_dumpconf(void)
+{
 	int nblks, dumpblks;	/* size of dump area */
 	if (dumpdev == NODEV)
 		goto bad;
 	nblks = bdev_size(dumpdev);
 	if (nblks <= ctod(1))
 		goto bad;
 	dumpblks = cpu_dumpsize();
 	if (dumpblks < 0)
 		goto bad;
 	/* dumpsize is in page units, and doesn't include headers. */
 	dumpsize = cpu_dump_mempagecnt();
 	dumpblks += ctod(dumpsize);
 	/* If dump won't fit (incl. room for possible label), punt. */
 	if (dumpblks > (nblks - ctod(1))) {
 #ifndef NO_SPARSE_DUMP
 		/* A sparse dump might (and hopefully will) fit. */
 		dumplo = ctod(1);
 #else
 		/* But if we're not configured for that, punt. */
 		goto bad;
 #endif
 	} else {
 		/* Put dump at end of partition */
 		dumplo = nblks - dumpblks;
+	}
 	/* Now that we've decided this will work, init ancillary stuff. */
 	dump_misc_init();
 	return;
  bad:
 	dumpsize = 0;
+}
 /*
  * Clear registers on exec
  */
 void
 setregs(struct lwp *l, struct exec_package *pack, vaddr_t stack)
+{
 	struct pcb *pcb = lwp_getpcb(l);
 	struct trapframe *tf;
 #ifdef USER_LDT
 	pmap_ldt_cleanup(l);
 #endif
 	fpu_save_area_clear(l, pack->ep_osversion >= 699002600
 	    ? __NetBSD_NPXCW__ : __NetBSD_COMPAT_NPXCW__);
 	pcb->pcb_flags = 0;
 	l->l_proc->p_flag &= ~PK_32;
 	tf = l->l_md.md_regs;
 	tf->tf_ds = LSEL(LUDATA_SEL, SEL_UPL);
 	tf->tf_es = LSEL(LUDATA_SEL, SEL_UPL);
 	cpu_fsgs_zero(l);
 	tf->tf_rdi = 0;
 	tf->tf_rsi = 0;
 	tf->tf_rbp = 0;
 	tf->tf_rbx = l->l_proc->p_psstrp;
 	tf->tf_rdx = 0;
 	tf->tf_rcx = 0;
 	tf->tf_rax = 0;
 	tf->tf_rip = pack->ep_entry;
 	tf->tf_cs = LSEL(LUCODE_SEL, SEL_UPL);
 	tf->tf_rflags = PSL_USERSET;
 	tf->tf_rsp = stack;
 	tf->tf_ss = LSEL(LUDATA_SEL, SEL_UPL);
+}
 /*
  * Initialize segments and descriptor tables
  */
 #ifdef XEN
 struct trap_info *xen_idt;
 int xen_idt_idx;
 #endif
 char *ldtstore;
 char *gdtstore;
 void
 setgate(struct gate_descriptor *gd, void *func, int ist, int type, int dpl, int sel)
+{
 	kpreempt_disable();
 	pmap_changeprot_local(idt_vaddr, VM_PROT_READ|VM_PROT_WRITE);
 	gd->gd_looffset = (uint64_t)func & 0xffff;
 	gd->gd_selector = sel;
 	gd->gd_ist = ist;
 	gd->gd_type = type;
 	gd->gd_dpl = dpl;
 	gd->gd_p = 1;
 	gd->gd_hioffset = (uint64_t)func >> 16;
 	gd->gd_zero = 0;
 	gd->gd_xx1 = 0;
 	gd->gd_xx2 = 0;
 	gd->gd_xx3 = 0;
 	pmap_changeprot_local(idt_vaddr, VM_PROT_READ);
 	kpreempt_enable();
+}
 void
 unsetgate(struct gate_descriptor *gd)
+{
 	kpreempt_disable();
 	pmap_changeprot_local(idt_vaddr, VM_PROT_READ|VM_PROT_WRITE);
 	memset(gd, 0, sizeof (*gd));
 	pmap_changeprot_local(idt_vaddr, VM_PROT_READ);
 	kpreempt_enable();
+}
 void
 setregion(struct region_descriptor *rd, void *base, uint16_t limit)
+{
 	rd->rd_limit = limit;
 	rd->rd_base = (uint64_t)base;
+}
 /*
  * Note that the base and limit fields are ignored in long mode.
  */
 void
 set_mem_segment(struct mem_segment_descriptor *sd, void *base, size_t limit,
 	int type, int dpl, int gran, int def32, int is64)
+{
 	sd->sd_lolimit = (unsigned)limit;
 	sd->sd_lobase = (unsigned long)base;
 	sd->sd_type = type;
 	sd->sd_dpl = dpl;
 	sd->sd_p = 1;
 	sd->sd_hilimit = (unsigned)limit >> 16;
 	sd->sd_avl = 0;
 	sd->sd_long = is64;
 	sd->sd_def32 = def32;
 	sd->sd_gran = gran;
 	sd->sd_hibase = (unsigned long)base >> 24;
+}
 void
 set_sys_segment(struct sys_segment_descriptor *sd, void *base, size_t limit,
 	int type, int dpl, int gran)
+{
 	memset(sd, 0, sizeof *sd);
 	sd->sd_lolimit = (unsigned)limit;
 	sd->sd_lobase = (uint64_t)base;
 	sd->sd_type = type;
 	sd->sd_dpl = dpl;
 	sd->sd_p = 1;
 	sd->sd_hilimit = (unsigned)limit >> 16;
 	sd->sd_gran = gran;
 	sd->sd_hibase = (uint64_t)base >> 24;
+}
 void
 cpu_init_idt(void)
+{
 #ifndef XEN
 	struct region_descriptor region;
 	setregion(&region, idt, NIDT * sizeof(idt[0]) - 1);
 	lidt(&region);
 #else
 	if (HYPERVISOR_set_trap_table(xen_idt))
 		panic("HYPERVISOR_set_trap_table() failed");
 #endif
+}
 #define	IDTVEC(name)	__CONCAT(X, name)
 typedef void (vector)(void);
 extern vector IDTVEC(syscall);
 extern vector IDTVEC(syscall32);
 extern vector IDTVEC(osyscall);
 extern vector IDTVEC(oosyscall);
 extern vector *IDTVEC(exceptions)[];
 static void
 init_x86_64_msgbuf(void)
+{
 	/* Message buffer is located at end of core. */
 	struct vm_physseg *vps;
 	psize_t sz = round_page(MSGBUFSIZE);
 	psize_t reqsz = sz;
 	int x;
  search_again:
 	vps = NULL;
 	for (x = 0; x < vm_nphysseg; x++) {
 		vps = VM_PHYSMEM_PTR(x);
 		if (ctob(vps->avail_end) == avail_end)
 			break;
+	}
 	if (x == vm_nphysseg)
 		panic("init_x86_64: can't find end of memory");
 	/* Shrink so it'll fit in the last segment. */
 	if ((vps->avail_end - vps->avail_start) < atop(sz))
 		sz = ctob(vps->avail_end - vps->avail_start);
 	vps->avail_end -= atop(sz);
 	vps->end -= atop(sz);
             msgbuf_p_seg[msgbuf_p_cnt].sz = sz;
             msgbuf_p_seg[msgbuf_p_cnt++].paddr = ctob(vps->avail_end);
 	/* Remove the last segment if it now has no pages. */
 	if (vps->start == vps->end) {
 		for (vm_nphysseg--; x < vm_nphysseg; x++)
 			VM_PHYSMEM_PTR_SWAP(x, x + 1);
+	}
 	/* Now find where the new avail_end is. */
 	for (avail_end = 0, x = 0; x < vm_nphysseg; x++)
 		if (VM_PHYSMEM_PTR(x)->avail_end > avail_end)
 			avail_end = VM_PHYSMEM_PTR(x)->avail_end;
 	avail_end = ctob(avail_end);
 	if (sz == reqsz)
 		return;
 	reqsz -= sz;
 	if (msgbuf_p_cnt == VM_PHYSSEG_MAX) {
 		/* No more segments available, bail out. */
 		printf("WARNING: MSGBUFSIZE (%zu) too large, using %zu.\n",
 		    (size_t)MSGBUFSIZE, (size_t)(MSGBUFSIZE - reqsz));
 		return;
+	}
 	sz = reqsz;
 	goto search_again;
+}
 static void
 init_x86_64_ksyms(void)
+{
 #if NKSYMS || defined(DDB) || defined(MODULAR)
 	extern int end;
 	extern int *esym;
 #ifndef XEN
 	struct btinfo_symtab *symtab;
 	vaddr_t tssym, tesym;
 #endif
 #ifdef DDB
 	db_machine_init();
 #endif
 #ifndef XEN
 	symtab = lookup_bootinfo(BTINFO_SYMTAB);
 	if (symtab) {
 		tssym = (vaddr_t)symtab->ssym + KERNBASE;
 		tesym = (vaddr_t)symtab->esym + KERNBASE;
 		ksyms_addsyms_elf(symtab->nsym, (void *)tssym, (void *)tesym);
 	} else
 		ksyms_addsyms_elf(*(long *)(void *)&end,
 		    ((long *)(void *)&end) + 1, esym);
 #else  /* XEN */
 	esym = xen_start_info.mod_start ?
 	    (void *)xen_start_info.mod_start :
 	    (void *)xen_start_info.mfn_list;
 	ksyms_addsyms_elf(*(int *)(void *)&end,
 	    ((int *)(void *)&end) + 1, esym);
 #endif /* XEN */
 #endif
+}
 void
 init_x86_64(paddr_t first_avail)
+{
 	extern void consinit(void);
 	struct region_descriptor region;
 	struct mem_segment_descriptor *ldt_segp;
 	int x;
 #ifndef XEN
 	int ist;
 	extern struct extent *iomem_ex;
 #if !defined(REALEXTMEM) && !defined(REALBASEMEM)
 	struct btinfo_memmap *bim;
 #endif
 #endif /* !XEN */
 	cpu_probe(&cpu_info_primary);
 #ifdef XEN
 	KASSERT(HYPERVISOR_shared_info != NULL);
 	cpu_info_primary.ci_vcpu = &HYPERVISOR_shared_info->vcpu_info[0];
 	__PRINTK(("init_x86_64(0x%lx)\n", first_avail));
 #endif /* XEN */
 	cpu_init_msrs(&cpu_info_primary, true);
 	use_pae = 1; /* PAE always enabled in long mode */
 #ifdef XEN
 	struct pcb *pcb = lwp_getpcb(&lwp0);
 	mutex_init(&pte_lock, MUTEX_DEFAULT, IPL_VM);
 	pcb->pcb_cr3 = xen_start_info.pt_base - KERNBASE;
 	__PRINTK(("pcb_cr3 0x%lx\n", xen_start_info.pt_base - KERNBASE));
 #endif
 #if NISA > 0 || NPCI > 0
 	x86_bus_space_init();
 #endif
 	consinit();	/* XXX SHOULD NOT BE DONE HERE */
 	/*
 	 * Initialize PAGE_SIZE-dependent variables.
 	 */
 	uvm_setpagesize();
 	uvmexp.ncolors = 2;
 #ifndef XEN
 	/*
 	 * Low memory reservations:
 	 * Page 0:	BIOS data
 	 * Page 1:	BIOS callback (not used yet, for symmetry with i386)
-	 * Page 2:	MP bootstrap
+	 * Page 2:	MP bootstrap code (MP_TRAMPOLINE)
 	 * Page 3:	ACPI wakeup code (ACPI_WAKEUP_ADDR)
 	 * Page 4:	Temporary page table for 0MB-4MB
 	 * Page 5:	Temporary page directory
 	 * Page 6:	Temporary page map level 3
 	 * Page 7:	Temporary page map level 4
 	 */
 	avail_start = 8 * PAGE_SIZE;
 #if !defined(REALBASEMEM) && !defined(REALEXTMEM)
 	/*
 	 * Check to see if we have a memory map from the BIOS (passed
 	 * to us by the boot program.
 	 */
 	bim = lookup_bootinfo(BTINFO_MEMMAP);
 	if (bim != NULL && bim->num > 0)
 		initx86_parse_memmap(bim, iomem_ex);
 #endif	/* ! REALBASEMEM && ! REALEXTMEM */
 	/*
 	 * If the loop above didn't find any valid segment, fall back to
 	 * former code.
 	 */
 	if (mem_cluster_cnt == 0)
 		initx86_fake_memmap(iomem_ex);
 #else	/* XEN */
 	/* Parse Xen command line (replace bootinfo */
 	xen_parse_cmdline(XEN_PARSE_BOOTFLAGS, NULL);
 	/* Determine physical address space */
 	avail_start = first_avail;
 	avail_end = ctob(xen_start_info.nr_pages);
 	pmap_pa_start = (KERNTEXTOFF - KERNBASE);
 	pmap_pa_end = avail_end;
 	__PRINTK(("pmap_pa_start 0x%lx avail_start 0x%lx avail_end 0x%lx\n",
 	    pmap_pa_start, avail_start, avail_end));
 #endif	/* !XEN */
 	/*
 	 * Call pmap initialization to make new kernel address space.
 	 * We must do this before loading pages into the VM system.
 	 */
 	pmap_bootstrap(VM_MIN_KERNEL_ADDRESS);
 	if (avail_start != PAGE_SIZE)
 		pmap_prealloc_lowmem_ptps();
 #ifndef XEN
 	initx86_load_memmap(first_avail);
 #else	/* XEN */
 	kern_end = KERNBASE + first_avail;
 	physmem = xen_start_info.nr_pages;
 	uvm_page_physload(atop(avail_start),
 		atop(avail_end), atop(avail_start),
 		atop(avail_end), VM_FREELIST_DEFAULT);
 #endif	/* !XEN */
 	init_x86_64_msgbuf();
 	pmap_growkernel(VM_MIN_KERNEL_ADDRESS + 32 * 1024 * 1024);
 	kpreempt_disable();
 	pmap_kenter_pa(idt_vaddr, idt_paddr, VM_PROT_READ|VM_PROT_WRITE, 0);
 	pmap_update(pmap_kernel());
 	memset((void *)idt_vaddr, 0, PAGE_SIZE);
 #ifndef XEN
 	pmap_changeprot_local(idt_vaddr, VM_PROT_READ);
 #endif
 	pmap_kenter_pa(idt_vaddr + PAGE_SIZE, idt_paddr + PAGE_SIZE,
 	    VM_PROT_READ|VM_PROT_WRITE, 0);
 #ifdef XEN
 	/* Steal one more page for LDT */
 	pmap_kenter_pa(idt_vaddr + 2 * PAGE_SIZE, idt_paddr + 2 * PAGE_SIZE,
 	    VM_PROT_READ|VM_PROT_WRITE, 0);
 #endif
 	pmap_kenter_pa(lo32_vaddr, lo32_paddr, VM_PROT_READ|VM_PROT_WRITE, 0);
 	pmap_update(pmap_kernel());
 #ifndef XEN
 	idt_init();
 	idt = (struct gate_descriptor *)idt_vaddr;
 	gdtstore = (char *)(idt + NIDT);
 	ldtstore = gdtstore + DYNSEL_START;
 #else
 	xen_idt = (struct trap_info *)idt_vaddr;
 	xen_idt_idx = 0;
 	/* Xen wants page aligned GDT/LDT in separated pages */
 	ldtstore = (char *) roundup((vaddr_t) (xen_idt + NIDT), PAGE_SIZE);
 	gdtstore = (char *) (ldtstore + PAGE_SIZE);
 #endif /* XEN */
 	/* make gdt gates and memory segments */
 	set_mem_segment(GDT_ADDR_MEM(gdtstore, GCODE_SEL), 0,
 xfffff, SDT_MEMERA, SEL_KPL, 1, 0, 1);
 	set_mem_segment(GDT_ADDR_MEM(gdtstore, GDATA_SEL), 0,
 xfffff, SDT_MEMRWA, SEL_KPL, 1, 0, 1);
 #ifndef XEN
 	set_sys_segment(GDT_ADDR_SYS(gdtstore, GLDT_SEL), ldtstore,
 	    LDT_SIZE - 1, SDT_SYSLDT, SEL_KPL, 0);
 #endif
 	set_mem_segment(GDT_ADDR_MEM(gdtstore, GUCODE_SEL), 0,
 	    x86_btop(VM_MAXUSER_ADDRESS) - 1, SDT_MEMERA, SEL_UPL, 1, 0, 1);
 	set_mem_segment(GDT_ADDR_MEM(gdtstore, GUDATA_SEL), 0,
 	    x86_btop(VM_MAXUSER_ADDRESS) - 1, SDT_MEMRWA, SEL_UPL, 1, 0, 1);
 	/* make ldt gates and memory segments */
 	setgate((struct gate_descriptor *)(ldtstore + LSYS5CALLS_SEL),
 	    &IDTVEC(oosyscall), 0, SDT_SYS386CGT, SEL_UPL,
 	    GSEL(GCODE_SEL, SEL_KPL));
 	*(struct mem_segment_descriptor *)(ldtstore + LUCODE_SEL) =
 	    *GDT_ADDR_MEM(gdtstore, GUCODE_SEL);
 	*(struct mem_segment_descriptor *)(ldtstore + LUDATA_SEL) =
 	    *GDT_ADDR_MEM(gdtstore, GUDATA_SEL);
 	/*
 	 * 32 bit GDT entries.
 	 */
 	set_mem_segment(GDT_ADDR_MEM(gdtstore, GUCODE32_SEL), 0,
 	    x86_btop(VM_MAXUSER_ADDRESS32) - 1, SDT_MEMERA, SEL_UPL, 1, 1, 0);
 	set_mem_segment(GDT_ADDR_MEM(gdtstore, GUDATA32_SEL), 0,
 	    x86_btop(VM_MAXUSER_ADDRESS32) - 1, SDT_MEMRWA, SEL_UPL, 1, 1, 0);
 	set_mem_segment(GDT_ADDR_MEM(gdtstore, GUFS_SEL), 0,
 	    x86_btop(VM_MAXUSER_ADDRESS32) - 1, SDT_MEMRWA, SEL_UPL, 1, 1, 0);
 	set_mem_segment(GDT_ADDR_MEM(gdtstore, GUGS_SEL), 0,
 	    x86_btop(VM_MAXUSER_ADDRESS32) - 1, SDT_MEMRWA, SEL_UPL, 1, 1, 0);
 	/*
 	 * 32 bit LDT entries.
 	 */
 	ldt_segp = (struct mem_segment_descriptor *)(ldtstore + LUCODE32_SEL);
 	set_mem_segment(ldt_segp, 0, x86_btop(VM_MAXUSER_ADDRESS32) - 1,
 	    SDT_MEMERA, SEL_UPL, 1, 1, 0);
 	ldt_segp = (struct mem_segment_descriptor *)(ldtstore + LUDATA32_SEL);
 	set_mem_segment(ldt_segp, 0, x86_btop(VM_MAXUSER_ADDRESS32) - 1,
 	    SDT_MEMRWA, SEL_UPL, 1, 1, 0);
 	/*
 	 * Other entries.
 	 */
 	memcpy((struct gate_descriptor *)(ldtstore + LSOL26CALLS_SEL),
 	    (struct gate_descriptor *)(ldtstore + LSYS5CALLS_SEL),
 	    sizeof (struct gate_descriptor));
 	memcpy((struct gate_descriptor *)(ldtstore + LBSDICALLS_SEL),
 	    (struct gate_descriptor *)(ldtstore + LSYS5CALLS_SEL),
 	    sizeof (struct gate_descriptor));
 	/* exceptions */
 	for (x = 0; x < 32; x++) {
 #ifndef XEN
 		idt_vec_reserve(x);
 		switch (x) {
 		case 2:	/* NMI */
 			ist = 3;
 			break;
 		case 8:	/* double fault */
 			ist = 2;
 			break;
 		default:
 			ist = 0;
 			break;
+		}
 		setgate(&idt[x], IDTVEC(exceptions)[x], ist, SDT_SYS386IGT,
 		    (x == 3 || x == 4) ? SEL_UPL : SEL_KPL,
 		    GSEL(GCODE_SEL, SEL_KPL));
 #else /* XEN */
 		pmap_changeprot_local(idt_vaddr, VM_PROT_READ|VM_PROT_WRITE);
 		xen_idt[xen_idt_idx].vector = x;
 		switch (x) {
 		case 2:  /* NMI */
 		case 18: /* MCA */
 			TI_SET_IF(&(xen_idt[xen_idt_idx]), 2);
 			break;
 		case 3:
 		case 4:
 			xen_idt[xen_idt_idx].flags = SEL_UPL;
 			break;
 		default:
 			xen_idt[xen_idt_idx].flags = SEL_KPL;
 			break;
+		}
 		xen_idt[xen_idt_idx].cs = GSEL(GCODE_SEL, SEL_KPL);
 		xen_idt[xen_idt_idx].address =
 		    (unsigned long)IDTVEC(exceptions)[x];
 		xen_idt_idx++;
 #endif /* XEN */
+	}
 	/* new-style interrupt gate for syscalls */
 #ifndef XEN
 	idt_vec_reserve(128);
 	setgate(&idt[128], &IDTVEC(osyscall), 0, SDT_SYS386IGT, SEL_UPL,
 	    GSEL(GCODE_SEL, SEL_KPL));
 #else
 	xen_idt[xen_idt_idx].vector = 128;
 	xen_idt[xen_idt_idx].flags = SEL_KPL;
 	xen_idt[xen_idt_idx].cs = GSEL(GCODE_SEL, SEL_KPL);
 	xen_idt[xen_idt_idx].address =  (unsigned long) &IDTVEC(osyscall);
 	xen_idt_idx++;
 	pmap_changeprot_local(idt_vaddr, VM_PROT_READ);
 #endif /* XEN */
 	kpreempt_enable();
 	setregion(&region, gdtstore, DYNSEL_START - 1);
 	lgdt(&region);
 #ifdef XEN
 	/* Init Xen callbacks and syscall handlers */
 	if (HYPERVISOR_set_callbacks(
 	    (unsigned long) hypervisor_callback,
 	    (unsigned long) failsafe_callback,
 	    (unsigned long) Xsyscall))
 		panic("HYPERVISOR_set_callbacks() failed");
 #endif /* XEN */
 	cpu_init_idt();
 	init_x86_64_ksyms();
 #ifndef XEN
 	intr_default_setup();
 #else
 	events_default_setup();
 #endif
 	splraise(IPL_HIGH);
 	x86_enable_intr();
 #ifdef DDB
 	if (boothowto & RB_KDB)
 		Debugger();
 #endif
 #ifdef KGDB
 	kgdb_port_init();
 	if (boothowto & RB_KDB) {
 		kgdb_debug_init = 1;
 		kgdb_connect(1);
+	}
 #endif
+}
 void
 cpu_reset(void)
+{
 	x86_disable_intr();
 #ifdef XEN
 	HYPERVISOR_reboot();
 #else
 	x86_reset();
 	/*
 	 * Try to cause a triple fault and watchdog reset by making the IDT
 	 * invalid and causing a fault.
 	 */
 	kpreempt_disable();
 	pmap_changeprot_local(idt_vaddr, VM_PROT_READ|VM_PROT_WRITE);
 	pmap_changeprot_local(idt_vaddr + PAGE_SIZE,
 	    VM_PROT_READ|VM_PROT_WRITE);
 	memset((void *)idt, 0, NIDT * sizeof(idt[0]));
 	kpreempt_enable();
 	breakpoint();
 #if 0
 	/*
 	 * Try to cause a triple fault and watchdog reset by unmapping the
 	 * entire address space and doing a TLB flush.
 	 */
 	memset((void *)PTD, 0, PAGE_SIZE);
 	tlbflush();
 #endif
 #endif	/* XEN */
 	for (;;);
+}
 void
 cpu_getmcontext(struct lwp *l, mcontext_t *mcp, unsigned int *flags)
+{
 	const struct trapframe *tf = l->l_md.md_regs;
 	__greg_t ras_rip;
 	/* Copy general registers member by member */
 #define copy_from_tf(reg, REG, idx) mcp->__gregs[_REG_##REG] = tf->tf_##reg;
 	_FRAME_GREG(copy_from_tf)
 #undef copy_from_tf
 	if ((ras_rip = (__greg_t)ras_lookup(l->l_proc,
 	    (void *) mcp->__gregs[_REG_RIP])) != -1)
 		mcp->__gregs[_REG_RIP] = ras_rip;
 	*flags |= _UC_CPU;
 	mcp->_mc_tlsbase = (uintptr_t)l->l_private;
 	*flags |= _UC_TLSBASE;
 	process_read_fpregs_xmm(l, (struct fxsave *)&mcp->__fpregs);
 	*flags |= _UC_FPU;
+}
 int
 cpu_setmcontext(struct lwp *l, const mcontext_t *mcp, unsigned int flags)
+{
 	struct trapframe *tf = l->l_md.md_regs;
 	const __greg_t *gr = mcp->__gregs;
 	struct proc *p = l->l_proc;
 	int error;
 	int err, trapno;
 	int64_t rflags;
 	CTASSERT(sizeof (mcontext_t) == 26 * 8 + 8 + 512);
 	if ((flags & _UC_CPU) != 0) {
 		error = cpu_mcontext_validate(l, mcp);
 		if (error != 0)
 			return error;
 		/*
 		 * save and restore some values we don't want to change.
 		 * _FRAME_GREG(copy_to_tf) below overwrites them.
+		 *
 		 * XXX maybe inline this.
 		 */
 		rflags = tf->tf_rflags;
 		err = tf->tf_err;
 		trapno = tf->tf_trapno;
 		/* Copy general registers member by member */
 #define copy_to_tf(reg, REG, idx) tf->tf_##reg = gr[_REG_##REG];
 		_FRAME_GREG(copy_to_tf)
 #undef copy_to_tf
 #ifdef XEN
 		/*
 		 * Xen has its own way of dealing with %cs and %ss,
 		 * reset it to proper values.
 		 */
 		tf->tf_ss = GSEL(GUDATA_SEL, SEL_UPL);
 		tf->tf_cs = GSEL(GUCODE_SEL, SEL_UPL);
 #endif
 		rflags &= ~PSL_USER;
 		tf->tf_rflags = rflags | (gr[_REG_RFLAGS] & PSL_USER);
 		tf->tf_err = err;
 		tf->tf_trapno = trapno;
 		l->l_md.md_flags |= MDL_IRET;
+	}
 	if ((flags & _UC_FPU) != 0)
 		process_write_fpregs_xmm(l, (const struct fxsave *)&mcp->__fpregs);
 	if ((flags & _UC_TLSBASE) != 0)
 		lwp_setprivate(l, (void *)(uintptr_t)mcp->_mc_tlsbase);
 	mutex_enter(p->p_lock);
 	if (flags & _UC_SETSTACK)
 		l->l_sigstk.ss_flags |= SS_ONSTACK;
 	if (flags & _UC_CLRSTACK)
 		l->l_sigstk.ss_flags &= ~SS_ONSTACK;
 	mutex_exit(p->p_lock);
 	return 0;
+}
 int
 cpu_mcontext_validate(struct lwp *l, const mcontext_t *mcp)
+{
 	const __greg_t *gr;
 	uint16_t sel;
 	int error;
 	struct pmap *pmap = l->l_proc->p_vmspace->vm_map.pmap;
 	struct proc *p = l->l_proc;
 	struct trapframe *tf = l->l_md.md_regs;
 	gr = mcp->__gregs;
 	if (((gr[_REG_RFLAGS] ^ tf->tf_rflags) & PSL_USERSTATIC) != 0)
 		return EINVAL;
 	if (__predict_false(pmap->pm_ldt != NULL)) {
 		error = valid_user_selector(l, gr[_REG_ES]);
 		if (error != 0)
 			return error;
 		error = valid_user_selector(l, gr[_REG_FS]);
 		if (error != 0)
 			return error;
 		error = valid_user_selector(l, gr[_REG_GS]);
 		if (error != 0)
 			return error;
 		if ((gr[_REG_DS] & 0xffff) == 0)
 			return EINVAL;
 		error = valid_user_selector(l, gr[_REG_DS]);
 		if (error != 0)
 			return error;
 #ifndef XEN
 		if ((gr[_REG_SS] & 0xffff) == 0)
 			return EINVAL;
 		error = valid_user_selector(l, gr[_REG_SS]);
 		if (error != 0)
 			return error;
 #endif
 	} else {
 #define VUD(sel) \
     ((p->p_flag & PK_32) ? VALID_USER_DSEL32(sel) : VALID_USER_DSEL(sel))
 		sel = gr[_REG_ES] & 0xffff;
 		if (sel != 0 && !VUD(sel))
 			return EINVAL;
 /* XXX: Shouldn't this be FSEL32? */
 #define VUF(sel) \
     ((p->p_flag & PK_32) ? VALID_USER_DSEL32(sel) : VALID_USER_DSEL(sel))
 		sel = gr[_REG_FS] & 0xffff;
 		if (sel != 0 && !VUF(sel))
 			return EINVAL;
 #define VUG(sel) \
     ((p->p_flag & PK_32) ? VALID_USER_GSEL32(sel) : VALID_USER_DSEL(sel))
 		sel = gr[_REG_GS] & 0xffff;
 		if (sel != 0 && !VUG(sel))
 			return EINVAL;
 		sel = gr[_REG_DS] & 0xffff;
 		if (!VUD(sel))
 			return EINVAL;
 #ifndef XEN
 		sel = gr[_REG_SS] & 0xffff;
 		if (!VUD(sel))
 			return EINVAL;
 #endif
+	}
 #ifndef XEN
 #define VUC(sel) \
     ((p->p_flag & PK_32) ? VALID_USER_CSEL32(sel) : VALID_USER_CSEL(sel))
 	sel = gr[_REG_CS] & 0xffff;
 	if (!VUC(sel))
 		return EINVAL;
 #endif
 	if (gr[_REG_RIP] >= VM_MAXUSER_ADDRESS)
 		return EINVAL;
 	return 0;
+}
 void
 cpu_initclocks(void)
+{
 	(*initclock_func)();
+}
 static int
 valid_user_selector(struct lwp *l, uint64_t seg)
+{
 	int off, len;
 	char *dt;
 	struct mem_segment_descriptor *sdp;
 	struct proc *p = l->l_proc;
 	struct pmap *pmap= p->p_vmspace->vm_map.pmap;
 	uint64_t base;
 	seg &= 0xffff;
 	if (seg == 0)
 		return 0;
 	off = (seg & 0xfff8);
 	if (seg & SEL_LDT) {
 		if (pmap->pm_ldt != NULL) {
 			len = pmap->pm_ldt_len; /* XXX broken */
 			dt = (char *)pmap->pm_ldt;
 		} else {
 			dt = ldtstore;
 			len = LDT_SIZE;
+		}
 		if (off > (len - 8))
 			return EINVAL;
 	} else {
 		CTASSERT(GUDATA_SEL & SEL_LDT);
 		KASSERT(seg != GUDATA_SEL);
 		CTASSERT(GUDATA32_SEL & SEL_LDT);
 		KASSERT(seg != GUDATA32_SEL);
 		return EINVAL;
+	}
 	sdp = (struct mem_segment_descriptor *)(dt + off);
 	if (sdp->sd_type < SDT_MEMRO || sdp->sd_p == 0)
 		return EINVAL;
 	base = ((uint64_t)sdp->sd_hibase << 32) | ((uint64_t)sdp->sd_lobase);
 	if (sdp->sd_gran == 1)
 		base <<= PAGE_SHIFT;
 	if (base >= VM_MAXUSER_ADDRESS)
 		return EINVAL;
 	return 0;
+}
 int
 mm_md_kernacc(void *ptr, vm_prot_t prot, bool *handled)
+{
 	extern int start, __data_start;
 	const vaddr_t v = (vaddr_t)ptr;
 	if (v >= (vaddr_t)&start && v < (vaddr_t)kern_end) {
 		*handled = true;
 		/* Either the text or rodata segment */
 		if (v < (vaddr_t)&__data_start && (prot & VM_PROT_WRITE))
 			return EFAULT;
 	} else if (v >= module_start && v < module_end) {
 		*handled = true;
 		if (!uvm_map_checkprot(module_map, v, v + 1, prot))
 			return EFAULT;
 	} else {
 		*handled = false;
+	}
 	return 0;
+}
 /*
  * Zero out an LWP's TLS context (%fs and %gs and associated stuff).
  * Used when exec'ing a new program.
  */
 void
 cpu_fsgs_zero(struct lwp *l)
+{
 	struct trapframe * const tf = l->l_md.md_regs;
 	struct pcb *pcb;
 	uint64_t zero = 0;
 	pcb = lwp_getpcb(l);
 	if (l == curlwp) {
 		kpreempt_disable();
 		tf->tf_fs = 0;
 		tf->tf_gs = 0;
 		setfs(0);
 #ifndef XEN
 		setusergs(0);
 #else
 		HYPERVISOR_set_segment_base(SEGBASE_GS_USER_SEL, 0);
 #endif
 		if ((l->l_proc->p_flag & PK_32) == 0) {
 #ifndef XEN
 			wrmsr(MSR_FSBASE, 0);
 			wrmsr(MSR_KERNELGSBASE, 0);
 #else
 			HYPERVISOR_set_segment_base(SEGBASE_FS, 0);
 			HYPERVISOR_set_segment_base(SEGBASE_GS_USER, 0);
 #endif
+		}
 		pcb->pcb_fs = 0;
 		pcb->pcb_gs = 0;
 		update_descriptor(&curcpu()->ci_gdt[GUFS_SEL], &zero);
 		update_descriptor(&curcpu()->ci_gdt[GUGS_SEL], &zero);
 		kpreempt_enable();
 	} else {
 		tf->tf_fs = 0;
 		tf->tf_gs = 0;
 		pcb->pcb_fs = 0;
 		pcb->pcb_gs = 0;
+	}
+}
 /*
  * Load an LWP's TLS context, possibly changing the %fs and %gs selectors.
  * Used only for 32-bit processes.
  */
 void
 cpu_fsgs_reload(struct lwp *l, int fssel, int gssel)
+{
 	struct trapframe *tf;
 	struct pcb *pcb;
 	KASSERT(l->l_proc->p_flag & PK_32);
 	tf = l->l_md.md_regs;
 	if (l == curlwp) {
 		pcb = lwp_getpcb(l);
 		kpreempt_disable();
 		update_descriptor(&curcpu()->ci_gdt[GUFS_SEL], &pcb->pcb_fs);
 		update_descriptor(&curcpu()->ci_gdt[GUGS_SEL], &pcb->pcb_gs);
 		setfs(fssel);
 #ifndef XEN
 		setusergs(gssel);
 #else
 		HYPERVISOR_set_segment_base(SEGBASE_GS_USER_SEL, gssel);
 #endif
 		tf->tf_fs = fssel;
 		tf->tf_gs = gssel;
 		kpreempt_enable();
 	} else {
 		tf->tf_fs = fssel;
 		tf->tf_gs = gssel;
+	}
+}
 #ifdef __HAVE_DIRECT_MAP
 bool
 mm_md_direct_mapped_io(void *addr, paddr_t *paddr)
+{
 	vaddr_t va = (vaddr_t)addr;
 	if (va >= PMAP_DIRECT_BASE && va < PMAP_DIRECT_END) {
 		*paddr = PMAP_DIRECT_UNMAP(va);
 		return true;
+	}
 	return false;
+}
 bool
 mm_md_direct_mapped_phys(paddr_t paddr, vaddr_t *vaddr)
+{
 	*vaddr = PMAP_DIRECT_MAP(paddr);
 	return true;
+}
 #endif

 @@ -1,1766 +1,1766 @@
-/*	$NetBSD: machdep.c,v 1.754 2015/04/24 00:04:04 khorben Exp $	*/
+/*	$NetBSD: machdep.c,v 1.755 2016/05/15 10:35:54 maxv Exp $	*/
 /*-
  * Copyright (c) 1996, 1997, 1998, 2000, 2004, 2006, 2008, 2009
  *     The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Charles M. Hannum, by Jason R. Thorpe of the Numerical Aerospace
  * Simulation Facility NASA Ames Research Center, by Julio M. Merino Vidal,
  * and 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.
  * 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
  */
 /*-
  * Copyright (c) 1982, 1987, 1990 The Regents of the University of California.
  * All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * William Jolitz.
+ *
  * 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. 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.
+ *
  *	@(#)machdep.c	7.4 (Berkeley) 6/3/91
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: machdep.c,v 1.754 2015/04/24 00:04:04 khorben Exp $");
+__KERNEL_RCSID(0, "$NetBSD: machdep.c,v 1.755 2016/05/15 10:35:54 maxv Exp $");
 #include "opt_beep.h"
 #include "opt_compat_ibcs2.h"
 #include "opt_compat_freebsd.h"
 #include "opt_compat_netbsd.h"
 #include "opt_compat_svr4.h"
 #include "opt_cpureset_delay.h"
 #include "opt_ddb.h"
 #include "opt_ipkdb.h"
 #include "opt_kgdb.h"
 #include "opt_mtrr.h"
 #include "opt_modular.h"
 #include "opt_multiboot.h"
 #include "opt_multiprocessor.h"
 #include "opt_physmem.h"
 #include "opt_realmem.h"
 #include "opt_user_ldt.h"
 #include "opt_vm86.h"
 #include "opt_xen.h"
 #include "isa.h"
 #include "pci.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/signal.h>
 #include <sys/signalvar.h>
 #include <sys/kernel.h>
 #include <sys/cpu.h>
 #include <sys/exec.h>
 #include <sys/fcntl.h>
 #include <sys/reboot.h>
 #include <sys/conf.h>
 #include <sys/kauth.h>
 #include <sys/mbuf.h>
 #include <sys/msgbuf.h>
 #include <sys/mount.h>
 #include <sys/syscallargs.h>
 #include <sys/core.h>
 #include <sys/kcore.h>
 #include <sys/ucontext.h>
 #include <sys/ras.h>
 #include <sys/ksyms.h>
 #include <sys/device.h>
 #ifdef IPKDB
 #include <ipkdb/ipkdb.h>
 #endif
 #ifdef KGDB
 #include <sys/kgdb.h>
 #endif
 #include <dev/cons.h>
 #include <dev/mm.h>
 #include <uvm/uvm.h>
 #include <uvm/uvm_page.h>
 #include <sys/sysctl.h>
 #include <machine/cpu.h>
 #include <machine/cpufunc.h>
 #include <machine/cpuvar.h>
 #include <machine/gdt.h>
 #include <machine/intr.h>
 #include <machine/kcore.h>
 #include <machine/pio.h>
 #include <machine/psl.h>
 #include <machine/reg.h>
 #include <machine/specialreg.h>
 #include <machine/bootinfo.h>
 #include <machine/mtrr.h>
 #include <x86/x86/tsc.h>
 #include <x86/fpu.h>
 #include <x86/machdep.h>
 #include <machine/multiboot.h>
 #ifdef XEN
 #include <xen/evtchn.h>
 #include <xen/xen.h>
 #include <xen/hypervisor.h>
 /* #define	XENDEBUG */
 /* #define	XENDEBUG_LOW */
 #ifdef XENDEBUG
 #define	XENPRINTF(x) printf x
 #define	XENPRINTK(x) printk x
 #else
 #define	XENPRINTF(x)
 #define	XENPRINTK(x)
 #endif
 #define	PRINTK(x) printf x
 #endif /* XEN */
 #include <dev/isa/isareg.h>
 #include <machine/isa_machdep.h>
 #include <dev/ic/i8042reg.h>
 #ifdef DDB
 #include <machine/db_machdep.h>
 #include <ddb/db_extern.h>
 #endif
 #ifdef VM86
 #include <machine/vm86.h>
 #endif
 #include "acpica.h"
 #include "bioscall.h"
 #if NBIOSCALL > 0
 #include <machine/bioscall.h>
 #endif
 #if NACPICA > 0
 #include <dev/acpi/acpivar.h>
 #define ACPI_MACHDEP_PRIVATE
 #include <machine/acpi_machdep.h>
 #endif
 #include "isa.h"
 #include "isadma.h"
 #include "ksyms.h"
 #include "cardbus.h"
 #if NCARDBUS > 0
 /* For rbus_min_start hint. */
 #include <sys/bus.h>
 #include <dev/cardbus/rbus.h>
 #include <machine/rbus_machdep.h>
 #endif
 #include "mca.h"
 #if NMCA > 0
 #include <machine/mca_machdep.h>	/* for mca_busprobe() */
 #endif
 #ifdef MULTIPROCESSOR		/* XXX */
 #include <machine/mpbiosvar.h>	/* XXX */
 #endif				/* XXX */
 /* the following is used externally (sysctl_hw) */
 char machine[] = "i386";		/* CPU "architecture" */
 char machine_arch[] = "i386";		/* machine == machine_arch */
 extern struct bi_devmatch *x86_alldisks;
 extern int x86_ndisks;
 #ifdef CPURESET_DELAY
 int	cpureset_delay = CPURESET_DELAY;
 #else
 int     cpureset_delay = 2000; /* default to 2s */
 #endif
 #ifdef MTRR
 struct mtrr_funcs *mtrr_funcs;
 #endif
 int	cpu_class;
 int	use_pae;
 int	i386_fpu_present = 1;
 int	i386_fpu_fdivbug;
 int	i386_use_fxsave;
 int	i386_has_sse;
 int	i386_has_sse2;
 vaddr_t	msgbuf_vaddr;
 struct {
 	paddr_t paddr;
 	psize_t sz;
 } msgbuf_p_seg[VM_PHYSSEG_MAX];
 unsigned int msgbuf_p_cnt = 0;
 vaddr_t	idt_vaddr;
 paddr_t	idt_paddr;
 vaddr_t	pentium_idt_vaddr;
 struct vm_map *phys_map = NULL;
 extern	paddr_t avail_start, avail_end;
 #ifdef XEN
 extern paddr_t pmap_pa_start, pmap_pa_end;
 void hypervisor_callback(void);
 void failsafe_callback(void);
 #endif
 #ifdef XEN
 void (*delay_func)(unsigned int) = xen_delay;
 void (*initclock_func)(void) = xen_initclocks;
 #else
 void (*delay_func)(unsigned int) = i8254_delay;
 void (*initclock_func)(void) = i8254_initclocks;
 #endif
 /*
  * Size of memory segments, before any memory is stolen.
  */
 phys_ram_seg_t mem_clusters[VM_PHYSSEG_MAX];
 int	mem_cluster_cnt = 0;
 void	init386(paddr_t);
 void	initgdt(union descriptor *);
 extern int time_adjusted;
 int *esym;
 int *eblob;
 extern int boothowto;
 #ifndef XEN
 /* Base memory reported by BIOS. */
 #ifndef REALBASEMEM
 int	biosbasemem = 0;
 #else
 int	biosbasemem = REALBASEMEM;
 #endif
 /* Extended memory reported by BIOS. */
 #ifndef REALEXTMEM
 int	biosextmem = 0;
 #else
 int	biosextmem = REALEXTMEM;
 #endif
 /* Set if any boot-loader set biosbasemem/biosextmem. */
 int	biosmem_implicit;
 /* Representation of the bootinfo structure constructed by a NetBSD native
  * boot loader.  Only be used by native_loader(). */
 struct bootinfo_source {
 	uint32_t bs_naddrs;
 	void *bs_addrs[1]; /* Actually longer. */
 };
 /* Only called by locore.h; no need to be in a header file. */
 void	native_loader(int, int, struct bootinfo_source *, paddr_t, int, int);
 /*
  * Called as one of the very first things during system startup (just after
  * the boot loader gave control to the kernel image), this routine is in
  * charge of retrieving the parameters passed in by the boot loader and
  * storing them in the appropriate kernel variables.
+ *
  * WARNING: Because the kernel has not yet relocated itself to KERNBASE,
  * special care has to be taken when accessing memory because absolute
  * addresses (referring to kernel symbols) do not work.  So:
+ *
  *     1) Avoid jumps to absolute addresses (such as gotos and switches).
  *     2) To access global variables use their physical address, which
  *        can be obtained using the RELOC macro.
  */
 void
 native_loader(int bl_boothowto, int bl_bootdev,
     struct bootinfo_source *bl_bootinfo, paddr_t bl_esym,
     int bl_biosextmem, int bl_biosbasemem)
+{
 #define RELOC(type, x) ((type)((vaddr_t)(x) - KERNBASE))
 	*RELOC(int *, &boothowto) = bl_boothowto;
 #ifdef COMPAT_OLDBOOT
 	/*
 	 * Pre-1.3 boot loaders gave the boot device as a parameter
 	 * (instead of a bootinfo entry).
 	 */
 	*RELOC(int *, &bootdev) = bl_bootdev;
 #endif
 	/*
 	 * The boot loader provides a physical, non-relocated address
 	 * for the symbols table's end.  We need to convert it to a
 	 * virtual address.
 	 */
 	if (bl_esym != 0)
 		*RELOC(int **, &esym) = (int *)((vaddr_t)bl_esym + KERNBASE);
 	else
 		*RELOC(int **, &esym) = 0;
 	/*
 	 * Copy bootinfo entries (if any) from the boot loader's
 	 * representation to the kernel's bootinfo space.
 	 */
 	if (bl_bootinfo != NULL) {
 		size_t i;
 		uint8_t *data;
 		struct bootinfo *bidest;
 		struct btinfo_modulelist *bi;
 		bidest = RELOC(struct bootinfo *, &bootinfo);
 		data = &bidest->bi_data[0];
 		for (i = 0; i < bl_bootinfo->bs_naddrs; i++) {
 			struct btinfo_common *bc;
 			bc = bl_bootinfo->bs_addrs[i];
 			if ((data + bc->len) >
 			    (&bidest->bi_data[0] + BOOTINFO_MAXSIZE))
 				break;
 			memcpy(data, bc, bc->len);
 			/*
 			 * If any modules were loaded, record where they
 			 * end.  We'll need to skip over them.
 			 */
 			bi = (struct btinfo_modulelist *)data;
 			if (bi->common.type == BTINFO_MODULELIST) {
 				*RELOC(int **, &eblob) =
 				    (int *)(bi->endpa + KERNBASE);
+			}
 			data += bc->len;
+		}
 		bidest->bi_nentries = i;
+	}
 	/*
 	 * Configure biosbasemem and biosextmem only if they were not
 	 * explicitly given during the kernel's build.
 	 */
 	if (*RELOC(int *, &biosbasemem) == 0) {
 		*RELOC(int *, &biosbasemem) = bl_biosbasemem;
 		*RELOC(int *, &biosmem_implicit) = 1;
+	}
 	if (*RELOC(int *, &biosextmem) == 0) {
 		*RELOC(int *, &biosextmem) = bl_biosextmem;
 		*RELOC(int *, &biosmem_implicit) = 1;
+	}
 #undef RELOC
+}
 #endif /* XEN */
 /*
  * Machine-dependent startup code
  */
 void
 cpu_startup(void)
+{
 	int x, y;
 	vaddr_t minaddr, maxaddr;
 	psize_t sz;
 	/*
 	 * For console drivers that require uvm and pmap to be initialized,
 	 * we'll give them one more chance here...
 	 */
 	consinit();
 	/*
 	 * Initialize error message buffer (et end of core).
 	 */
 	if (msgbuf_p_cnt == 0)
 		panic("msgbuf paddr map has not been set up");
 	for (x = 0, sz = 0; x < msgbuf_p_cnt; sz += msgbuf_p_seg[x++].sz)
 		continue;
 	msgbuf_vaddr = uvm_km_alloc(kernel_map, sz, 0, UVM_KMF_VAONLY);
 	if (msgbuf_vaddr == 0)
 		panic("failed to valloc msgbuf_vaddr");
 	/* msgbuf_paddr was init'd in pmap */
 	for (y = 0, sz = 0; y < msgbuf_p_cnt; y++) {
 		for (x = 0; x < btoc(msgbuf_p_seg[y].sz); x++, sz += PAGE_SIZE)
 			pmap_kenter_pa((vaddr_t)msgbuf_vaddr + sz,
 			    msgbuf_p_seg[y].paddr + x * PAGE_SIZE,
 			    VM_PROT_READ|VM_PROT_WRITE, 0);
+	}
 	pmap_update(pmap_kernel());
 	initmsgbuf((void *)msgbuf_vaddr, sz);
 #ifdef MULTIBOOT
 	multiboot_print_info();
 #endif
 #ifdef TRAPLOG
 	/*
 	 * Enable recording of branch from/to in MSR's
 	 */
 	wrmsr(MSR_DEBUGCTLMSR, 0x1);
 #endif
 #if NCARDBUS > 0
 	/* Tell RBUS how much RAM we have, so it can use heuristics. */
 	rbus_min_start_hint(ctob((psize_t)physmem));
 #endif
 	minaddr = 0;
 	/*
 	 * Allocate a submap for physio
 	 */
 	phys_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr,
 				   VM_PHYS_SIZE, 0, false, NULL);
 	/* Say hello. */
 	banner();
 	/* Safe for i/o port / memory space allocation to use malloc now. */
 #if NISA > 0 || NPCI > 0
 	x86_bus_space_mallocok();
 #endif
 	gdt_init();
 	i386_proc0_tss_ldt_init();
 #ifndef XEN
 	cpu_init_tss(&cpu_info_primary);
 	ltr(cpu_info_primary.ci_tss_sel);
 #endif
 	x86_startup();
+}
 /*
  * Set up proc0's TSS and LDT.
  */
 void
 i386_proc0_tss_ldt_init(void)
+{
 	struct lwp *l;
 	struct pcb *pcb __diagused;
 	l = &lwp0;
 	pcb = lwp_getpcb(l);
 	pmap_kernel()->pm_ldt_sel = GSEL(GLDT_SEL, SEL_KPL);
 	pcb->pcb_cr0 = rcr0() & ~CR0_TS;
 	pcb->pcb_esp0 = uvm_lwp_getuarea(l) + USPACE - 16;
 	pcb->pcb_iopl = SEL_KPL;
 	l->l_md.md_regs = (struct trapframe *)pcb->pcb_esp0 - 1;
 	memcpy(&pcb->pcb_fsd, &gdt[GUDATA_SEL], sizeof(pcb->pcb_fsd));
 	memcpy(&pcb->pcb_gsd, &gdt[GUDATA_SEL], sizeof(pcb->pcb_gsd));
 #ifndef XEN
 	lldt(pmap_kernel()->pm_ldt_sel);
 #else
 	HYPERVISOR_fpu_taskswitch(1);
 	XENPRINTF(("lwp tss sp %p ss %04x/%04x\n",
 	    (void *)pcb->pcb_esp0,
 	    GSEL(GDATA_SEL, SEL_KPL),
 	    IDXSEL(GSEL(GDATA_SEL, SEL_KPL))));
 	HYPERVISOR_stack_switch(GSEL(GDATA_SEL, SEL_KPL), pcb->pcb_esp0);
 #endif
+}
 #ifdef XEN
 /* used in assembly */
 void i386_switch_context(lwp_t *);
 void i386_tls_switch(lwp_t *);
 /*
  * Switch context:
  * - switch stack pointer for user->kernel transition
  */
 void
 i386_switch_context(lwp_t *l)
+{
 	struct pcb *pcb;
 	struct physdev_op physop;
 	pcb = lwp_getpcb(l);
 	HYPERVISOR_stack_switch(GSEL(GDATA_SEL, SEL_KPL), pcb->pcb_esp0);
 	physop.cmd = PHYSDEVOP_SET_IOPL;
 	physop.u.set_iopl.iopl = pcb->pcb_iopl;
 	HYPERVISOR_physdev_op(&physop);
+}
 void
 i386_tls_switch(lwp_t *l)
+{
 	struct cpu_info *ci = curcpu();
 	struct pcb *pcb = lwp_getpcb(l);
 	/*
          * Raise the IPL to IPL_HIGH.
 	 * FPU IPIs can alter the LWP's saved cr0.  Dropping the priority
 	 * is deferred until mi_switch(), when cpu_switchto() returns.
 	 */
 	(void)splhigh();
         /*
 	 * If our floating point registers are on a different CPU,
 	 * set CR0_TS so we'll trap rather than reuse bogus state.
 	 */
 	if (l != ci->ci_fpcurlwp) {
 		HYPERVISOR_fpu_taskswitch(1);
+	}
 	/* Update TLS segment pointers */
 	update_descriptor(&ci->ci_gdt[GUFS_SEL],
 			  (union descriptor *) &pcb->pcb_fsd);
 	update_descriptor(&ci->ci_gdt[GUGS_SEL],
 			  (union descriptor *) &pcb->pcb_gsd);
+}
 #endif /* XEN */
 #ifndef XEN
 /*
  * Set up TSS and I/O bitmap.
  */
 void
 cpu_init_tss(struct cpu_info *ci)
+{
 	struct i386tss *tss = &ci->ci_tss;
 	tss->tss_iobase = IOMAP_INVALOFF << 16;
 	tss->tss_ss0 = GSEL(GDATA_SEL, SEL_KPL);
 	tss->tss_ldt = GSEL(GLDT_SEL, SEL_KPL);
 	tss->tss_cr3 = rcr3();
 	ci->ci_tss_sel = tss_alloc(tss);
+}
 #endif /* XEN */
 void *
 getframe(struct lwp *l, int sig, int *onstack)
+{
 	struct proc *p = l->l_proc;
 	struct trapframe *tf = l->l_md.md_regs;
 	/* Do we need to jump onto the signal stack? */
 	*onstack = (l->l_sigstk.ss_flags & (SS_DISABLE | SS_ONSTACK)) == 0
 	    && (SIGACTION(p, sig).sa_flags & SA_ONSTACK) != 0;
 	if (*onstack)
 		return (char *)l->l_sigstk.ss_sp + l->l_sigstk.ss_size;
 #ifdef VM86
 	if (tf->tf_eflags & PSL_VM)
 		return (void *)(tf->tf_esp + (tf->tf_ss << 4));
 	else
 #endif
 		return (void *)tf->tf_esp;
+}
 /*
  * Build context to run handler in.  We invoke the handler
  * directly, only returning via the trampoline.  Note the
  * trampoline version numbers are coordinated with machine-
  * dependent code in libc.
  */
 void
 buildcontext(struct lwp *l, int sel, void *catcher, void *fp)
+{
 	struct trapframe *tf = l->l_md.md_regs;
 	tf->tf_gs = GSEL(GUGS_SEL, SEL_UPL);
 	tf->tf_fs = GSEL(GUFS_SEL, SEL_UPL);
 	tf->tf_es = GSEL(GUDATA_SEL, SEL_UPL);
 	tf->tf_ds = GSEL(GUDATA_SEL, SEL_UPL);
 	tf->tf_eip = (int)catcher;
 	tf->tf_cs = GSEL(sel, SEL_UPL);
 	tf->tf_eflags &= ~PSL_CLEARSIG;
 	tf->tf_esp = (int)fp;
 	tf->tf_ss = GSEL(GUDATA_SEL, SEL_UPL);
 	/* Ensure FP state is reset. */
 	fpu_save_area_reset(l);
+}
 void
 sendsig_siginfo(const ksiginfo_t *ksi, const sigset_t *mask)
+{
 	struct lwp *l = curlwp;
 	struct proc *p = l->l_proc;
 	struct pmap *pmap = vm_map_pmap(&p->p_vmspace->vm_map);
 	int sel = pmap->pm_hiexec > I386_MAX_EXE_ADDR ?
 	    GUCODEBIG_SEL : GUCODE_SEL;
 	struct sigacts *ps = p->p_sigacts;
 	int onstack, error;
 	int sig = ksi->ksi_signo;
 	struct sigframe_siginfo *fp = getframe(l, sig, &onstack), frame;
 	sig_t catcher = SIGACTION(p, sig).sa_handler;
 	struct trapframe *tf = l->l_md.md_regs;
 	KASSERT(mutex_owned(p->p_lock));
 	fp--;
 	frame.sf_ra = (int)ps->sa_sigdesc[sig].sd_tramp;
 	frame.sf_signum = sig;
 	frame.sf_sip = &fp->sf_si;
 	frame.sf_ucp = &fp->sf_uc;
 	frame.sf_si._info = ksi->ksi_info;
 	frame.sf_uc.uc_flags = _UC_SIGMASK|_UC_VM;
 	frame.sf_uc.uc_sigmask = *mask;
 	frame.sf_uc.uc_link = l->l_ctxlink;
 	frame.sf_uc.uc_flags |= (l->l_sigstk.ss_flags & SS_ONSTACK)
 	    ? _UC_SETSTACK : _UC_CLRSTACK;
 	memset(&frame.sf_uc.uc_stack, 0, sizeof(frame.sf_uc.uc_stack));
 	if (tf->tf_eflags & PSL_VM)
 		(*p->p_emul->e_syscall_intern)(p);
 	sendsig_reset(l, sig);
 	mutex_exit(p->p_lock);
 	cpu_getmcontext(l, &frame.sf_uc.uc_mcontext, &frame.sf_uc.uc_flags);
 	error = copyout(&frame, fp, sizeof(frame));
 	mutex_enter(p->p_lock);
 	if (error != 0) {
 		/*
 		 * Process has trashed its stack; give it an illegal
 		 * instruction to halt it in its tracks.
 		 */
 		sigexit(l, SIGILL);
 		/* NOTREACHED */
+	}
 	buildcontext(l, sel, catcher, fp);
 	/* Remember that we're now on the signal stack. */
 	if (onstack)
 		l->l_sigstk.ss_flags |= SS_ONSTACK;
+}
 static void
 maybe_dump(int howto)
+{
 	int s;
 	/* Disable interrupts. */
 	s = splhigh();
 	/* Do a dump if requested. */
 	if ((howto & (RB_DUMP | RB_HALT)) == RB_DUMP)
 		dumpsys();
 	splx(s);
+}
 void
 cpu_reboot(int howto, char *bootstr)
+{
 	static bool syncdone = false;
 	int s = IPL_NONE;
 	if (cold) {
 		howto |= RB_HALT;
 		goto haltsys;
+	}
 	boothowto = howto;
 	/* XXX used to dump after vfs_shutdown() and before
 	 * detaching devices / shutdown hooks / pmf_system_shutdown().
 	 */
 	maybe_dump(howto);
 	/*
 	 * If we've panic'd, don't make the situation potentially
 	 * worse by syncing or unmounting the file systems.
 	 */
 	if ((howto & RB_NOSYNC) == 0 && panicstr == NULL) {
 		if (!syncdone) {
 			syncdone = true;
 			/* XXX used to force unmount as well, here */
 			vfs_sync_all(curlwp);
 			/*
 			 * If we've been adjusting the clock, the todr
 			 * will be out of synch; adjust it now.
+			 *
 			 * XXX used to do this after unmounting all
 			 * filesystems with vfs_shutdown().
 			 */
 			if (time_adjusted != 0)
 				resettodr();
+		}
 		while (vfs_unmountall1(curlwp, false, false) ||
 		       config_detach_all(boothowto) ||
 		       vfs_unmount_forceone(curlwp))
 			;	/* do nothing */
 	} else
 		suspendsched();
 	pmf_system_shutdown(boothowto);
 	s = splhigh();
 	/* amd64 maybe_dump() */
 haltsys:
 	doshutdownhooks();
 	if ((howto & RB_POWERDOWN) == RB_POWERDOWN) {
 #if NACPICA > 0
 		if (s != IPL_NONE)
 			splx(s);
 		acpi_enter_sleep_state(ACPI_STATE_S5);
 #else
 		__USE(s);
 #endif
 #ifdef XEN
 		HYPERVISOR_shutdown();
 		for (;;);
 #endif
+	}
 #ifdef MULTIPROCESSOR
 	cpu_broadcast_halt();
 #endif /* MULTIPROCESSOR */
 	if (howto & RB_HALT) {
 #if NACPICA > 0
 		acpi_disable();
 #endif
 		printf("\n");
 		printf("The operating system has halted.\n");
 		printf("Please press any key to reboot.\n\n");
 #ifdef BEEP_ONHALT
+		{
 			int c;
 			for (c = BEEP_ONHALT_COUNT; c > 0; c--) {
 				sysbeep(BEEP_ONHALT_PITCH,
 					BEEP_ONHALT_PERIOD * hz / 1000);
 				delay(BEEP_ONHALT_PERIOD * 1000);
 				sysbeep(0, BEEP_ONHALT_PERIOD * hz / 1000);
 				delay(BEEP_ONHALT_PERIOD * 1000);
+			}
+		}
 #endif
 		cnpollc(1);	/* for proper keyboard command handling */
 		if (cngetc() == 0) {
 			/* no console attached, so just hlt */
 			printf("No keyboard - cannot reboot after all.\n");
 			for(;;) {
 				x86_hlt();
+			}
+		}
 		cnpollc(0);
+	}
 	printf("rebooting...\n");
 	if (cpureset_delay > 0)
 		delay(cpureset_delay * 1000);
 	cpu_reset();
 	for(;;) ;
 	/*NOTREACHED*/
+}
 /*
  * Clear registers on exec
  */
 void
 setregs(struct lwp *l, struct exec_package *pack, vaddr_t stack)
+{
 	struct pmap *pmap = vm_map_pmap(&l->l_proc->p_vmspace->vm_map);
 	struct pcb *pcb = lwp_getpcb(l);
 	struct trapframe *tf;
 #ifdef USER_LDT
 	pmap_ldt_cleanup(l);
 #endif
 	fpu_save_area_clear(l, pack->ep_osversion >= 699002600
 	    ? __INITIAL_NPXCW__ : __NetBSD_COMPAT_NPXCW__);
 	memcpy(&pcb->pcb_fsd, &gdt[GUDATA_SEL], sizeof(pcb->pcb_fsd));
 	memcpy(&pcb->pcb_gsd, &gdt[GUDATA_SEL], sizeof(pcb->pcb_gsd));
 	tf = l->l_md.md_regs;
 	tf->tf_gs = GSEL(GUGS_SEL, SEL_UPL);
 	tf->tf_fs = GSEL(GUFS_SEL, SEL_UPL);
 	tf->tf_es = LSEL(LUDATA_SEL, SEL_UPL);
 	tf->tf_ds = LSEL(LUDATA_SEL, SEL_UPL);
 	tf->tf_edi = 0;
 	tf->tf_esi = 0;
 	tf->tf_ebp = 0;
 	tf->tf_ebx = l->l_proc->p_psstrp;
 	tf->tf_edx = 0;
 	tf->tf_ecx = 0;
 	tf->tf_eax = 0;
 	tf->tf_eip = pack->ep_entry;
 	tf->tf_cs = pmap->pm_hiexec > I386_MAX_EXE_ADDR ?
 	    LSEL(LUCODEBIG_SEL, SEL_UPL) : LSEL(LUCODE_SEL, SEL_UPL);
 	tf->tf_eflags = PSL_USERSET;
 	tf->tf_esp = stack;
 	tf->tf_ss = LSEL(LUDATA_SEL, SEL_UPL);
+}
 /*
  * Initialize segments and descriptor tables
  */
 union	descriptor *gdt, *ldt;
 union	descriptor *pentium_idt;
 extern vaddr_t lwp0uarea;
 void
 setgate(struct gate_descriptor *gd, void *func, int args, int type, int dpl,
     int sel)
+{
 	gd->gd_looffset = (int)func;
 	gd->gd_selector = sel;
 	gd->gd_stkcpy = args;
 	gd->gd_xx = 0;
 	gd->gd_type = type;
 	gd->gd_dpl = dpl;
 	gd->gd_p = 1;
 	gd->gd_hioffset = (int)func >> 16;
+}
 void
 unsetgate(struct gate_descriptor *gd)
+{
 	gd->gd_p = 0;
 	gd->gd_hioffset = 0;
 	gd->gd_looffset = 0;
 	gd->gd_selector = 0;
 	gd->gd_xx = 0;
 	gd->gd_stkcpy = 0;
 	gd->gd_type = 0;
 	gd->gd_dpl = 0;
+}
 void
 setregion(struct region_descriptor *rd, void *base, size_t limit)
+{
 	rd->rd_limit = (int)limit;
 	rd->rd_base = (int)base;
+}
 void
 setsegment(struct segment_descriptor *sd, const void *base, size_t limit,
     int type, int dpl, int def32, int gran)
+{
 	sd->sd_lolimit = (int)limit;
 	sd->sd_lobase = (int)base;
 	sd->sd_type = type;
 	sd->sd_dpl = dpl;
 	sd->sd_p = 1;
 	sd->sd_hilimit = (int)limit >> 16;
 	sd->sd_xx = 0;
 	sd->sd_def32 = def32;
 	sd->sd_gran = gran;
 	sd->sd_hibase = (int)base >> 24;
+}
 #define	IDTVEC(name)	__CONCAT(X, name)
 typedef void (vector)(void);
 extern vector IDTVEC(syscall);
 extern vector IDTVEC(osyscall);
 extern vector *IDTVEC(exceptions)[];
 extern vector IDTVEC(svr4_fasttrap);
 void (*svr4_fasttrap_vec)(void) = (void (*)(void))nullop;
 krwlock_t svr4_fasttrap_lock;
 #ifdef XEN
 #define MAX_XEN_IDT 128
 trap_info_t xen_idt[MAX_XEN_IDT];
 int xen_idt_idx;
 extern union descriptor tmpgdt[];
 #endif
 void
 cpu_init_idt(void)
+{
 #ifndef XEN
 	struct region_descriptor region;
 	setregion(&region, pentium_idt, NIDT * sizeof(idt[0]) - 1);
 	lidt(&region);
 #else /* XEN */
 	XENPRINTF(("HYPERVISOR_set_trap_table %p\n", xen_idt));
 	if (HYPERVISOR_set_trap_table(xen_idt))
 		panic("HYPERVISOR_set_trap_table %p failed\n", xen_idt);
 #endif /* !XEN */
+}
 void
 initgdt(union descriptor *tgdt)
+{
 	KASSERT(tgdt != NULL);
 	gdt = tgdt;
 #ifdef XEN
 	u_long	frames[16];
 #else
 	struct region_descriptor region;
 	memset(gdt, 0, NGDT*sizeof(*gdt));
 #endif /* XEN */
 	/* make gdt gates and memory segments */
 	setsegment(&gdt[GCODE_SEL].sd, 0, 0xfffff, SDT_MEMERA, SEL_KPL, 1, 1);
 	setsegment(&gdt[GDATA_SEL].sd, 0, 0xfffff, SDT_MEMRWA, SEL_KPL, 1, 1);
 	setsegment(&gdt[GUCODE_SEL].sd, 0, x86_btop(I386_MAX_EXE_ADDR) - 1,
 	    SDT_MEMERA, SEL_UPL, 1, 1);
 	setsegment(&gdt[GUCODEBIG_SEL].sd, 0, 0xfffff,
 	    SDT_MEMERA, SEL_UPL, 1, 1);
 	setsegment(&gdt[GUDATA_SEL].sd, 0, 0xfffff,
 	    SDT_MEMRWA, SEL_UPL, 1, 1);
 #if NBIOSCALL > 0
 	/* bios trampoline GDT entries */
 	setsegment(&gdt[GBIOSCODE_SEL].sd, 0, 0xfffff, SDT_MEMERA, SEL_KPL, 0,
 );
 	setsegment(&gdt[GBIOSDATA_SEL].sd, 0, 0xfffff, SDT_MEMRWA, SEL_KPL, 0,
 );
 #endif
 	setsegment(&gdt[GCPU_SEL].sd, &cpu_info_primary, 0xfffff,
 	    SDT_MEMRWA, SEL_KPL, 1, 1);
 #ifndef XEN
 	setregion(&region, gdt, NGDT * sizeof(gdt[0]) - 1);
 	lgdt(&region);
 #else /* !XEN */
 	/*
 	 * We jumpstart the bootstrap process a bit so we can update
 	 * page permissions. This is done redundantly later from
 	 * x86_xpmap.c:xen_pmap_bootstrap() - harmless.
 	 */
 	xpmap_phys_to_machine_mapping =
 	    (unsigned long *)xen_start_info.mfn_list;
 	frames[0] = xpmap_ptom((uint32_t)gdt - KERNBASE) >> PAGE_SHIFT;
 	{	/*
 		 * Enter the gdt page RO into the kernel map. We can't
 		 * use pmap_kenter_pa() here, because %fs is not
 		 * usable until the gdt is loaded, and %fs is used as
 		 * the base pointer for curcpu() and curlwp(), both of
 		 * which are in the callpath of pmap_kenter_pa().
 		 * So we mash up our own - this is MD code anyway.
 		 */
 		pt_entry_t pte;
 		pt_entry_t pg_nx = (cpu_feature[2] & CPUID_NOX ? PG_NX : 0);
 		pte = pmap_pa2pte((vaddr_t)gdt - KERNBASE);
 		pte |= PG_k | PG_RO | pg_nx | PG_V;
 		if (HYPERVISOR_update_va_mapping((vaddr_t)gdt, pte, UVMF_INVLPG) < 0) {
 			panic("gdt page RO update failed.\n");
+		}
+	}
 	XENPRINTK(("loading gdt %lx, %d entries\n", frames[0] << PAGE_SHIFT,
 	    NGDT));
 	if (HYPERVISOR_set_gdt(frames, NGDT /* XXX is it right ? */))
 		panic("HYPERVISOR_set_gdt failed!\n");
 	lgdt_finish();
 #endif /* !XEN */
+}
 static void
 init386_msgbuf(void)
+{
 	/* Message buffer is located at end of core. */
 	struct vm_physseg *vps;
 	psize_t sz = round_page(MSGBUFSIZE);
 	psize_t reqsz = sz;
 	unsigned int x;
  search_again:
 	vps = NULL;
 	for (x = 0; x < vm_nphysseg; ++x) {
 		vps = VM_PHYSMEM_PTR(x);
 		if (ctob(vps->avail_end) == avail_end) {
 			break;
+		}
+	}
 	if (x == vm_nphysseg)
 		panic("init386: can't find end of memory");
 	/* Shrink so it'll fit in the last segment. */
 	if (vps->avail_end - vps->avail_start < atop(sz))
 		sz = ctob(vps->avail_end - vps->avail_start);
 	vps->avail_end -= atop(sz);
 	vps->end -= atop(sz);
 	msgbuf_p_seg[msgbuf_p_cnt].sz = sz;
 	msgbuf_p_seg[msgbuf_p_cnt++].paddr = ctob(vps->avail_end);
 	/* Remove the last segment if it now has no pages. */
 	if (vps->start == vps->end) {
 		for (--vm_nphysseg; x < vm_nphysseg; x++)
 			VM_PHYSMEM_PTR_SWAP(x, x + 1);
+	}
 	/* Now find where the new avail_end is. */
 	for (avail_end = 0, x = 0; x < vm_nphysseg; x++)
 		if (VM_PHYSMEM_PTR(x)->avail_end > avail_end)
 			avail_end = VM_PHYSMEM_PTR(x)->avail_end;
 	avail_end = ctob(avail_end);
 	if (sz == reqsz)
 		return;
 	reqsz -= sz;
 	if (msgbuf_p_cnt == VM_PHYSSEG_MAX) {
 		/* No more segments available, bail out. */
 		printf("WARNING: MSGBUFSIZE (%zu) too large, using %zu.\n",
 		    (size_t)MSGBUFSIZE, (size_t)(MSGBUFSIZE - reqsz));
 		return;
+	}
 	sz = reqsz;
 	goto search_again;
+}
 #ifndef XEN
 static void
 init386_pte0(void)
+{
 	paddr_t paddr;
 	vaddr_t vaddr;
 	paddr = 4 * PAGE_SIZE;
 	vaddr = (vaddr_t)vtopte(0);
 	pmap_kenter_pa(vaddr, paddr, VM_PROT_ALL, 0);
 	pmap_update(pmap_kernel());
 	/* make sure it is clean before using */
 	memset((void *)vaddr, 0, PAGE_SIZE);
+}
 #endif /* !XEN */
 static void
 init386_ksyms(void)
+{
 #if NKSYMS || defined(DDB) || defined(MODULAR)
 	extern int end;
 	struct btinfo_symtab *symtab;
 #ifdef DDB
 	db_machine_init();
 #endif
 #if defined(MULTIBOOT)
 	if (multiboot_ksyms_addsyms_elf())
 		return;
 #endif
 	if ((symtab = lookup_bootinfo(BTINFO_SYMTAB)) == NULL) {
 		ksyms_addsyms_elf(*(int *)&end, ((int *)&end) + 1, esym);
 		return;
+	}
 	symtab->ssym += KERNBASE;
 	symtab->esym += KERNBASE;
 	ksyms_addsyms_elf(symtab->nsym, (int *)symtab->ssym, (int *)symtab->esym);
 #endif
+}
 void
 init386(paddr_t first_avail)
+{
 	extern void consinit(void);
 	int x;
 #ifndef XEN
 	union descriptor *tgdt;
 	extern struct extent *iomem_ex;
 	struct region_descriptor region;
 	struct btinfo_memmap *bim;
 #endif
 #if NBIOSCALL > 0
 	extern int biostramp_image_size;
 	extern u_char biostramp_image[];
 #endif
 #ifdef XEN
 	XENPRINTK(("HYPERVISOR_shared_info %p (%x)\n", HYPERVISOR_shared_info,
 	    xen_start_info.shared_info));
 	KASSERT(HYPERVISOR_shared_info != NULL);
 	cpu_info_primary.ci_vcpu = &HYPERVISOR_shared_info->vcpu_info[0];
 #endif
 	cpu_probe(&cpu_info_primary);
 	uvm_lwp_setuarea(&lwp0, lwp0uarea);
 	cpu_init_msrs(&cpu_info_primary, true);
 #ifdef PAE
 	use_pae = 1;
 #else
 	use_pae = 0;
 #endif
 #ifdef XEN
 	struct pcb *pcb = lwp_getpcb(&lwp0);
 	pcb->pcb_cr3 = PDPpaddr;
 	__PRINTK(("pcb_cr3 0x%lx cr3 0x%lx\n",
 	    PDPpaddr, xpmap_ptom(PDPpaddr)));
 	XENPRINTK(("lwp0uarea %p first_avail %p\n",
 	    lwp0uarea, (void *)(long)first_avail));
 	XENPRINTK(("ptdpaddr %p atdevbase %p\n", (void *)PDPpaddr,
 	    (void *)atdevbase));
 #endif
 #if defined(PAE) && !defined(XEN)
 	/*
 	 * Save VA and PA of L3 PD of boot processor (for Xen, this is done
 	 * in xen_pmap_bootstrap())
 	 */
 	cpu_info_primary.ci_pae_l3_pdirpa = rcr3();
 	cpu_info_primary.ci_pae_l3_pdir = (pd_entry_t *)(rcr3() + KERNBASE);
 #endif /* PAE && !XEN */
 #ifdef XEN
 	xen_parse_cmdline(XEN_PARSE_BOOTFLAGS, NULL);
 #endif
 	/*
 	 * Initialize PAGE_SIZE-dependent variables.
 	 */
 	uvm_setpagesize();
 	/*
 	 * Start with 2 color bins -- this is just a guess to get us
 	 * started.  We'll recolor when we determine the largest cache
 	 * sizes on the system.
 	 */
 	uvmexp.ncolors = 2;
 #ifndef XEN
 	/*
 	 * Low memory reservations:
 	 * Page 0:	BIOS data
 	 * Page 1:	BIOS callback
-	 * Page 2:	MP bootstrap
+	 * Page 2:	MP bootstrap code (MP_TRAMPOLINE)
-	 * Page 3:	ACPI wakeup code
+	 * Page 3:	ACPI wakeup code (ACPI_WAKEUP_ADDR)
 	 * Page 4:	Temporary page table for 0MB-4MB
 	 * Page 5:	Temporary page directory
 	 */
 	avail_start = 6 * PAGE_SIZE;
 #else /* !XEN */
 	/* steal one page for gdt */
 	gdt = (void *)((u_long)first_avail + KERNBASE);
 	first_avail += PAGE_SIZE;
 	/* Make sure the end of the space used by the kernel is rounded. */
 	first_avail = round_page(first_avail);
 	avail_start = first_avail;
 	avail_end = ctob((paddr_t)xen_start_info.nr_pages);
 	pmap_pa_start = (KERNTEXTOFF - KERNBASE);
 	pmap_pa_end = pmap_pa_start + ctob((paddr_t)xen_start_info.nr_pages);
 	mem_clusters[0].start = avail_start;
 	mem_clusters[0].size = avail_end - avail_start;
 	mem_cluster_cnt++;
 	physmem += xen_start_info.nr_pages;
 	uvmexp.wired += atop(avail_start);
 	/*
 	 * initgdt() has to be done before consinit(), so that %fs is properly
 	 * initialised. initgdt() uses pmap_kenter_pa so it can't be called
 	 * before the above variables are set.
 	 */
 	initgdt(gdt);
 	mutex_init(&pte_lock, MUTEX_DEFAULT, IPL_VM);
 #endif /* XEN */
 #if NISA > 0 || NPCI > 0
 	x86_bus_space_init();
 #endif /* NISA > 0 || NPCI > 0 */
 	consinit();	/* XXX SHOULD NOT BE DONE HERE */
 #ifdef DEBUG_MEMLOAD
 	printf("mem_cluster_count: %d\n", mem_cluster_cnt);
 #endif
 	/*
 	 * Call pmap initialization to make new kernel address space.
 	 * We must do this before loading pages into the VM system.
 	 */
 	pmap_bootstrap((vaddr_t)atdevbase + IOM_SIZE);
 #ifndef XEN
 	/*
 	 * Check to see if we have a memory map from the BIOS (passed
 	 * to us by the boot program.
 	 */
 	bim = lookup_bootinfo(BTINFO_MEMMAP);
 	if ((biosmem_implicit || (biosbasemem == 0 && biosextmem == 0)) &&
 	    bim != NULL && bim->num > 0)
 		initx86_parse_memmap(bim, iomem_ex);
 	/*
 	 * If the loop above didn't find any valid segment, fall back to
 	 * former code.
 	 */
 	if (mem_cluster_cnt == 0)
 		initx86_fake_memmap(iomem_ex);
 	initx86_load_memmap(first_avail);
 #else /* !XEN */
 	XENPRINTK(("load the memory cluster 0x%" PRIx64 " (%" PRId64 ") - "
 	    "0x%" PRIx64 " (%" PRId64 ")\n",
 	    (uint64_t)avail_start, (uint64_t)atop(avail_start),
 	    (uint64_t)avail_end, (uint64_t)atop(avail_end)));
 	uvm_page_physload(atop(avail_start), atop(avail_end),
 	    atop(avail_start), atop(avail_end),
 	    VM_FREELIST_DEFAULT);
 	/* Reclaim the boot gdt page - see locore.s */
+	{
 		pt_entry_t pte;
 		pt_entry_t pg_nx = (cpu_feature[2] & CPUID_NOX ? PG_NX : 0);
 		pte = pmap_pa2pte((vaddr_t)tmpgdt - KERNBASE);
 		pte |= PG_k | PG_RW | pg_nx | PG_V;
 		if (HYPERVISOR_update_va_mapping((vaddr_t)tmpgdt, pte, UVMF_INVLPG) < 0) {
 			panic("tmpgdt page relaim RW update failed.\n");
+		}
+	}
 #endif /* !XEN */
 	init386_msgbuf();
 #ifndef XEN
 	/*
 	 * XXX Remove this
+	 *
 	 * Setup a temporary Page Table Entry to allow identity mappings of
 	 * the real mode address. This is required by:
 	 * - bioscall
 	 * - MP bootstrap
 	 * - ACPI wakecode
 	 */
 	init386_pte0();
 #if NBIOSCALL > 0
 	KASSERT(biostramp_image_size <= PAGE_SIZE);
 	pmap_kenter_pa((vaddr_t)BIOSTRAMP_BASE,	/* virtual */
 		       (paddr_t)BIOSTRAMP_BASE,	/* physical */
 		       VM_PROT_ALL, 0);		/* protection */
 	pmap_update(pmap_kernel());
 	memcpy((void *)BIOSTRAMP_BASE, biostramp_image, biostramp_image_size);
 	/* Needed early, for bioscall() */
 	cpu_info_primary.ci_pmap = pmap_kernel();
 #endif
 #endif /* !XEN */
 	pmap_kenter_pa(idt_vaddr, idt_paddr, VM_PROT_READ|VM_PROT_WRITE, 0);
 	pmap_update(pmap_kernel());
 	memset((void *)idt_vaddr, 0, PAGE_SIZE);
 #ifndef XEN
 	idt_init();
 	idt = (struct gate_descriptor *)idt_vaddr;
 	pmap_kenter_pa(pentium_idt_vaddr, idt_paddr, VM_PROT_READ, 0);
 	pmap_update(pmap_kernel());
 	pentium_idt = (union descriptor *)pentium_idt_vaddr;
 	tgdt = gdt;
 	gdt = (union descriptor *)
 		    ((char *)idt + NIDT * sizeof (struct gate_descriptor));
 	ldt = gdt + NGDT;
 	memcpy(gdt, tgdt, NGDT*sizeof(*gdt));
 	setsegment(&gdt[GLDT_SEL].sd, ldt, NLDT * sizeof(ldt[0]) - 1,
 	    SDT_SYSLDT, SEL_KPL, 0, 0);
 #else
 	HYPERVISOR_set_callbacks(
 	    GSEL(GCODE_SEL, SEL_KPL), (unsigned long)hypervisor_callback,
 	    GSEL(GCODE_SEL, SEL_KPL), (unsigned long)failsafe_callback);
 	ldt = (union descriptor *)idt_vaddr;
 #endif /* XEN */
 	/* make ldt gates and memory segments */
 	setgate(&ldt[LSYS5CALLS_SEL].gd, &IDTVEC(osyscall), 1,
 	    SDT_SYS386CGT, SEL_UPL, GSEL(GCODE_SEL, SEL_KPL));
 	ldt[LUCODE_SEL] = gdt[GUCODE_SEL];
 	ldt[LUCODEBIG_SEL] = gdt[GUCODEBIG_SEL];
 	ldt[LUDATA_SEL] = gdt[GUDATA_SEL];
 	ldt[LSOL26CALLS_SEL] = ldt[LBSDICALLS_SEL] = ldt[LSYS5CALLS_SEL];
 #ifndef XEN
 	/* exceptions */
 	for (x = 0; x < 32; x++) {
 		idt_vec_reserve(x);
 		setgate(&idt[x], IDTVEC(exceptions)[x], 0, SDT_SYS386IGT,
 		    (x == 3 || x == 4) ? SEL_UPL : SEL_KPL,
 		    GSEL(GCODE_SEL, SEL_KPL));
+	}
 	/* new-style interrupt gate for syscalls */
 	idt_vec_reserve(128);
 	setgate(&idt[128], &IDTVEC(syscall), 0, SDT_SYS386IGT, SEL_UPL,
 	    GSEL(GCODE_SEL, SEL_KPL));
 	idt_vec_reserve(0xd2);
 	setgate(&idt[0xd2], &IDTVEC(svr4_fasttrap), 0, SDT_SYS386IGT,
 	    SEL_UPL, GSEL(GCODE_SEL, SEL_KPL));
 	setregion(&region, gdt, NGDT * sizeof(gdt[0]) - 1);
 	lgdt(&region);
 	cpu_init_idt();
 #else /* !XEN */
 	memset(xen_idt, 0, sizeof(trap_info_t) * MAX_XEN_IDT);
 	xen_idt_idx = 0;
 	for (x = 0; x < 32; x++) {
 		KASSERT(xen_idt_idx < MAX_XEN_IDT);
 		xen_idt[xen_idt_idx].vector = x;
 		switch (x) {
 		case 2:  /* NMI */
 		case 18: /* MCA */
 			TI_SET_IF(&(xen_idt[xen_idt_idx]), 2);
 			break;
 		case 3:
 		case 4:
 			xen_idt[xen_idt_idx].flags = SEL_UPL;
 			break;
 		default:
 			xen_idt[xen_idt_idx].flags = SEL_XEN;
 			break;
+		}
 		xen_idt[xen_idt_idx].cs = GSEL(GCODE_SEL, SEL_KPL);
 		xen_idt[xen_idt_idx].address =
 			(uint32_t)IDTVEC(exceptions)[x];
 		xen_idt_idx++;
+	}
 	KASSERT(xen_idt_idx < MAX_XEN_IDT);
 	xen_idt[xen_idt_idx].vector = 128;
 	xen_idt[xen_idt_idx].flags = SEL_UPL;
 	xen_idt[xen_idt_idx].cs = GSEL(GCODE_SEL, SEL_KPL);
 	xen_idt[xen_idt_idx].address = (uint32_t)&IDTVEC(syscall);
 	xen_idt_idx++;
 	KASSERT(xen_idt_idx < MAX_XEN_IDT);
 	xen_idt[xen_idt_idx].vector = 0xd2;
 	xen_idt[xen_idt_idx].flags = SEL_UPL;
 	xen_idt[xen_idt_idx].cs = GSEL(GCODE_SEL, SEL_KPL);
 	xen_idt[xen_idt_idx].address = (uint32_t)&IDTVEC(svr4_fasttrap);
 	xen_idt_idx++;
 	lldt(GSEL(GLDT_SEL, SEL_KPL));
 	cpu_init_idt();
 #endif /* XEN */
 	init386_ksyms();
 #if NMCA > 0
 	/* check for MCA bus, needed to be done before ISA stuff - if
 	 * MCA is detected, ISA needs to use level triggered interrupts
 	 * by default */
 	mca_busprobe();
 #endif
 #ifdef XEN
 	XENPRINTF(("events_default_setup\n"));
 	events_default_setup();
 #else
 	intr_default_setup();
 #endif
 	splraise(IPL_HIGH);
 	x86_enable_intr();
 #ifdef DDB
 	if (boothowto & RB_KDB)
 		Debugger();
 #endif
 #ifdef IPKDB
 	ipkdb_init();
 	if (boothowto & RB_KDB)
 		ipkdb_connect(0);
 #endif
 #ifdef KGDB
 	kgdb_port_init();
 	if (boothowto & RB_KDB) {
 		kgdb_debug_init = 1;
 		kgdb_connect(1);
+	}
 #endif
 	if (physmem < btoc(2 * 1024 * 1024)) {
 		printf("warning: too little memory available; "
 		       "have %lu bytes, want %lu bytes\n"
 		       "running in degraded mode\n"
 		       "press a key to confirm\n\n",
 		       (unsigned long)ptoa(physmem), 2*1024*1024UL);
 		cngetc();
+	}
 	rw_init(&svr4_fasttrap_lock);
+}
 #include <dev/ic/mc146818reg.h>		/* for NVRAM POST */
 #include <i386/isa/nvram.h>		/* for NVRAM POST */
 void
 cpu_reset(void)
+{
 #ifdef XEN
 	HYPERVISOR_reboot();
 	for (;;);
 #else /* XEN */
 	struct region_descriptor region;
 	x86_disable_intr();
 	/*
 	 * Ensure the NVRAM reset byte contains something vaguely sane.
 	 */
 	outb(IO_RTC, NVRAM_RESET);
 	outb(IO_RTC+1, NVRAM_RESET_RST);
 	/*
 	 * Reset AMD Geode SC1100.
+	 *
 	 * 1) Write PCI Configuration Address Register (0xcf8) to
 	 *    select Function 0, Register 0x44: Bridge Configuration,
 	 *    GPIO and LPC Configuration Register Space, Reset
 	 *    Control Register.
+	 *
 	 * 2) Write 0xf to PCI Configuration Data Register (0xcfc)
 	 *    to reset IDE controller, IDE bus, and PCI bus, and
 	 *    to trigger a system-wide reset.
+	 *
 	 * See AMD Geode SC1100 Processor Data Book, Revision 2.0,
 	 * sections 6.3.1, 6.3.2, and 6.4.1.
 	 */
 	if (cpu_info_primary.ci_signature == 0x540) {
 		outl(0xcf8, 0x80009044);
 		outl(0xcfc, 0xf);
+	}
 	x86_reset();
 	/*
 	 * Try to cause a triple fault and watchdog reset by making the IDT
 	 * invalid and causing a fault.
 	 */
 	memset((void *)idt, 0, NIDT * sizeof(idt[0]));
 	setregion(&region, idt, NIDT * sizeof(idt[0]) - 1);
 	lidt(&region);
 	breakpoint();
 #if 0
 	/*
 	 * Try to cause a triple fault and watchdog reset by unmapping the
 	 * entire address space and doing a TLB flush.
 	 */
 	memset((void *)PTD, 0, PAGE_SIZE);
 	tlbflush();
 #endif
 	for (;;);
 #endif /* XEN */
+}
 void
 cpu_getmcontext(struct lwp *l, mcontext_t *mcp, unsigned int *flags)
+{
 	const struct trapframe *tf = l->l_md.md_regs;
 	__greg_t *gr = mcp->__gregs;
 	__greg_t ras_eip;
 	/* Save register context. */
 #ifdef VM86
 	if (tf->tf_eflags & PSL_VM) {
 		gr[_REG_GS]  = tf->tf_vm86_gs;
 		gr[_REG_FS]  = tf->tf_vm86_fs;
 		gr[_REG_ES]  = tf->tf_vm86_es;
 		gr[_REG_DS]  = tf->tf_vm86_ds;
 		gr[_REG_EFL] = get_vflags(l);
 	} else
 #endif
+	{
 		gr[_REG_GS]  = tf->tf_gs;
 		gr[_REG_FS]  = tf->tf_fs;
 		gr[_REG_ES]  = tf->tf_es;
 		gr[_REG_DS]  = tf->tf_ds;
 		gr[_REG_EFL] = tf->tf_eflags;
+	}
 	gr[_REG_EDI]    = tf->tf_edi;
 	gr[_REG_ESI]    = tf->tf_esi;
 	gr[_REG_EBP]    = tf->tf_ebp;
 	gr[_REG_EBX]    = tf->tf_ebx;
 	gr[_REG_EDX]    = tf->tf_edx;
 	gr[_REG_ECX]    = tf->tf_ecx;
 	gr[_REG_EAX]    = tf->tf_eax;
 	gr[_REG_EIP]    = tf->tf_eip;
 	gr[_REG_CS]     = tf->tf_cs;
 	gr[_REG_ESP]    = tf->tf_esp;
 	gr[_REG_UESP]   = tf->tf_esp;
 	gr[_REG_SS]     = tf->tf_ss;
 	gr[_REG_TRAPNO] = tf->tf_trapno;
 	gr[_REG_ERR]    = tf->tf_err;
 	if ((ras_eip = (__greg_t)ras_lookup(l->l_proc,
 	    (void *) gr[_REG_EIP])) != -1)
 		gr[_REG_EIP] = ras_eip;
 	*flags |= _UC_CPU;
 	mcp->_mc_tlsbase = (uintptr_t)l->l_private;
 	*flags |= _UC_TLSBASE;
 	/*
 	 * Save floating point register context.
+	 *
 	 * If the cpu doesn't support fxsave we must still write to
 	 * the entire 512 byte area - otherwise we leak kernel memory
 	 * contents to userspace.
 	 * It wouldn't matter if we were doing the copyout here.
 	 * So we might as well convert to fxsave format.
 	 */
 	__CTASSERT(sizeof (struct fxsave) ==
 	    sizeof mcp->__fpregs.__fp_reg_set.__fp_xmm_state);
 	process_read_fpregs_xmm(l, (struct fxsave *)
 	    &mcp->__fpregs.__fp_reg_set.__fp_xmm_state);
 	memset(&mcp->__fpregs.__fp_pad, 0, sizeof mcp->__fpregs.__fp_pad);
 	*flags |= _UC_FXSAVE | _UC_FPU;
+}
 int
 cpu_mcontext_validate(struct lwp *l, const mcontext_t *mcp)
+{
 	const __greg_t *gr = mcp->__gregs;
 	struct trapframe *tf = l->l_md.md_regs;
 	/*
 	 * Check for security violations.  If we're returning
 	 * to protected mode, the CPU will validate the segment
 	 * registers automatically and generate a trap on
 	 * violations.  We handle the trap, rather than doing
 	 * all of the checking here.
 	 */
 	if (((gr[_REG_EFL] ^ tf->tf_eflags) & PSL_USERSTATIC) ||
 	    !USERMODE(gr[_REG_CS], gr[_REG_EFL]))
 		return EINVAL;
 	return 0;
+}
 int
 cpu_setmcontext(struct lwp *l, const mcontext_t *mcp, unsigned int flags)
+{
 	struct trapframe *tf = l->l_md.md_regs;
 	const __greg_t *gr = mcp->__gregs;
 	struct proc *p = l->l_proc;
 	int error;
 	/* Restore register context, if any. */
 	if ((flags & _UC_CPU) != 0) {
 #ifdef VM86
 		if (gr[_REG_EFL] & PSL_VM) {
 			tf->tf_vm86_gs = gr[_REG_GS];
 			tf->tf_vm86_fs = gr[_REG_FS];
 			tf->tf_vm86_es = gr[_REG_ES];
 			tf->tf_vm86_ds = gr[_REG_DS];
 			set_vflags(l, gr[_REG_EFL]);
 			if (flags & _UC_VM) {
 				void syscall_vm86(struct trapframe *);
 				l->l_proc->p_md.md_syscall = syscall_vm86;
+			}
 		} else
 #endif
+		{
 			error = cpu_mcontext_validate(l, mcp);
 			if (error)
 				return error;
 			tf->tf_gs = gr[_REG_GS];
 			tf->tf_fs = gr[_REG_FS];
 			tf->tf_es = gr[_REG_ES];
 			tf->tf_ds = gr[_REG_DS];
 			/* Only change the user-alterable part of eflags */
 			tf->tf_eflags &= ~PSL_USER;
 			tf->tf_eflags |= (gr[_REG_EFL] & PSL_USER);
+		}
 		tf->tf_edi    = gr[_REG_EDI];
 		tf->tf_esi    = gr[_REG_ESI];
 		tf->tf_ebp    = gr[_REG_EBP];
 		tf->tf_ebx    = gr[_REG_EBX];
 		tf->tf_edx    = gr[_REG_EDX];
 		tf->tf_ecx    = gr[_REG_ECX];
 		tf->tf_eax    = gr[_REG_EAX];
 		tf->tf_eip    = gr[_REG_EIP];
 		tf->tf_cs     = gr[_REG_CS];
 		tf->tf_esp    = gr[_REG_UESP];
 		tf->tf_ss     = gr[_REG_SS];
+	}
 	if ((flags & _UC_TLSBASE) != 0)
 		lwp_setprivate(l, (void *)(uintptr_t)mcp->_mc_tlsbase);
 	/* Restore floating point register context, if given. */
 	if ((flags & _UC_FPU) != 0) {
 		__CTASSERT(sizeof (struct fxsave) ==
 		    sizeof mcp->__fpregs.__fp_reg_set.__fp_xmm_state);
 		__CTASSERT(sizeof (struct save87) ==
 		    sizeof mcp->__fpregs.__fp_reg_set.__fpchip_state);
 		if (flags & _UC_FXSAVE) {
 			process_write_fpregs_xmm(l, (const struct fxsave *)
 				    &mcp->__fpregs.__fp_reg_set.__fp_xmm_state);
 		} else {
 			process_write_fpregs_s87(l, (const struct save87 *)
 				    &mcp->__fpregs.__fp_reg_set.__fpchip_state);
+		}
+	}
 	mutex_enter(p->p_lock);
 	if (flags & _UC_SETSTACK)
 		l->l_sigstk.ss_flags |= SS_ONSTACK;
 	if (flags & _UC_CLRSTACK)
 		l->l_sigstk.ss_flags &= ~SS_ONSTACK;
 	mutex_exit(p->p_lock);
 	return (0);
+}
 void
 cpu_initclocks(void)
+{
 	(*initclock_func)();
+}
 #define	DEV_IO 14		/* iopl for compat_10 */
 int
 mm_md_open(dev_t dev, int flag, int mode, struct lwp *l)
+{
 	switch (minor(dev)) {
 	case DEV_IO:
 		/*
 		 * This is done by i386_iopl(3) now.
+		 *
 		 * #if defined(COMPAT_10) || defined(COMPAT_FREEBSD)
 		 */
 		if (flag & FWRITE) {
 			struct trapframe *fp;
 			int error;
 			error = kauth_authorize_machdep(l->l_cred,
 			    KAUTH_MACHDEP_IOPL, NULL, NULL, NULL, NULL);
 			if (error)
 				return (error);
 			fp = curlwp->l_md.md_regs;
 			fp->tf_eflags |= PSL_IOPL;
+		}
 		break;
 	default:
 		break;
+	}
 	return 0;
+}
 #ifdef PAE
 void
 cpu_alloc_l3_page(struct cpu_info *ci)
+{
 	int ret;
 	struct pglist pg;
 	struct vm_page *vmap;
 	KASSERT(ci != NULL);
 	/*
 	 * Allocate a page for the per-CPU L3 PD. cr3 being 32 bits, PA musts
 	 * resides below the 4GB boundary.
 	 */
 	ret = uvm_pglistalloc(PAGE_SIZE, 0, 0x100000000ULL, 32, 0, &pg, 1, 0);
 	vmap = TAILQ_FIRST(&pg);
 	if (ret != 0 || vmap == NULL)
 		panic("%s: failed to allocate L3 pglist for CPU %d (ret %d)\n",
 			__func__, cpu_index(ci), ret);
 	ci->ci_pae_l3_pdirpa = vmap->phys_addr;
 	ci->ci_pae_l3_pdir = (paddr_t *)uvm_km_alloc(kernel_map, PAGE_SIZE, 0,
 		UVM_KMF_VAONLY | UVM_KMF_NOWAIT);
 	if (ci->ci_pae_l3_pdir == NULL)
 		panic("%s: failed to allocate L3 PD for CPU %d\n",
 			__func__, cpu_index(ci));
 	pmap_kenter_pa((vaddr_t)ci->ci_pae_l3_pdir, ci->ci_pae_l3_pdirpa,
 		VM_PROT_READ | VM_PROT_WRITE, 0);
 	pmap_update(pmap_kernel());
+}
 #endif /* PAE */

 @@ -1,1173 +1,1173 @@
-/*	$NetBSD: pmap.c,v 1.194 2016/05/14 09:37:21 maxv Exp $	*/
+/*	$NetBSD: pmap.c,v 1.195 2016/05/15 10:35:54 maxv Exp $	*/
 /*-
  * Copyright (c) 2008, 2010 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.
  * 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
  */
 /*
  * Copyright (c) 2007 Manuel Bouyer.
+ *
  * 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 ``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 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.
+ *
  */
 /*
  * Copyright (c) 2006 Mathieu Ropert <mro@adviseo.fr>
+ *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
  * copyright notice and this permission notice appear in all copies.
+ *
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 /*
  * Copyright (c) 1997 Charles D. Cranor and Washington University.
  * 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 ``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 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.
  */
 /*
  * Copyright 2001 (c) Wasabi Systems, Inc.
  * All rights reserved.
+ *
  * Written by Frank van der Linden for Wasabi Systems, Inc.
+ *
  * 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 for the NetBSD Project by
  *      Wasabi Systems, Inc.
  * 4. The name of Wasabi Systems, Inc. may not be used to endorse
  *    or promote products derived from this software without specific prior
  *    written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``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 WASABI SYSTEMS, INC
  * 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.
  */
 /*
  * This is the i386 pmap modified and generalized to support x86-64
  * as well. The idea is to hide the upper N levels of the page tables
  * inside pmap_get_ptp, pmap_free_ptp and pmap_growkernel. The rest
  * is mostly untouched, except that it uses some more generalized
  * macros and interfaces.
+ *
  * This pmap has been tested on the i386 as well, and it can be easily
  * adapted to PAE.
+ *
  * fvdl@wasabisystems.com 18-Jun-2001
  */
 /*
  * pmap.c: i386 pmap module rewrite
  * Chuck Cranor <chuck@netbsd>
  * 11-Aug-97
+ *
  * history of this pmap module: in addition to my own input, i used
  *    the following references for this rewrite of the i386 pmap:
+ *
  * [1] the NetBSD i386 pmap.   this pmap appears to be based on the
  *     BSD hp300 pmap done by Mike Hibler at University of Utah.
  *     it was then ported to the i386 by William Jolitz of UUNET
  *     Technologies, Inc.   Then Charles M. Hannum of the NetBSD
  *     project fixed some bugs and provided some speed ups.
+ *
  * [2] the FreeBSD i386 pmap.   this pmap seems to be the
  *     Hibler/Jolitz pmap, as modified for FreeBSD by John S. Dyson
  *     and David Greenman.
+ *
  * [3] the Mach pmap.   this pmap, from CMU, seems to have migrated
  *     between several processors.   the VAX version was done by
  *     Avadis Tevanian, Jr., and Michael Wayne Young.    the i386
  *     version was done by Lance Berc, Mike Kupfer, Bob Baron,
  *     David Golub, and Richard Draves.    the alpha version was
  *     done by Alessandro Forin (CMU/Mach) and Chris Demetriou
  *     (NetBSD/alpha).
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: pmap.c,v 1.194 2016/05/14 09:37:21 maxv Exp $");
+__KERNEL_RCSID(0, "$NetBSD: pmap.c,v 1.195 2016/05/15 10:35:54 maxv Exp $");
 #include "opt_user_ldt.h"
 #include "opt_lockdebug.h"
 #include "opt_multiprocessor.h"
 #include "opt_xen.h"
 #if !defined(__x86_64__)
 #include "opt_kstack_dr0.h"
 #endif /* !defined(__x86_64__) */
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/proc.h>
 #include <sys/pool.h>
 #include <sys/kernel.h>
 #include <sys/atomic.h>
 #include <sys/cpu.h>
 #include <sys/intr.h>
 #include <sys/xcall.h>
 #include <sys/kcore.h>
 #include <uvm/uvm.h>
 #include <uvm/pmap/pmap_pvt.h>
 #include <dev/isa/isareg.h>
 #include <machine/specialreg.h>
 #include <machine/gdt.h>
 #include <machine/isa_machdep.h>
 #include <machine/cpuvar.h>
 #include <machine/cputypes.h>
 #include <x86/pmap.h>
 #include <x86/pmap_pv.h>
 #include <x86/i82489reg.h>
 #include <x86/i82489var.h>
 #ifdef XEN
 #include <xen/xen-public/xen.h>
 #include <xen/hypervisor.h>
 #endif
 /*
  * general info:
+ *
  *  - for an explanation of how the i386 MMU hardware works see
  *    the comments in <machine/pte.h>.
+ *
  *  - for an explanation of the general memory structure used by
  *    this pmap (including the recursive mapping), see the comments
  *    in <machine/pmap.h>.
+ *
  * this file contains the code for the "pmap module."   the module's
  * job is to manage the hardware's virtual to physical address mappings.
  * note that there are two levels of mapping in the VM system:
+ *
  *  [1] the upper layer of the VM system uses vm_map's and vm_map_entry's
  *      to map ranges of virtual address space to objects/files.  for
  *      example, the vm_map may say: "map VA 0x1000 to 0x22000 read-only
  *      to the file /bin/ls starting at offset zero."   note that
  *      the upper layer mapping is not concerned with how individual
  *      vm_pages are mapped.
+ *
  *  [2] the lower layer of the VM system (the pmap) maintains the mappings
  *      from virtual addresses.   it is concerned with which vm_page is
  *      mapped where.   for example, when you run /bin/ls and start
  *      at page 0x1000 the fault routine may lookup the correct page
  *      of the /bin/ls file and then ask the pmap layer to establish
  *      a mapping for it.
+ *
  * note that information in the lower layer of the VM system can be
  * thrown away since it can easily be reconstructed from the info
  * in the upper layer.
+ *
  * data structures we use include:
+ *
  *  - struct pmap: describes the address space of one thread
  *  - struct pmap_page: describes one pv-tracked page, without
  *	necessarily a corresponding vm_page
  *  - struct pv_entry: describes one <PMAP,VA> mapping of a PA
  *  - struct pv_head: there is one pv_head per pv-tracked page of
  *	physical memory.   the pv_head points to a list of pv_entry
  *	structures which describe all the <PMAP,VA> pairs that this
  *      page is mapped in.    this is critical for page based operations
  *      such as pmap_page_protect() [change protection on _all_ mappings
  *      of a page]
  */
 /*
  * memory allocation
+ *
  *  - there are three data structures that we must dynamically allocate:
+ *
  * [A] new process' page directory page (PDP)
  *	- plan 1: done at pmap_create() we use
  *	  uvm_km_alloc(kernel_map, PAGE_SIZE)  [fka kmem_alloc] to do this
  *	  allocation.
+ *
  * if we are low in free physical memory then we sleep in
  * uvm_km_alloc -- in this case this is ok since we are creating
  * a new pmap and should not be holding any locks.
+ *
  * if the kernel is totally out of virtual space
  * (i.e. uvm_km_alloc returns NULL), then we panic.
+ *
  * [B] new page tables pages (PTP)
  * 	- call uvm_pagealloc()
  * 		=> success: zero page, add to pm_pdir
  * 		=> failure: we are out of free vm_pages, let pmap_enter()
  *		   tell UVM about it.
+ *
  * note: for kernel PTPs, we start with NKPTP of them.   as we map
  * kernel memory (at uvm_map time) we check to see if we've grown
  * the kernel pmap.   if so, we call the optional function
  * pmap_growkernel() to grow the kernel PTPs in advance.
+ *
  * [C] pv_entry structures
  */
 /*
  * locking
+ *
  * we have the following locks that we must contend with:
+ *
  * mutexes:
+ *
  * - pmap lock (per pmap, part of uvm_object)
  *   this lock protects the fields in the pmap structure including
  *   the non-kernel PDEs in the PDP, and the PTEs.  it also locks
  *   in the alternate PTE space (since that is determined by the
  *   entry in the PDP).
+ *
  * - pvh_lock (per pv_head)
  *   this lock protects the pv_entry list which is chained off the
  *   pv_head structure for a specific pv-tracked PA.   it is locked
  *   when traversing the list (e.g. adding/removing mappings,
  *   syncing R/M bits, etc.)
+ *
  * - pmaps_lock
  *   this lock protects the list of active pmaps (headed by "pmaps").
  *   we lock it when adding or removing pmaps from this list.
  */
 const vaddr_t ptp_masks[] = PTP_MASK_INITIALIZER;
 const int ptp_shifts[] = PTP_SHIFT_INITIALIZER;
 const long nkptpmax[] = NKPTPMAX_INITIALIZER;
 const long nbpd[] = NBPD_INITIALIZER;
 pd_entry_t * const normal_pdes[] = PDES_INITIALIZER;
 long nkptp[] = NKPTP_INITIALIZER;
 struct pmap_head pmaps;
 kmutex_t pmaps_lock;
 static vaddr_t pmap_maxkvaddr;
 /*
  * XXX kludge: dummy locking to make KASSERTs in uvm_page.c comfortable.
  * actual locking is done by pm_lock.
  */
 #if defined(DIAGNOSTIC)
 #define	PMAP_SUBOBJ_LOCK(pm, idx) \
 	KASSERT(mutex_owned((pm)->pm_lock)); \
 	if ((idx) != 0) \
 		mutex_enter((pm)->pm_obj[(idx)].vmobjlock)
 #define	PMAP_SUBOBJ_UNLOCK(pm, idx) \
 	KASSERT(mutex_owned((pm)->pm_lock)); \
 	if ((idx) != 0) \
 		mutex_exit((pm)->pm_obj[(idx)].vmobjlock)
 #else /* defined(DIAGNOSTIC) */
 #define	PMAP_SUBOBJ_LOCK(pm, idx)	/* nothing */
 #define	PMAP_SUBOBJ_UNLOCK(pm, idx)	/* nothing */
 #endif /* defined(DIAGNOSTIC) */
 /*
  * Misc. event counters.
  */
 struct evcnt pmap_iobmp_evcnt;
 struct evcnt pmap_ldt_evcnt;
 /*
  * PAT
  */
 #define	PATENTRY(n, type)	(type << ((n) * 8))
 #define	PAT_UC		0x0ULL
 #define	PAT_WC		0x1ULL
 #define	PAT_WT		0x4ULL
 #define	PAT_WP		0x5ULL
 #define	PAT_WB		0x6ULL
 #define	PAT_UCMINUS	0x7ULL
 static bool cpu_pat_enabled __read_mostly = false;
 /*
  * global data structures
  */
 static struct pmap kernel_pmap_store;	/* the kernel's pmap (proc0) */
 struct pmap *const kernel_pmap_ptr = &kernel_pmap_store;
 /*
  * pmap_pg_g: if our processor supports PG_G in the PTE then we
  * set pmap_pg_g to PG_G (otherwise it is zero).
  */
 int pmap_pg_g __read_mostly = 0;
 /*
  * pmap_largepages: if our processor supports PG_PS and we are
  * using it, this is set to true.
  */
 int pmap_largepages __read_mostly;
 /*
  * i386 physical memory comes in a big contig chunk with a small
  * hole toward the front of it...  the following two paddr_t's
  * (shared with machdep.c) describe the physical address space
  * of this machine.
  */
 paddr_t avail_start __read_mostly; /* PA of first available physical page */
 paddr_t avail_end __read_mostly; /* PA of last available physical page */
 #ifdef XEN
 #ifdef __x86_64__
 /* Dummy PGD for user cr3, used between pmap_deactivate() and pmap_activate() */
 static paddr_t xen_dummy_user_pgd;
 #endif /* __x86_64__ */
 paddr_t pmap_pa_start; /* PA of first physical page for this domain */
 paddr_t pmap_pa_end;   /* PA of last physical page for this domain */
 #endif /* XEN */
 #define	VM_PAGE_TO_PP(pg)	(&(pg)->mdpage.mp_pp)
 #define	PV_HASH_SIZE		32768
 #define	PV_HASH_LOCK_CNT	32
 struct pv_hash_lock {
 	kmutex_t lock;
 } __aligned(CACHE_LINE_SIZE) pv_hash_locks[PV_HASH_LOCK_CNT]
     __aligned(CACHE_LINE_SIZE);
 struct pv_hash_head {
 	SLIST_HEAD(, pv_entry) hh_list;
 } pv_hash_heads[PV_HASH_SIZE];
 static u_int
 pvhash_hash(struct vm_page *ptp, vaddr_t va)
+{
 	return (uintptr_t)ptp / sizeof(*ptp) + (va >> PAGE_SHIFT);
+}
 static struct pv_hash_head *
 pvhash_head(u_int hash)
+{
 	return &pv_hash_heads[hash % PV_HASH_SIZE];
+}
 static kmutex_t *
 pvhash_lock(u_int hash)
+{
 	return &pv_hash_locks[hash % PV_HASH_LOCK_CNT].lock;
+}
 static struct pv_entry *
 pvhash_remove(struct pv_hash_head *hh, struct vm_page *ptp, vaddr_t va)
+{
 	struct pv_entry *pve;
 	struct pv_entry *prev;
 	prev = NULL;
 	SLIST_FOREACH(pve, &hh->hh_list, pve_hash) {
 		if (pve->pve_pte.pte_ptp == ptp &&
 		    pve->pve_pte.pte_va == va) {
 			if (prev != NULL) {
 				SLIST_REMOVE_AFTER(prev, pve_hash);
 			} else {
 				SLIST_REMOVE_HEAD(&hh->hh_list, pve_hash);
+			}
 			break;
+		}
 		prev = pve;
+	}
 	return pve;
+}
 /*
  * other data structures
  */
 static pt_entry_t protection_codes[8] __read_mostly; /* maps MI prot to i386
 							prot code */
 static bool pmap_initialized __read_mostly = false; /* pmap_init done yet? */
 /*
  * the following two vaddr_t's are used during system startup
  * to keep track of how much of the kernel's VM space we have used.
  * once the system is started, the management of the remaining kernel
  * VM space is turned over to the kernel_map vm_map.
  */
 static vaddr_t virtual_avail __read_mostly;	/* VA of first free KVA */
 static vaddr_t virtual_end __read_mostly;	/* VA of last free KVA */
 /*
  * pool that pmap structures are allocated from
  */
 static struct pool_cache pmap_cache;
 /*
  * pv_entry cache
  */
 static struct pool_cache pmap_pv_cache;
 #ifdef __HAVE_DIRECT_MAP
 extern phys_ram_seg_t mem_clusters[];
 extern int mem_cluster_cnt;
 #else
 /*
  * MULTIPROCESSOR: special VA's/ PTE's are actually allocated inside a
  * maxcpus*NPTECL array of PTE's, to avoid cache line thrashing
  * due to false sharing.
  */
 #ifdef MULTIPROCESSOR
 #define PTESLEW(pte, id) ((pte)+(id)*NPTECL)
 #define VASLEW(va,id) ((va)+(id)*NPTECL*PAGE_SIZE)
 #else
 #define PTESLEW(pte, id) ((void)id, pte)
 #define VASLEW(va,id) ((void)id, va)
 #endif
 /*
  * special VAs and the PTEs that map them
  */
 static pt_entry_t *csrc_pte, *cdst_pte, *zero_pte, *ptp_pte, *early_zero_pte;
 static char *csrcp, *cdstp, *zerop, *ptpp;
 #ifdef XEN
 char *early_zerop; /* also referenced from xen_pmap_bootstrap() */
 #else
 static char *early_zerop;
 #endif
 #endif
 int pmap_enter_default(pmap_t, vaddr_t, paddr_t, vm_prot_t, u_int);
 /* PDP pool_cache(9) and its callbacks */
 struct pool_cache pmap_pdp_cache;
 static int  pmap_pdp_ctor(void *, void *, int);
 static void pmap_pdp_dtor(void *, void *);
 #ifdef PAE
 /* need to allocate items of 4 pages */
 static void *pmap_pdp_alloc(struct pool *, int);
 static void pmap_pdp_free(struct pool *, void *);
 static struct pool_allocator pmap_pdp_allocator = {
 	.pa_alloc = pmap_pdp_alloc,
 	.pa_free = pmap_pdp_free,
 	.pa_pagesz = PAGE_SIZE * PDP_SIZE,
 };
 #endif /* PAE */
 extern vaddr_t idt_vaddr;			/* we allocate IDT early */
 extern paddr_t idt_paddr;
 #ifdef _LP64
 extern vaddr_t lo32_vaddr;
 extern vaddr_t lo32_paddr;
 #endif
 extern int end;
 #ifdef i386
 /* stuff to fix the pentium f00f bug */
 extern vaddr_t pentium_idt_vaddr;
 #endif
 /*
  * local prototypes
  */
 static struct vm_page	*pmap_get_ptp(struct pmap *, vaddr_t,
 				      pd_entry_t * const *);
 static struct vm_page	*pmap_find_ptp(struct pmap *, vaddr_t, paddr_t, int);
 static void		 pmap_freepage(struct pmap *, struct vm_page *, int);
 static void		 pmap_free_ptp(struct pmap *, struct vm_page *,
 				       vaddr_t, pt_entry_t *,
 				       pd_entry_t * const *);
 static bool		 pmap_remove_pte(struct pmap *, struct vm_page *,
 					 pt_entry_t *, vaddr_t,
 					 struct pv_entry **);
 static void		 pmap_remove_ptes(struct pmap *, struct vm_page *,
 					  vaddr_t, vaddr_t, vaddr_t,
 					  struct pv_entry **);
 static bool		 pmap_get_physpage(vaddr_t, int, paddr_t *);
 static void		 pmap_alloc_level(pd_entry_t * const *, vaddr_t, int,
 					  long *);
 static bool		 pmap_reactivate(struct pmap *);
 /*
  * p m a p   h e l p e r   f u n c t i o n s
  */
 static inline void
 pmap_stats_update(struct pmap *pmap, int resid_diff, int wired_diff)
+{
 	if (pmap == pmap_kernel()) {
 		atomic_add_long(&pmap->pm_stats.resident_count, resid_diff);
 		atomic_add_long(&pmap->pm_stats.wired_count, wired_diff);
 	} else {
 		KASSERT(mutex_owned(pmap->pm_lock));
 		pmap->pm_stats.resident_count += resid_diff;
 		pmap->pm_stats.wired_count += wired_diff;
+	}
+}
 static inline void
 pmap_stats_update_bypte(struct pmap *pmap, pt_entry_t npte, pt_entry_t opte)
+{
 	int resid_diff = ((npte & PG_V) ? 1 : 0) - ((opte & PG_V) ? 1 : 0);
 	int wired_diff = ((npte & PG_W) ? 1 : 0) - ((opte & PG_W) ? 1 : 0);
 	KASSERT((npte & (PG_V | PG_W)) != PG_W);
 	KASSERT((opte & (PG_V | PG_W)) != PG_W);
 	pmap_stats_update(pmap, resid_diff, wired_diff);
+}
 /*
  * ptp_to_pmap: lookup pmap by ptp
  */
 static struct pmap *
 ptp_to_pmap(struct vm_page *ptp)
+{
 	struct pmap *pmap;
 	if (ptp == NULL) {
 		return pmap_kernel();
+	}
 	pmap = (struct pmap *)ptp->uobject;
 	KASSERT(pmap != NULL);
 	KASSERT(&pmap->pm_obj[0] == ptp->uobject);
 	return pmap;
+}
 static inline struct pv_pte *
 pve_to_pvpte(struct pv_entry *pve)
+{
 	KASSERT((void *)&pve->pve_pte == (void *)pve);
 	return &pve->pve_pte;
+}
 static inline struct pv_entry *
 pvpte_to_pve(struct pv_pte *pvpte)
+{
 	struct pv_entry *pve = (void *)pvpte;
 	KASSERT(pve_to_pvpte(pve) == pvpte);
 	return pve;
+}
 /*
  * pv_pte_first, pv_pte_next: PV list iterator.
  */
 static struct pv_pte *
 pv_pte_first(struct pmap_page *pp)
+{
 	if ((pp->pp_flags & PP_EMBEDDED) != 0) {
 		return &pp->pp_pte;
+	}
 	return pve_to_pvpte(LIST_FIRST(&pp->pp_head.pvh_list));
+}
 static struct pv_pte *
 pv_pte_next(struct pmap_page *pp, struct pv_pte *pvpte)
+{
 	KASSERT(pvpte != NULL);
 	if (pvpte == &pp->pp_pte) {
 		KASSERT((pp->pp_flags & PP_EMBEDDED) != 0);
 		return NULL;
+	}
 	KASSERT((pp->pp_flags & PP_EMBEDDED) == 0);
 	return pve_to_pvpte(LIST_NEXT(pvpte_to_pve(pvpte), pve_list));
+}
 /*
  * pmap_is_curpmap: is this pmap the one currently loaded [in %cr3]?
  *		of course the kernel is always loaded
  */
 bool
 pmap_is_curpmap(struct pmap *pmap)
+{
 	return((pmap == pmap_kernel()) ||
 	       (pmap == curcpu()->ci_pmap));
+}
 /*
  *	Add a reference to the specified pmap.
  */
 void
 pmap_reference(struct pmap *pmap)
+{
 	atomic_inc_uint(&pmap->pm_obj[0].uo_refs);
+}
 /*
  * pmap_map_ptes: map a pmap's PTEs into KVM and lock them in
+ *
  * there are several pmaps involved.  some or all of them might be same.
+ *
  *	- the pmap given by the first argument
  *		our caller wants to access this pmap's PTEs.
+ *
  *	- pmap_kernel()
  *		the kernel pmap.  note that it only contains the kernel part
  *		of the address space which is shared by any pmap.  ie. any
  *		pmap can be used instead of pmap_kernel() for our purpose.
+ *
  *	- ci->ci_pmap
  *		pmap currently loaded on the cpu.
+ *
  *	- vm_map_pmap(&curproc->p_vmspace->vm_map)
  *		current process' pmap.
+ *
  * => we lock enough pmaps to keep things locked in
  * => must be undone with pmap_unmap_ptes before returning
  */
 void
 pmap_map_ptes(struct pmap *pmap, struct pmap **pmap2,
 	      pd_entry_t **ptepp, pd_entry_t * const **pdeppp)
+{
 	struct pmap *curpmap;
 	struct cpu_info *ci;
 	lwp_t *l;
 	/* The kernel's pmap is always accessible. */
 	if (pmap == pmap_kernel()) {
 		*pmap2 = NULL;
 		*ptepp = PTE_BASE;
 		*pdeppp = normal_pdes;
 		return;
+	}
 	KASSERT(kpreempt_disabled());
 	l = curlwp;
  retry:
 	mutex_enter(pmap->pm_lock);
 	ci = curcpu();
 	curpmap = ci->ci_pmap;
 	if (vm_map_pmap(&l->l_proc->p_vmspace->vm_map) == pmap) {
 		/* Our own pmap so just load it: easy. */
 		if (__predict_false(ci->ci_want_pmapload)) {
 			mutex_exit(pmap->pm_lock);
 			pmap_load();
 			goto retry;
+		}
 		KASSERT(pmap == curpmap);
 	} else if (pmap == curpmap) {
 		/*
 		 * Already on the CPU: make it valid.  This is very
 		 * often the case during exit(), when we have switched
 		 * to the kernel pmap in order to destroy a user pmap.
 		 */
 		if (!pmap_reactivate(pmap)) {
 			u_int gen = uvm_emap_gen_return();
 			tlbflush();
 			uvm_emap_update(gen);
+		}
 	} else {
 		/*
 		 * Toss current pmap from CPU, but keep a reference to it.
 		 * The reference will be dropped by pmap_unmap_ptes().
 		 * Can happen if we block during exit().
 		 */
 		const cpuid_t cid = cpu_index(ci);
 		kcpuset_atomic_clear(curpmap->pm_cpus, cid);
 		kcpuset_atomic_clear(curpmap->pm_kernel_cpus, cid);
 		ci->ci_pmap = pmap;
 		ci->ci_tlbstate = TLBSTATE_VALID;
 		kcpuset_atomic_set(pmap->pm_cpus, cid);
 		kcpuset_atomic_set(pmap->pm_kernel_cpus, cid);
 		cpu_load_pmap(pmap, curpmap);
+	}
 	pmap->pm_ncsw = l->l_ncsw;
 	*pmap2 = curpmap;
 	*ptepp = PTE_BASE;
 #if defined(XEN) && defined(__x86_64__)
 	KASSERT(ci->ci_normal_pdes[PTP_LEVELS - 2] == L4_BASE);
 	ci->ci_normal_pdes[PTP_LEVELS - 2] = pmap->pm_pdir;
 	*pdeppp = ci->ci_normal_pdes;
 #else /* XEN && __x86_64__ */
 	*pdeppp = normal_pdes;
 #endif /* XEN && __x86_64__ */
+}
 /*
  * pmap_unmap_ptes: unlock the PTE mapping of "pmap"
  */
 void
 pmap_unmap_ptes(struct pmap *pmap, struct pmap *pmap2)
+{
 	struct cpu_info *ci;
 	struct pmap *mypmap;
 	KASSERT(kpreempt_disabled());
 	/* The kernel's pmap is always accessible. */
 	if (pmap == pmap_kernel()) {
 		return;
+	}
 	ci = curcpu();
 #if defined(XEN) && defined(__x86_64__)
 	/* Reset per-cpu normal_pdes */
 	KASSERT(ci->ci_normal_pdes[PTP_LEVELS - 2] != L4_BASE);
 	ci->ci_normal_pdes[PTP_LEVELS - 2] = L4_BASE;
 #endif /* XEN && __x86_64__ */
 	/*
 	 * We cannot tolerate context switches while mapped in.
 	 * If it is our own pmap all we have to do is unlock.
 	 */
 	KASSERT(pmap->pm_ncsw == curlwp->l_ncsw);
 	mypmap = vm_map_pmap(&curproc->p_vmspace->vm_map);
 	if (pmap == mypmap) {
 		mutex_exit(pmap->pm_lock);
 		return;
+	}
 	/*
 	 * Mark whatever's on the CPU now as lazy and unlock.
 	 * If the pmap was already installed, we are done.
 	 */
 	ci->ci_tlbstate = TLBSTATE_LAZY;
 	ci->ci_want_pmapload = (mypmap != pmap_kernel());
 	mutex_exit(pmap->pm_lock);
 	if (pmap == pmap2) {
 		return;
+	}
 	/*
 	 * We installed another pmap on the CPU.  Grab a reference to
 	 * it and leave in place.  Toss the evicted pmap (can block).
 	 */
 	pmap_reference(pmap);
 	pmap_destroy(pmap2);
+}
 inline static void
 pmap_exec_account(struct pmap *pm, vaddr_t va, pt_entry_t opte, pt_entry_t npte)
+{
 #if !defined(__x86_64__)
 	if (curproc == NULL || curproc->p_vmspace == NULL ||
 	    pm != vm_map_pmap(&curproc->p_vmspace->vm_map))
 		return;
 	if ((opte ^ npte) & PG_X)
 		pmap_update_pg(va);
 	/*
 	 * Executability was removed on the last executable change.
 	 * Reset the code segment to something conservative and
 	 * let the trap handler deal with setting the right limit.
 	 * We can't do that because of locking constraints on the vm map.
 	 */
 	if ((opte & PG_X) && (npte & PG_X) == 0 && va == pm->pm_hiexec) {
 		struct trapframe *tf = curlwp->l_md.md_regs;
 		tf->tf_cs = GSEL(GUCODE_SEL, SEL_UPL);
 		pm->pm_hiexec = I386_MAX_EXE_ADDR;
+	}
 #endif /* !defined(__x86_64__) */
+}
 #if !defined(__x86_64__)
 /*
  * Fixup the code segment to cover all potential executable mappings.
  * returns 0 if no changes to the code segment were made.
  */
 int
 pmap_exec_fixup(struct vm_map *map, struct trapframe *tf, struct pcb *pcb)
+{
 	struct vm_map_entry *ent;
 	struct pmap *pm = vm_map_pmap(map);
 	vaddr_t va = 0;
 	vm_map_lock_read(map);
 	for (ent = (&map->header)->next; ent != &map->header; ent = ent->next) {
 		/*
 		 * This entry has greater va than the entries before.
 		 * We need to make it point to the last page, not past it.
 		 */
 		if (ent->protection & VM_PROT_EXECUTE)
 			va = trunc_page(ent->end) - PAGE_SIZE;
+	}
 	vm_map_unlock_read(map);
 	if (va == pm->pm_hiexec && tf->tf_cs == GSEL(GUCODEBIG_SEL, SEL_UPL))
 		return (0);
 	pm->pm_hiexec = va;
 	if (pm->pm_hiexec > I386_MAX_EXE_ADDR) {
 		tf->tf_cs = GSEL(GUCODEBIG_SEL, SEL_UPL);
 	} else {
 		tf->tf_cs = GSEL(GUCODE_SEL, SEL_UPL);
 		return (0);
+	}
 	return (1);
+}
 #endif /* !defined(__x86_64__) */
 void
 pat_init(struct cpu_info *ci)
+{
 	uint64_t pat;
 	if (!(ci->ci_feat_val[0] & CPUID_PAT))
 		return;
 	/* We change WT to WC. Leave all other entries the default values. */
 	pat = PATENTRY(0, PAT_WB) | PATENTRY(1, PAT_WC) |
 	      PATENTRY(2, PAT_UCMINUS) | PATENTRY(3, PAT_UC) |
 	      PATENTRY(4, PAT_WB) | PATENTRY(5, PAT_WC) |
 	      PATENTRY(6, PAT_UCMINUS) | PATENTRY(7, PAT_UC);
 	wrmsr(MSR_CR_PAT, pat);
 	cpu_pat_enabled = true;
 	aprint_debug_dev(ci->ci_dev, "PAT enabled\n");
+}
 static pt_entry_t
 pmap_pat_flags(u_int flags)
+{
 	u_int cacheflags = (flags & PMAP_CACHE_MASK);
 	if (!cpu_pat_enabled) {
 		switch (cacheflags) {
 		case PMAP_NOCACHE:
 		case PMAP_NOCACHE_OVR:
 			/* results in PGC_UCMINUS on cpus which have
 			 * the cpuid PAT but PAT "disabled"
 			 */
 			return PG_N;
 		default:
 			return 0;
+		}
+	}
 	switch (cacheflags) {
 	case PMAP_NOCACHE:
 		return PGC_UC;
 	case PMAP_WRITE_COMBINE:
 		return PGC_WC;
 	case PMAP_WRITE_BACK:
 		return PGC_WB;
 	case PMAP_NOCACHE_OVR:
 		return PGC_UCMINUS;
+	}
 	return 0;
+}
 /*
  * p m a p   k e n t e r   f u n c t i o n s
+ *
  * functions to quickly enter/remove pages from the kernel address
  * space.   pmap_kremove is exported to MI kernel.  we make use of
  * the recursive PTE mappings.
  */
 /*
  * pmap_kenter_pa: enter a kernel mapping without R/M (pv_entry) tracking
+ *
  * => no need to lock anything, assume va is already allocated
  * => should be faster than normal pmap enter function
  */
 void
 pmap_kenter_pa(vaddr_t va, paddr_t pa, vm_prot_t prot, u_int flags)
+{
 	pt_entry_t *pte, opte, npte;
 	KASSERT(!(prot & ~VM_PROT_ALL));
 	if (va < VM_MIN_KERNEL_ADDRESS)
 		pte = vtopte(va);
 	else
 		pte = kvtopte(va);
 #ifdef DOM0OPS
 	if (pa < pmap_pa_start || pa >= pmap_pa_end) {
 #ifdef DEBUG
 		printf_nolog("%s: pa 0x%" PRIx64 " for va 0x%" PRIx64
 		    " outside range\n", __func__, (int64_t)pa, (int64_t)va);
 #endif /* DEBUG */
 		npte = pa;
 	} else
 #endif /* DOM0OPS */
 		npte = pmap_pa2pte(pa);
 	npte |= protection_codes[prot] | PG_k | PG_V | pmap_pg_g;
 	npte |= pmap_pat_flags(flags);
 	opte = pmap_pte_testset(pte, npte); /* zap! */
 #if defined(DIAGNOSTIC)
 	/* XXX For now... */
 	if (opte & PG_PS)
 		panic("%s: PG_PS", __func__);
 #endif
 	if ((opte & (PG_V | PG_U)) == (PG_V | PG_U)) {
 		/* This should not happen. */
 		printf_nolog("%s: mapping already present\n", __func__);
 		kpreempt_disable();
 		pmap_tlb_shootdown(pmap_kernel(), va, opte, TLBSHOOT_KENTER);
 		kpreempt_enable();
+	}
+}
 void
 pmap_emap_enter(vaddr_t va, paddr_t pa, vm_prot_t prot)
+{
 	pt_entry_t *pte, npte;
 	KASSERT((prot & ~VM_PROT_ALL) == 0);
 	pte = (va < VM_MIN_KERNEL_ADDRESS) ? vtopte(va) : kvtopte(va);
 #ifdef DOM0OPS
 	if (pa < pmap_pa_start || pa >= pmap_pa_end) {
 		npte = pa;
 	} else
 #endif
 		npte = pmap_pa2pte(pa);
 	npte = pmap_pa2pte(pa);
 	npte |= protection_codes[prot] | PG_k | PG_V;
 	pmap_pte_set(pte, npte);
+}
 /*
  * pmap_emap_sync: perform TLB flush or pmap load, if it was deferred.
  */
 void
 pmap_emap_sync(bool canload)
+{
 	struct cpu_info *ci = curcpu();
 	struct pmap *pmap;
 	KASSERT(kpreempt_disabled());
 	if (__predict_true(ci->ci_want_pmapload && canload)) {
 		/*
 		 * XXX: Hint for pmap_reactivate(), which might suggest to
 		 * not perform TLB flush, if state has not changed.
 		 */
 		pmap = vm_map_pmap(&curlwp->l_proc->p_vmspace->vm_map);
 		if (__predict_false(pmap == ci->ci_pmap)) {
 			kcpuset_atomic_clear(pmap->pm_cpus, cpu_index(ci));
+		}
 		pmap_load();
 		KASSERT(ci->ci_want_pmapload == 0);
 	} else {
 		tlbflush();
+	}
+}
 void
 pmap_emap_remove(vaddr_t sva, vsize_t len)
+{
 	pt_entry_t *pte;
 	vaddr_t va, eva = sva + len;
 	for (va = sva; va < eva; va += PAGE_SIZE) {
 		pte = (va < VM_MIN_KERNEL_ADDRESS) ? vtopte(va) : kvtopte(va);
 		pmap_pte_set(pte, 0);
+	}
+}
 __strict_weak_alias(pmap_kenter_ma, pmap_kenter_pa);
 #if defined(__x86_64__)
 /*
  * Change protection for a virtual address. Local for a CPU only, don't
  * care about TLB shootdowns.
+ *
  * => must be called with preemption disabled
  */
 void
 pmap_changeprot_local(vaddr_t va, vm_prot_t prot)
+{
 	pt_entry_t *pte, opte, npte;
 	KASSERT(kpreempt_disabled());
 	if (va < VM_MIN_KERNEL_ADDRESS)
 		pte = vtopte(va);
 	else
 		pte = kvtopte(va);
 	npte = opte = *pte;
 	if ((prot & VM_PROT_WRITE) != 0)
 		npte |= PG_RW;
 	else
 		npte &= ~PG_RW;
 	if (opte != npte) {
 		pmap_pte_set(pte, npte);
 		pmap_pte_flush();
 		invlpg(va);
+	}
+}
 #endif /* defined(__x86_64__) */
 /*
  * pmap_kremove: remove a kernel mapping(s) without R/M (pv_entry) tracking
+ *
  * => no need to lock anything
  * => caller must dispose of any vm_page mapped in the va range
  * => note: not an inline function
  * => we assume the va is page aligned and the len is a multiple of PAGE_SIZE
  * => we assume kernel only unmaps valid addresses and thus don't bother
  *    checking the valid bit before doing TLB flushing
  * => must be followed by call to pmap_update() before reuse of page
  */
 static inline void
 pmap_kremove1(vaddr_t sva, vsize_t len, bool localonly)
+{
 	pt_entry_t *pte, opte;
 	vaddr_t va, eva;
 	eva = sva + len;
 	kpreempt_disable();
 	for (va = sva; va < eva; va += PAGE_SIZE) {
 		pte = kvtopte(va);
 		opte = pmap_pte_testset(pte, 0); /* zap! */
 		if ((opte & (PG_V | PG_U)) == (PG_V | PG_U) && !localonly) {
 			pmap_tlb_shootdown(pmap_kernel(), va, opte,
 			    TLBSHOOT_KREMOVE);
+		}
 		KASSERT((opte & PG_PS) == 0);
 		KASSERT((opte & PG_PVLIST) == 0);
+	}
 	if (localonly) {
 		tlbflushg();
+	}
 	kpreempt_enable();
+}
 void
 pmap_kremove(vaddr_t sva, vsize_t len)
+{
 	pmap_kremove1(sva, len, false);
+}
 /*
  * pmap_kremove_local: like pmap_kremove(), but only worry about
  * TLB invalidations on the current CPU.  this is only intended
  * for use while writing kernel crash dumps.
  */
 void
 pmap_kremove_local(vaddr_t sva, vsize_t len)
+{
 	KASSERT(panicstr != NULL);
 	pmap_kremove1(sva, len, true);
+}
 /*
  * p m a p   i n i t   f u n c t i o n s
+ *
  * pmap_bootstrap and pmap_init are called during system startup
 @@ -3535,1081 +3535,1081 @@ pmap_sync_pv(struct pv_pte *pvpte, pt_en
 		/*
 		 * check if there's anything to do on this pte.
 		 */
 		if ((opte & clearbits) == 0) {
 			need_shootdown = false;
 			break;
+		}
 		/*
 		 * we need a shootdown if the pte is cached. (PG_U)
+		 *
 		 * ...unless we are clearing only the PG_RW bit and
 		 * it isn't cached as RW. (PG_M)
 		 */
 		need_shootdown = (opte & PG_U) != 0 &&
 		    !(clearbits == PG_RW && (opte & PG_M) == 0);
 		npte = opte & ~clearbits;
 		/*
 		 * if we need a shootdown anyway, clear PG_U and PG_M.
 		 */
 		if (need_shootdown) {
 			npte &= ~(PG_U | PG_M);
+		}
 		KASSERT((npte & (PG_M | PG_U)) != PG_M);
 		KASSERT((npte & (PG_U | PG_V)) != PG_U);
 		KASSERT(npte == 0 || (opte & PG_V) != 0);
 	} while (pmap_pte_cas(ptep, opte, npte) != opte);
 	if (need_shootdown) {
 		pmap_tlb_shootdown(pmap, va, opte, TLBSHOOT_SYNC_PV2);
+	}
 	pmap_unmap_pte();
 	*optep = opte;
 	return 0;
+}
 static void
 pmap_pp_remove(struct pmap_page *pp, paddr_t pa)
+{
 	struct pv_pte *pvpte;
 	struct pv_entry *killlist = NULL;
 	struct vm_page *ptp;
 	pt_entry_t expect;
 	int count;
 	expect = pmap_pa2pte(pa) | PG_V;
 	count = SPINLOCK_BACKOFF_MIN;
 	kpreempt_disable();
 startover:
 	while ((pvpte = pv_pte_first(pp)) != NULL) {
 		struct pmap *pmap;
 		struct pv_entry *pve;
 		pt_entry_t opte;
 		vaddr_t va;
 		int error;
 		/*
 		 * add a reference to the pmap before clearing the pte.
 		 * otherwise the pmap can disappear behind us.
 		 */
 		ptp = pvpte->pte_ptp;
 		pmap = ptp_to_pmap(ptp);
 		if (ptp != NULL) {
 			pmap_reference(pmap);
+		}
 		error = pmap_sync_pv(pvpte, expect, ~0, &opte);
 		if (error == EAGAIN) {
 			int hold_count;
 			KERNEL_UNLOCK_ALL(curlwp, &hold_count);
 			if (ptp != NULL) {
 				pmap_destroy(pmap);
+			}
 			SPINLOCK_BACKOFF(count);
 			KERNEL_LOCK(hold_count, curlwp);
 			goto startover;
+		}
 		pp->pp_attrs |= opte;
 		va = pvpte->pte_va;
 		pve = pmap_remove_pv(pp, ptp, va);
 		/* update the PTP reference count.  free if last reference. */
 		if (ptp != NULL) {
 			struct pmap *pmap2;
 			pt_entry_t *ptes;
 			pd_entry_t * const *pdes;
 			KASSERT(pmap != pmap_kernel());
 			pmap_tlb_shootnow();
 			pmap_map_ptes(pmap, &pmap2, &ptes, &pdes);
 			pmap_stats_update_bypte(pmap, 0, opte);
 			ptp->wire_count--;
 			if (ptp->wire_count <= 1) {
 				pmap_free_ptp(pmap, ptp, va, ptes, pdes);
+			}
 			pmap_unmap_ptes(pmap, pmap2);
 			pmap_destroy(pmap);
 		} else {
 			KASSERT(pmap == pmap_kernel());
 			pmap_stats_update_bypte(pmap, 0, opte);
+		}
 		if (pve != NULL) {
 			pve->pve_next = killlist;	/* mark it for death */
 			killlist = pve;
+		}
+	}
 	pmap_tlb_shootnow();
 	kpreempt_enable();
 	/* Now free unused pvs. */
 	pmap_free_pvs(killlist);
+}
 /*
  * pmap_page_remove: remove a managed vm_page from all pmaps that map it
+ *
  * => R/M bits are sync'd back to attrs
  */
 void
 pmap_page_remove(struct vm_page *pg)
+{
 	struct pmap_page *pp;
 	paddr_t pa;
 	KASSERT(uvm_page_locked_p(pg));
 	pp = VM_PAGE_TO_PP(pg);
 	pa = VM_PAGE_TO_PHYS(pg);
 	pmap_pp_remove(pp, pa);
+}
 /*
  * pmap_pv_remove: remove an unmanaged pv-tracked page from all pmaps
  *	that map it
  */
 void
 pmap_pv_remove(paddr_t pa)
+{
 	struct pmap_page *pp;
 	pp = pmap_pv_tracked(pa);
 	if (pp == NULL)
 		panic("pmap_pv_protect: page not pv-tracked: 0x%"PRIxPADDR,
 		    pa);
 	pmap_pp_remove(pp, pa);
+}
 /*
  * p m a p   a t t r i b u t e  f u n c t i o n s
  * functions that test/change managed page's attributes
  * since a page can be mapped multiple times we must check each PTE that
  * maps it by going down the pv lists.
  */
 /*
  * pmap_test_attrs: test a page's attributes
  */
 bool
 pmap_test_attrs(struct vm_page *pg, unsigned testbits)
+{
 	struct pmap_page *pp;
 	struct pv_pte *pvpte;
 	pt_entry_t expect;
 	u_int result;
 	KASSERT(uvm_page_locked_p(pg));
 	pp = VM_PAGE_TO_PP(pg);
 	if ((pp->pp_attrs & testbits) != 0) {
 		return true;
+	}
 	expect = pmap_pa2pte(VM_PAGE_TO_PHYS(pg)) | PG_V;
 	kpreempt_disable();
 	for (pvpte = pv_pte_first(pp); pvpte; pvpte = pv_pte_next(pp, pvpte)) {
 		pt_entry_t opte;
 		int error;
 		if ((pp->pp_attrs & testbits) != 0) {
 			break;
+		}
 		error = pmap_sync_pv(pvpte, expect, 0, &opte);
 		if (error == 0) {
 			pp->pp_attrs |= opte;
+		}
+	}
 	result = pp->pp_attrs & testbits;
 	kpreempt_enable();
 	/*
 	 * note that we will exit the for loop with a non-null pve if
 	 * we have found the bits we are testing for.
 	 */
 	return result != 0;
+}
 static bool
 pmap_pp_clear_attrs(struct pmap_page *pp, paddr_t pa, unsigned clearbits)
+{
 	struct pv_pte *pvpte;
 	u_int result;
 	pt_entry_t expect;
 	int count;
 	expect = pmap_pa2pte(pa) | PG_V;
 	count = SPINLOCK_BACKOFF_MIN;
 	kpreempt_disable();
 startover:
 	for (pvpte = pv_pte_first(pp); pvpte; pvpte = pv_pte_next(pp, pvpte)) {
 		pt_entry_t opte;
 		int error;
 		error = pmap_sync_pv(pvpte, expect, clearbits, &opte);
 		if (error == EAGAIN) {
 			int hold_count;
 			KERNEL_UNLOCK_ALL(curlwp, &hold_count);
 			SPINLOCK_BACKOFF(count);
 			KERNEL_LOCK(hold_count, curlwp);
 			goto startover;
+		}
 		pp->pp_attrs |= opte;
+	}
 	result = pp->pp_attrs & clearbits;
 	pp->pp_attrs &= ~clearbits;
 	pmap_tlb_shootnow();
 	kpreempt_enable();
 	return result != 0;
+}
 /*
  * pmap_clear_attrs: clear the specified attribute for a page.
+ *
  * => we return true if we cleared one of the bits we were asked to
  */
 bool
 pmap_clear_attrs(struct vm_page *pg, unsigned clearbits)
+{
 	struct pmap_page *pp;
 	paddr_t pa;
 	KASSERT(uvm_page_locked_p(pg));
 	pp = VM_PAGE_TO_PP(pg);
 	pa = VM_PAGE_TO_PHYS(pg);
 	return pmap_pp_clear_attrs(pp, pa, clearbits);
+}
 /*
  * pmap_pv_clear_attrs: clear the specified attributes for an unmanaged
  *	pv-tracked page.
  */
 bool
 pmap_pv_clear_attrs(paddr_t pa, unsigned clearbits)
+{
 	struct pmap_page *pp;
 	pp = pmap_pv_tracked(pa);
 	if (pp == NULL)
 		panic("pmap_pv_protect: page not pv-tracked: 0x%"PRIxPADDR,
 		    pa);
 	return pmap_pp_clear_attrs(pp, pa, clearbits);
+}
 /*
  * p m a p   p r o t e c t i o n   f u n c t i o n s
  */
 /*
  * pmap_page_protect: change the protection of all recorded mappings
  *	of a managed page
+ *
  * => NOTE: this is an inline function in pmap.h
  */
 /* see pmap.h */
 /*
  * pmap_pv_protect: change the protection of all recorded mappings
  *	of an unmanaged pv-tracked page
+ *
  * => NOTE: this is an inline function in pmap.h
  */
 /* see pmap.h */
 /*
  * pmap_protect: set the protection in of the pages in a pmap
+ *
  * => NOTE: this is an inline function in pmap.h
  */
 /* see pmap.h */
 /*
  * pmap_write_protect: write-protect pages in a pmap.
  */
 void
 pmap_write_protect(struct pmap *pmap, vaddr_t sva, vaddr_t eva, vm_prot_t prot)
+{
 	pt_entry_t *ptes;
 	pt_entry_t * const *pdes;
 	struct pmap *pmap2;
 	vaddr_t blockend, va;
 	KASSERT(curlwp->l_md.md_gc_pmap != pmap);
 	sva &= PG_FRAME;
 	eva &= PG_FRAME;
 	/* Acquire pmap. */
 	kpreempt_disable();
 	pmap_map_ptes(pmap, &pmap2, &ptes, &pdes);
 	for (va = sva ; va < eva ; va = blockend) {
 		pt_entry_t *spte, *epte;
 		int i;
 		blockend = x86_round_pdr(va + 1);
 		if (blockend > eva)
 			blockend = eva;
 		/*
 		 * XXXCDC: our PTE mappings should never be write-protected!
+		 *
 		 * long term solution is to move the PTEs out of user
 		 * address space.  and into kernel address space (up
 		 * with APTE).  then we can set VM_MAXUSER_ADDRESS to
 		 * be VM_MAX_ADDRESS.
 		 */
 		/* XXXCDC: ugly hack to avoid freeing PDP here */
 		for (i = 0; i < PDP_SIZE; i++) {
 			if (pl_i(va, PTP_LEVELS) == PDIR_SLOT_PTE+i)
 				continue;
+		}
 		/* Is it a valid block? */
 		if (!pmap_pdes_valid(va, pdes, NULL)) {
 			continue;
+		}
 		KASSERT(va < VM_MAXUSER_ADDRESS || va >= VM_MAX_ADDRESS);
 		spte = &ptes[pl1_i(va)];
 		epte = &ptes[pl1_i(blockend)];
 		for (/*null */; spte < epte ; spte++) {
 			pt_entry_t opte, npte;
 			do {
 				opte = *spte;
 				if ((~opte & (PG_RW | PG_V)) != 0) {
 					goto next;
+				}
 				npte = opte & ~PG_RW;
 			} while (pmap_pte_cas(spte, opte, npte) != opte);
 			if ((opte & PG_M) != 0) {
 				vaddr_t tva = x86_ptob(spte - ptes);
 				pmap_tlb_shootdown(pmap, tva, opte,
 				    TLBSHOOT_WRITE_PROTECT);
+			}
 next:;
+		}
+	}
 	/* Release pmap. */
 	pmap_unmap_ptes(pmap, pmap2);
 	kpreempt_enable();
+}
 /*
  * pmap_unwire: clear the wired bit in the PTE.
+ *
  * => Mapping should already be present.
  */
 void
 pmap_unwire(struct pmap *pmap, vaddr_t va)
+{
 	pt_entry_t *ptes, *ptep, opte;
 	pd_entry_t * const *pdes;
 	struct pmap *pmap2;
 	/* Acquire pmap. */
 	kpreempt_disable();
 	pmap_map_ptes(pmap, &pmap2, &ptes, &pdes);
 	if (!pmap_pdes_valid(va, pdes, NULL)) {
 		panic("pmap_unwire: invalid PDE");
+	}
 	ptep = &ptes[pl1_i(va)];
 	opte = *ptep;
 	KASSERT(pmap_valid_entry(opte));
 	if (opte & PG_W) {
 		pt_entry_t npte = opte & ~PG_W;
 		opte = pmap_pte_testset(ptep, npte);
 		pmap_stats_update_bypte(pmap, npte, opte);
 	} else {
 		printf("pmap_unwire: wiring for pmap %p va 0x%lx "
 		    "did not change!\n", pmap, va);
+	}
 	/* Release pmap. */
 	pmap_unmap_ptes(pmap, pmap2);
 	kpreempt_enable();
+}
 /*
  * pmap_copy: copy mappings from one pmap to another
+ *
  * => optional function
  * void pmap_copy(dst_pmap, src_pmap, dst_addr, len, src_addr)
  */
 /*
  * defined as macro in pmap.h
  */
 __strict_weak_alias(pmap_enter, pmap_enter_default);
 int
 pmap_enter_default(pmap_t pmap, vaddr_t va, paddr_t pa, vm_prot_t prot,
     u_int flags)
+{
 	return pmap_enter_ma(pmap, va, pa, pa, prot, flags, 0);
+}
 /*
  * pmap_enter: enter a mapping into a pmap
+ *
  * => must be done "now" ... no lazy-evaluation
  * => we set pmap => pv_head locking
  */
 int
 pmap_enter_ma(struct pmap *pmap, vaddr_t va, paddr_t ma, paddr_t pa,
 	   vm_prot_t prot, u_int flags, int domid)
+{
 	pt_entry_t *ptes, opte, npte;
 	pt_entry_t *ptep;
 	pd_entry_t * const *pdes;
 	struct vm_page *ptp;
 	struct vm_page *new_pg, *old_pg;
 	struct pmap_page *new_pp, *old_pp;
 	struct pv_entry *old_pve = NULL;
 	struct pv_entry *new_pve;
 	struct pv_entry *new_pve2;
 	int error;
 	bool wired = (flags & PMAP_WIRED) != 0;
 	struct pmap *pmap2;
 	KASSERT(pmap_initialized);
 	KASSERT(curlwp->l_md.md_gc_pmap != pmap);
 	KASSERT(va < VM_MAX_KERNEL_ADDRESS);
 	KASSERTMSG(va != (vaddr_t)PDP_BASE,
 	    "pmap_enter: trying to map over PDP!");
 	KASSERTMSG(va < VM_MIN_KERNEL_ADDRESS ||
 	    pmap_valid_entry(pmap->pm_pdir[pl_i(va, PTP_LEVELS)]),
 	    "pmap_enter: missing kernel PTP for VA %lx!", va);
 #ifdef XEN
 	KASSERT(domid == DOMID_SELF || pa == 0);
 #endif /* XEN */
 	npte = ma | protection_codes[prot] | PG_V;
 	npte |= pmap_pat_flags(flags);
 	if (wired)
 	        npte |= PG_W;
 	if (va < VM_MAXUSER_ADDRESS)
 		npte |= PG_u;
 	else if (va < VM_MAX_ADDRESS)
 		npte |= (PG_u | PG_RW);	/* XXXCDC: no longer needed? */
 	else
 		npte |= PG_k;
 	if (pmap == pmap_kernel())
 		npte |= pmap_pg_g;
 	if (flags & VM_PROT_ALL) {
 		npte |= PG_U;
 		if (flags & VM_PROT_WRITE) {
 			KASSERT((npte & PG_RW) != 0);
 			npte |= PG_M;
+		}
+	}
 #ifdef XEN
 	if (domid != DOMID_SELF)
 		new_pg = NULL;
 	else
 #endif
 		new_pg = PHYS_TO_VM_PAGE(pa);
 	if (new_pg != NULL) {
 		/* This is a managed page */
 		npte |= PG_PVLIST;
 		new_pp = VM_PAGE_TO_PP(new_pg);
 	} else if ((new_pp = pmap_pv_tracked(pa)) != NULL) {
 		/* This is an unmanaged pv-tracked page */
 		npte |= PG_PVLIST;
 	} else {
 		new_pp = NULL;
+	}
 	/* get pves. */
 	new_pve = pool_cache_get(&pmap_pv_cache, PR_NOWAIT);
 	new_pve2 = pool_cache_get(&pmap_pv_cache, PR_NOWAIT);
 	if (new_pve == NULL || new_pve2 == NULL) {
 		if (flags & PMAP_CANFAIL) {
 			error = ENOMEM;
 			goto out2;
+		}
 		panic("pmap_enter: pve allocation failed");
+	}
 	kpreempt_disable();
 	pmap_map_ptes(pmap, &pmap2, &ptes, &pdes);	/* locks pmap */
 	if (pmap == pmap_kernel()) {
 		ptp = NULL;
 	} else {
 		ptp = pmap_get_ptp(pmap, va, pdes);
 		if (ptp == NULL) {
 			pmap_unmap_ptes(pmap, pmap2);
 			if (flags & PMAP_CANFAIL) {
 				error = ENOMEM;
 				goto out;
+			}
 			panic("pmap_enter: get ptp failed");
+		}
+	}
 	/*
 	 * update the pte.
 	 */
 	ptep = &ptes[pl1_i(va)];
 	do {
 		opte = *ptep;
 		/*
 		 * if the same page, inherit PG_U and PG_M.
 		 */
 		if (((opte ^ npte) & (PG_FRAME | PG_V)) == 0) {
 			npte |= opte & (PG_U | PG_M);
+		}
 #if defined(XEN)
 		if (domid != DOMID_SELF) {
 			/* pmap_pte_cas with error handling */
 			int s = splvm();
 			if (opte != *ptep) {
 				splx(s);
 				continue;
+			}
 			error = xpq_update_foreign(
 			    vtomach((vaddr_t)ptep), npte, domid);
 			splx(s);
 			if (error) {
 				if (ptp != NULL && ptp->wire_count <= 1) {
 					pmap_free_ptp(pmap, ptp, va, ptes, pdes);
+				}
 				pmap_unmap_ptes(pmap, pmap2);
 				goto out;
+			}
 			break;
+		}
 #endif /* defined(XEN) */
 	} while (pmap_pte_cas(ptep, opte, npte) != opte);
 	/*
 	 * update statistics and PTP's reference count.
 	 */
 	pmap_stats_update_bypte(pmap, npte, opte);
 	if (ptp != NULL && !pmap_valid_entry(opte)) {
 		ptp->wire_count++;
+	}
 	KASSERT(ptp == NULL || ptp->wire_count > 1);
 	/*
 	 * if the same page, we can skip pv_entry handling.
 	 */
 	if (((opte ^ npte) & (PG_FRAME | PG_V)) == 0) {
 		KASSERT(((opte ^ npte) & PG_PVLIST) == 0);
 		goto same_pa;
+	}
 	/*
 	 * if old page is pv-tracked, remove pv_entry from its list.
 	 */
 	if ((~opte & (PG_V | PG_PVLIST)) == 0) {
 		if ((old_pg = PHYS_TO_VM_PAGE(pmap_pte2pa(opte))) != NULL) {
 			KASSERT(uvm_page_locked_p(old_pg));
 			old_pp = VM_PAGE_TO_PP(old_pg);
 		} else if ((old_pp = pmap_pv_tracked(pmap_pte2pa(opte)))
 		    == NULL) {
 			pa = pmap_pte2pa(opte);
 			panic("pmap_enter: PG_PVLIST with pv-untracked page"
 			    " va = 0x%"PRIxVADDR
 			    " pa = 0x%" PRIxPADDR " (0x%" PRIxPADDR ")",
 			    va, pa, atop(pa));
+		}
 		old_pve = pmap_remove_pv(old_pp, ptp, va);
 		old_pp->pp_attrs |= opte;
+	}
 	/*
 	 * if new page is pv-tracked, insert pv_entry into its list.
 	 */
 	if (new_pp) {
 		new_pve = pmap_enter_pv(new_pp, new_pve, &new_pve2, ptp, va);
+	}
 same_pa:
 	pmap_unmap_ptes(pmap, pmap2);
 	/*
 	 * shootdown tlb if necessary.
 	 */
 	if ((~opte & (PG_V | PG_U)) == 0 &&
 	    ((opte ^ npte) & (PG_FRAME | PG_RW)) != 0) {
 		pmap_tlb_shootdown(pmap, va, opte, TLBSHOOT_ENTER);
+	}
 	error = 0;
 out:
 	kpreempt_enable();
 out2:
 	if (old_pve != NULL) {
 		pool_cache_put(&pmap_pv_cache, old_pve);
+	}
 	if (new_pve != NULL) {
 		pool_cache_put(&pmap_pv_cache, new_pve);
+	}
 	if (new_pve2 != NULL) {
 		pool_cache_put(&pmap_pv_cache, new_pve2);
+	}
 	return error;
+}
 static bool
 pmap_get_physpage(vaddr_t va, int level, paddr_t *paddrp)
+{
 	struct vm_page *ptp;
 	struct pmap *kpm = pmap_kernel();
 	if (!uvm.page_init_done) {
 		/*
 		 * we're growing the kernel pmap early (from
 		 * uvm_pageboot_alloc()).  this case must be
 		 * handled a little differently.
 		 */
 		if (!uvm_page_physget(paddrp))
 			panic("pmap_get_physpage: out of memory");
 #if defined(__HAVE_DIRECT_MAP)
 		pagezero(PMAP_DIRECT_MAP(*paddrp));
 #else
 #if defined(XEN)
 		if (XEN_VERSION_SUPPORTED(3, 4)) {
 			xen_pagezero(*paddrp);
 			return true;
+		}
 #endif
 		kpreempt_disable();
 		pmap_pte_set(early_zero_pte,
 		    pmap_pa2pte(*paddrp) | PG_V | PG_RW | PG_k);
 		pmap_pte_flush();
 		pmap_update_pg((vaddr_t)early_zerop);
 		memset(early_zerop, 0, PAGE_SIZE);
 #if defined(DIAGNOSTIC) || defined(XEN)
 		pmap_pte_set(early_zero_pte, 0);
 		pmap_pte_flush();
 #endif /* defined(DIAGNOSTIC) */
 		kpreempt_enable();
 #endif /* defined(__HAVE_DIRECT_MAP) */
 	} else {
 		/* XXX */
 		ptp = uvm_pagealloc(NULL, 0, NULL,
 				    UVM_PGA_USERESERVE|UVM_PGA_ZERO);
 		if (ptp == NULL)
 			panic("pmap_get_physpage: out of memory");
 		ptp->flags &= ~PG_BUSY;
 		ptp->wire_count = 1;
 		*paddrp = VM_PAGE_TO_PHYS(ptp);
+	}
 	pmap_stats_update(kpm, 1, 0);
 	return true;
+}
 /*
  * Allocate the amount of specified ptps for a ptp level, and populate
  * all levels below accordingly, mapping virtual addresses starting at
  * kva.
+ *
  * Used by pmap_growkernel.
  */
 static void
 pmap_alloc_level(pd_entry_t * const *pdes, vaddr_t kva, int lvl,
     long *needed_ptps)
+{
 	unsigned long i;
 	vaddr_t va;
 	paddr_t pa;
 	unsigned long index, endindex;
 	int level;
 	pd_entry_t *pdep;
 #ifdef XEN
 	int s = splvm(); /* protect xpq_* */
 #endif
 	for (level = lvl; level > 1; level--) {
 		if (level == PTP_LEVELS)
 			pdep = pmap_kernel()->pm_pdir;
 		else
 			pdep = pdes[level - 2];
 		va = kva;
 		index = pl_i_roundup(kva, level);
 		endindex = index + needed_ptps[level - 1] - 1;
 		for (i = index; i <= endindex; i++) {
 			pt_entry_t pte;
 			KASSERT(!pmap_valid_entry(pdep[i]));
 			pmap_get_physpage(va, level - 1, &pa);
 			pte = pmap_pa2pte(pa) | PG_k | PG_V | PG_RW;
 #ifdef XEN
 			pmap_pte_set(&pdep[i], pte);
 #if defined(PAE) || defined(__x86_64__)
 			if (level == PTP_LEVELS && i >= PDIR_SLOT_KERN) {
 				if (__predict_true(
 				    cpu_info_primary.ci_flags & CPUF_PRESENT)) {
 					/* update per-cpu PMDs on all cpus */
 					xen_kpm_sync(pmap_kernel(), i);
 				} else {
 					/*
 					 * too early; update primary CPU
 					 * PMD only (without locks)
 					 */
 #ifdef PAE
 					pd_entry_t *cpu_pdep =
 					    &cpu_info_primary.ci_kpm_pdir[l2tol2(i)];
 #endif
 #ifdef __x86_64__
 					pd_entry_t *cpu_pdep =
 						&cpu_info_primary.ci_kpm_pdir[i];
 #endif
 					pmap_pte_set(cpu_pdep, pte);
+				}
+			}
 #endif /* PAE || __x86_64__ */
 #else /* XEN */
 			pdep[i] = pte;
 #endif /* XEN */
 			KASSERT(level != PTP_LEVELS || nkptp[level - 1] +
 			    pl_i(VM_MIN_KERNEL_ADDRESS, level) == i);
 			nkptp[level - 1]++;
 			va += nbpd[level - 1];
+		}
 		pmap_pte_flush();
+	}
 #ifdef XEN
 	splx(s);
 #endif
+}
 /*
  * pmap_growkernel: increase usage of KVM space
+ *
  * => we allocate new PTPs for the kernel and install them in all
  *	the pmaps on the system.
  */
 vaddr_t
 pmap_growkernel(vaddr_t maxkvaddr)
+{
 	struct pmap *kpm = pmap_kernel();
 #if !defined(XEN) || !defined(__x86_64__)
 	struct pmap *pm;
 	long old;
 #endif
 	int s, i;
 	long needed_kptp[PTP_LEVELS], target_nptp;
 	bool invalidate = false;
 	s = splvm();	/* to be safe */
 	mutex_enter(kpm->pm_lock);
 	if (maxkvaddr <= pmap_maxkvaddr) {
 		mutex_exit(kpm->pm_lock);
 		splx(s);
 		return pmap_maxkvaddr;
+	}
 	maxkvaddr = x86_round_pdr(maxkvaddr);
 #if !defined(XEN) || !defined(__x86_64__)
 	old = nkptp[PTP_LEVELS - 1];
 #endif
 	/*
 	 * This loop could be optimized more, but pmap_growkernel()
 	 * is called infrequently.
 	 */
 	for (i = PTP_LEVELS - 1; i >= 1; i--) {
 		target_nptp = pl_i_roundup(maxkvaddr, i + 1) -
 		    pl_i_roundup(VM_MIN_KERNEL_ADDRESS, i + 1);
 		/*
 		 * XXX only need to check toplevel.
 		 */
 		if (target_nptp > nkptpmax[i])
 			panic("out of KVA space");
 		KASSERT(target_nptp >= nkptp[i]);
 		needed_kptp[i] = target_nptp - nkptp[i];
+	}
 	pmap_alloc_level(normal_pdes, pmap_maxkvaddr, PTP_LEVELS, needed_kptp);
 	/*
 	 * If the number of top level entries changed, update all
 	 * pmaps.
 	 */
 	if (needed_kptp[PTP_LEVELS - 1] != 0) {
 #ifdef XEN
 #ifdef __x86_64__
 		/* nothing, kernel entries are never entered in user pmap */
 #else /* __x86_64__ */
 		mutex_enter(&pmaps_lock);
 		LIST_FOREACH(pm, &pmaps, pm_list) {
 			int pdkidx;
 			for (pdkidx =  PDIR_SLOT_KERN + old;
 			    pdkidx < PDIR_SLOT_KERN + nkptp[PTP_LEVELS - 1];
 			    pdkidx++) {
 				pmap_pte_set(&pm->pm_pdir[pdkidx],
 				    kpm->pm_pdir[pdkidx]);
+			}
 			pmap_pte_flush();
+		}
 		mutex_exit(&pmaps_lock);
 #endif /* __x86_64__ */
 #else /* XEN */
 		unsigned newpdes;
 		newpdes = nkptp[PTP_LEVELS - 1] - old;
 		mutex_enter(&pmaps_lock);
 		LIST_FOREACH(pm, &pmaps, pm_list) {
 			memcpy(&pm->pm_pdir[PDIR_SLOT_KERN + old],
 			       &kpm->pm_pdir[PDIR_SLOT_KERN + old],
 			       newpdes * sizeof (pd_entry_t));
+		}
 		mutex_exit(&pmaps_lock);
 #endif
 		invalidate = true;
+	}
 	pmap_maxkvaddr = maxkvaddr;
 	mutex_exit(kpm->pm_lock);
 	splx(s);
 	if (invalidate && pmap_initialized) {
 		/* Invalidate the PDP cache. */
 		pool_cache_invalidate(&pmap_pdp_cache);
+	}
 	return maxkvaddr;
+}
 #ifdef DEBUG
 void pmap_dump(struct pmap *, vaddr_t, vaddr_t);
 /*
  * pmap_dump: dump all the mappings from a pmap
+ *
  * => caller should not be holding any pmap locks
  */
 void
 pmap_dump(struct pmap *pmap, vaddr_t sva, vaddr_t eva)
+{
 	pt_entry_t *ptes, *pte;
 	pd_entry_t * const *pdes;
 	struct pmap *pmap2;
 	vaddr_t blkendva;
 	/*
 	 * if end is out of range truncate.
 	 * if (end == start) update to max.
 	 */
 	if (eva > VM_MAXUSER_ADDRESS || eva <= sva)
 		eva = VM_MAXUSER_ADDRESS;
 	/*
 	 * we lock in the pmap => pv_head direction
 	 */
 	kpreempt_disable();
 	pmap_map_ptes(pmap, &pmap2, &ptes, &pdes);	/* locks pmap */
 	/*
 	 * dumping a range of pages: we dump in PTP sized blocks (4MB)
 	 */
 	for (/* null */ ; sva < eva ; sva = blkendva) {
 		/* determine range of block */
 		blkendva = x86_round_pdr(sva+1);
 		if (blkendva > eva)
 			blkendva = eva;
 		/* valid block? */
 		if (!pmap_pdes_valid(sva, pdes, NULL))
 			continue;
 		pte = &ptes[pl1_i(sva)];
 		for (/* null */; sva < blkendva ; sva += PAGE_SIZE, pte++) {
 			if (!pmap_valid_entry(*pte))
 				continue;
 			printf("va %#" PRIxVADDR " -> pa %#" PRIxPADDR
 			    " (pte=%#" PRIxPADDR ")\n",
 			    sva, (paddr_t)pmap_pte2pa(*pte), (paddr_t)*pte);
+		}
+	}
 	pmap_unmap_ptes(pmap, pmap2);
 	kpreempt_enable();
+}
 #endif
 /*
  * pmap_update: process deferred invalidations and frees.
  */
 void
 pmap_update(struct pmap *pmap)
+{
 	struct vm_page *empty_ptps;
 	lwp_t *l = curlwp;
 	/*
 	 * If we have torn down this pmap, invalidate non-global TLB
 	 * entries on any processors using it.
 	 */
 	kpreempt_disable();
 	if (__predict_false(l->l_md.md_gc_pmap == pmap)) {
 		l->l_md.md_gc_pmap = NULL;
 		pmap_tlb_shootdown(pmap, (vaddr_t)-1LL, 0, TLBSHOOT_UPDATE);
+	}
 	/*
 	 * Initiate any pending TLB shootdowns.  Wait for them to
 	 * complete before returning control to the caller.
 	 */
 	pmap_tlb_shootnow();
 	kpreempt_enable();
 	/*
 	 * Now that shootdowns are complete, process deferred frees,
 	 * but not from interrupt context.
 	 */
 	if (l->l_md.md_gc_ptp != NULL) {
 		KASSERT((l->l_pflag & LP_INTR) == 0);
 		if (cpu_intr_p()) {
 			return;
+		}
 		empty_ptps = l->l_md.md_gc_ptp;
 		l->l_md.md_gc_ptp = NULL;
 		pmap_free_ptps(empty_ptps);
+	}
+}
 #if PTP_LEVELS > 4
 #error "Unsupported number of page table mappings"
 #endif
 paddr_t
 pmap_init_tmp_pgtbl(paddr_t pg)
+{
 	static bool maps_loaded;
 	static const paddr_t x86_tmp_pml_paddr[] = {
-* PAGE_SIZE,
+* PAGE_SIZE,	/* L1 */
-* PAGE_SIZE,
+* PAGE_SIZE,	/* L2 */
-* PAGE_SIZE,
+* PAGE_SIZE,	/* L3 */
-* PAGE_SIZE
+* PAGE_SIZE	/* L4 */
 	};
 	static vaddr_t x86_tmp_pml_vaddr[] = { 0, 0, 0, 0 };
 	pd_entry_t *tmp_pml, *kernel_pml;
 	int level;
 	if (!maps_loaded) {
 		for (level = 0; level < PTP_LEVELS; ++level) {
 			x86_tmp_pml_vaddr[level] =
 			    uvm_km_alloc(kernel_map, PAGE_SIZE, 0,
 			    UVM_KMF_VAONLY);
 			if (x86_tmp_pml_vaddr[level] == 0)
 				panic("mapping of real mode PML failed\n");
 			pmap_kenter_pa(x86_tmp_pml_vaddr[level],
 			    x86_tmp_pml_paddr[level],
 			    VM_PROT_READ | VM_PROT_WRITE, 0);
 			pmap_update(pmap_kernel());
+		}
 		maps_loaded = true;
+	}
 	/* Zero levels 1-3 */
 	for (level = 0; level < PTP_LEVELS - 1; ++level) {
 		tmp_pml = (void *)x86_tmp_pml_vaddr[level];
 		memset(tmp_pml, 0, PAGE_SIZE);
+	}
 	/* Copy PML4 */
 	kernel_pml = pmap_kernel()->pm_pdir;
 	tmp_pml = (void *)x86_tmp_pml_vaddr[PTP_LEVELS - 1];
 	memcpy(tmp_pml, kernel_pml, PAGE_SIZE);
 #ifdef PAE
 	/*
 	 * Use the last 4 entries of the L2 page as L3 PD entries. These
 	 * last entries are unlikely to be used for temporary mappings.
 	 * 508: maps 0->1GB (userland)
 	 * 509: unused
 	 * 510: unused
 	 * 511: maps 3->4GB (kernel)
 	 */
 	tmp_pml[508] = x86_tmp_pml_paddr[PTP_LEVELS - 1] | PG_V;
 	tmp_pml[509] = 0;
 	tmp_pml[510] = 0;
 	tmp_pml[511] = pmap_pdirpa(pmap_kernel(), PDIR_SLOT_KERN) | PG_V;
 #endif
 	for (level = PTP_LEVELS - 1; level > 0; --level) {
 		tmp_pml = (void *)x86_tmp_pml_vaddr[level];
 		tmp_pml[pl_i(pg, level + 1)] =
 		    (x86_tmp_pml_paddr[level - 1] & PG_FRAME) | PG_RW | PG_V;
+	}
 	tmp_pml = (void *)x86_tmp_pml_vaddr[0];
 	tmp_pml[pl_i(pg, 1)] = (pg & PG_FRAME) | PG_RW | PG_V;
 #ifdef PAE
 	/* Return the PA of the L3 page (entry 508 of the L2 page) */
 	return x86_tmp_pml_paddr[PTP_LEVELS - 1] + 508 * sizeof(pd_entry_t);
 #endif
 	return x86_tmp_pml_paddr[PTP_LEVELS - 1];
+}
 u_int
 x86_mmap_flags(paddr_t mdpgno)
+{
 	u_int nflag = (mdpgno >> X86_MMAP_FLAG_SHIFT) & X86_MMAP_FLAG_MASK;
 	u_int pflag = 0;
 	if (nflag & X86_MMAP_FLAG_PREFETCH)
 		pflag |= PMAP_WRITE_COMBINE;
 	return pflag;
+}