 @@ -1,24 +1,28 @@
-/*	$NetBSD: machdep.c,v 1.164 2011/08/11 18:11:17 cherry Exp $	*/
+/*	$NetBSD: machdep.c,v 1.165 2011/08/27 16:23:44 christos Exp $	*/
 /*-
- * Copyright (c) 1996, 1997, 1998, 2000, 2006, 2007, 2008
+ * 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
 @@ -97,27 +101,27 @@
  * 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.164 2011/08/11 18:11:17 cherry Exp $");
+__KERNEL_RCSID(0, "$NetBSD: machdep.c,v 1.165 2011/08/27 16:23:44 christos 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"
 @@ -229,26 +233,45 @@ int     cpureset_delay = 2000; /* defaul
 #endif
 int	cpu_class = CPUCLASS_686;
 #ifdef MTRR
 struct mtrr_funcs *mtrr_funcs;
 #endif
 int	physmem;
 uint64_t	dumpmem_low;
 uint64_t	dumpmem_high;
 int	cpu_class;
 #ifndef NO_SPARSE_DUMP
 int sparse_dump = 0;
 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;
 @@ -280,28 +303,48 @@ struct mtrr_funcs *mtrr_funcs;
 #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	dumpsys(void);
 void	dodumpsys(void);
 void	dumpsys(void);
 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(vaddr_t, vaddr_t, int);
 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);
 /*
  * Machine-dependent startup code
  */
 void
 cpu_startup(void)
+{
 	int x, y;
 	vaddr_t minaddr, maxaddr;
 	psize_t sz;
 	/*
 @@ -520,26 +563,34 @@ SYSCTL_SETUP(sysctl_machdep_setup, "sysc
 		       NULL, 1, NULL, 0,
 		       CTL_MACHDEP, CPU_SSE2, CTL_EOL);
 	sysctl_createv(clog, 0, NULL, NULL,
 		       CTLFLAG_PERMANENT,
 		       CTLTYPE_QUAD, "tsc_freq", NULL,
 		       NULL, 0, &tsc_freq, 0,
 		       CTL_MACHDEP, CTL_CREATE, CTL_EOL);
 	sysctl_createv(clog, 0, NULL, NULL,
 		       CTLFLAG_PERMANENT | CTLFLAG_IMMEDIATE,
 		       CTLTYPE_INT, "pae",
 		       SYSCTL_DESCR("Whether the kernel uses PAE"),
 		       NULL, 1, NULL, 0,
 		       CTL_MACHDEP, CTL_CREATE, CTL_EOL);
 #ifndef NO_SPARSE_DUMP
 	/* XXXjld Does this really belong under machdep, and not e.g. kern? */
 	sysctl_createv(clog, 0, NULL, NULL,
 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
 		       CTLTYPE_INT, "sparse_dump", NULL,
 		       NULL, 0, &sparse_dump, 0,
 		       CTL_MACHDEP, CTL_CREATE, CTL_EOL);
 #endif
+}
 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;
 @@ -736,254 +787,494 @@ haltsys:
 	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
 	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, by half-open virtual
  * address interval (which may wrap around the end of the space).
  */
 void
 sparse_dump_mark(vaddr_t vbegin, vaddr_t vend, int includep)
+{
 	pmap_t pmap;
 	paddr_t p;
 	vaddr_t v;
 	/*
 	 * If a partial page is called for, the whole page must be included.
 	 */
 	if (includep) {
 		vbegin = rounddown(vbegin, PAGE_SIZE);
 		vend = roundup(vend, PAGE_SIZE);
 	} else {
 		vbegin = roundup(vbegin, PAGE_SIZE);
 		vend = rounddown(vend, PAGE_SIZE);
+	}
 	pmap = pmap_kernel();
 	for (v = vbegin; v != vend; v += PAGE_SIZE) {
 		if (pmap_extract(pmap, v, &p)) {
 			if (includep)
 				setbit(sparse_dump_physmap, p/PAGE_SIZE);
 			else
 				clrbit(sparse_dump_physmap, p/PAGE_SIZE);
+		}
+	}
+}
 /*
  * 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((vaddr_t)PTE_BASE, (vaddr_t)KERN_BASE, 1);
 	/* 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) {
 			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)
 		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.
+ * 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.
+ * 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)
+{
 	int (*dump)(dev_t, daddr_t, void *, size_t);
-	char buf[dbtob(1)];
+	kcore_seg_t seg;
-	kcore_seg_t *segp;
+	cpu_kcore_hdr_t cpuhdr;
 	cpu_kcore_hdr_t *cpuhdrp;
 	phys_ram_seg_t *memsegp;
 	const struct bdevsw *bdev;
 	int i;
 	bdev = bdevsw_lookup(dumpdev);
 	if (bdev == NULL)
 		return (ENXIO);
 	dump = bdev->d_dump;
 	memset(buf, 0, sizeof buf);
 	segp = (kcore_seg_t *)buf;
 	cpuhdrp = (cpu_kcore_hdr_t *)&buf[ALIGN(sizeof(*segp))];
 	memsegp = (phys_ram_seg_t *)&buf[ ALIGN(sizeof(*segp)) +
 	    ALIGN(sizeof(*cpuhdrp))];
 	/*
 	 * Generate a segment header.
 	 */
-	CORE_SETMAGIC(*segp, KCORE_MAGIC, MID_MACHINE, CORE_CPU);
+	CORE_SETMAGIC(seg, KCORE_MAGIC, MID_MACHINE, CORE_CPU);
-	segp->c_size = dbtob(1) - ALIGN(sizeof(*segp));
+	seg.c_size = dump_header_size - ALIGN(sizeof(seg));
 	(void)dump_header_addbytes(&seg, ALIGN(sizeof(seg)));
 	/*
 	 * Add the machine-dependent header info.
 	 */
-	cpuhdrp->ptdpaddr = PDPpaddr;
+	cpuhdr.ptdpaddr = PDPpaddr;
-	cpuhdrp->nmemsegs = mem_cluster_cnt;
+	cpuhdr.nmemsegs = dump_nmemsegs;
 	(void)dump_header_addbytes(&cpuhdr, ALIGN(sizeof(cpuhdr)));
 	/*
-	 * Fill in the memory segment descriptors.
+	 * Write out the memory segment descriptors.
 	 */
-	for (i = 0; i < mem_cluster_cnt; i++) {
+	return dump_seg_iter(dump_header_addseg);
 		memsegp[i].start = mem_clusters[i].start;
 		memsegp[i].size = mem_clusters[i].size;
 	return (dump(dumpdev, dumplo, (void *)buf, dbtob(1)));
 /*
  * 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.
  */
 void
 cpu_dumpconf(void)
 	const struct bdevsw *bdev;
 	int nblks, dumpblks;	/* size of dump area */
 	if (dumpdev == NODEV)
 		goto bad;
 	bdev = bdevsw_lookup(dumpdev);
 	if (bdev == NULL) {
 		dumpdev = NODEV;
 		goto bad;
 	if (bdev->d_psize == NULL)
 		goto bad;
 	nblks = (*bdev->d_psize)(dumpdev);
 	if (nblks <= ctod(1))
 		goto bad;
 	dumpblks = cpu_dumpsize();
 	if (dumpblks < 0)
 		goto bad;
 	dumpblks += ctod(cpu_dump_mempagecnt());
 	/* If dump won't fit (incl. room for possible label), punt. */
 	if (dumpblks > (nblks - ctod(1)))
 		goto bad;
 	/* Put dump at end of partition */
 	dumplo = nblks - dumpblks;
 	/* dumpsize is in page units, and doesn't include headers. */
 	dumpsize = cpu_dump_mempagecnt();
 	return;
  bad:
 	dumpsize = 0;
+}
 /*
  * 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("%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);
 		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;
-	u_long totalbytesleft, bytes, i, n, memseg;
+	int dumpend, psize;
 	u_long maddr;
 	int psize;
 	daddr_t blkno;
 	int (*dump)(dev_t, daddr_t, void *, size_t);
 	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();
 	if (dumplo <= 0 || dumpsize == 0) {
 		printf("\ndump to dev %u,%u not possible\n", major(dumpdev),
 		    minor(dumpdev));
 		return;
+	}
-	printf("\ndumping to dev %u,%u offset %ld\n", major(dumpdev),
+	printf("\ndumping to dev %llu,%llu offset %ld\n",
-	    minor(dumpdev), dumplo);
+	    (unsigned long long)major(dumpdev),
 	    (unsigned long long)minor(dumpdev), dumplo);
 	psize = (*bdev->d_psize)(dumpdev);
 	printf("dump ");
 	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;
-	totalbytesleft = ctob(cpu_dump_mempagecnt());
+	if (dump_header_blkno != dumplo + btodb(dump_header_size)) {
-	blkno = dumplo + cpu_dumpsize();
+		printf("BAD header size (%ld [written] != %ld [expected])\n",
-	dump = bdev->d_dump;
+		    (long)(dump_header_blkno - dumplo),
-	error = 0;
+		    (long)btodb(dump_header_size));
 		goto failed;
+	}
-	for (memseg = 0; memseg < mem_cluster_cnt; memseg++) {
+	dump_totalbytesleft = roundup(ptoa(dump_npages), BYTES_PER_DUMP);
-		maddr = mem_clusters[memseg].start;
+	error = dump_seg_iter(dumpsys_seg);
 		bytes = mem_clusters[memseg].size;
 		for (i = 0; i < bytes; i += n, totalbytesleft -= n) {
 			/* Print out how many MBs we have left to go. */
 			if ((totalbytesleft % (1024*1024)) == 0)
 				printf("%ld ", totalbytesleft / (1024 * 1024));
 			/* Limit size for next transfer. */
 			n = bytes - i;
 			if (n > BYTES_PER_DUMP)
 				n = BYTES_PER_DUMP;
 			(void) pmap_map(dumpspace, maddr, maddr + n,
 			    VM_PROT_READ);
 			error = (*dump)(dumpdev, blkno, (void *)dumpspace, n);
 			if (error)
 				goto err;
 			maddr += n;
 			blkno += btodb(n);		/* XXX? */
-#if 0	/* XXX this doesn't work.  grr. */
+	if (error == 0 && dump_header_blkno != dumpend) {
-			/* operator aborting dump? */
+		printf("BAD dump size (%ld [written] != %ld [expected])\n",
-			if (sget() != NULL) {
+		    (long)(dumpend - dumplo),
-				error = EINTR;
+		    (long)(dump_header_blkno - dumplo));
-				break;
+		goto failed;
 #endif
+	}
- err:
+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;
 @@ -994,31 +1285,96 @@ dodumpsys(void)
 	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)
+{
 	const struct bdevsw *bdev;
 	int nblks, dumpblks;	/* size of dump area */
 	if (dumpdev == NODEV)
 		goto bad;
 	bdev = bdevsw_lookup(dumpdev);
 	if (bdev == NULL) {
 		dumpdev = NODEV;
 		goto bad;
+	}
 	if (bdev->d_psize == NULL)
 		goto bad;
 	nblks = (*bdev->d_psize)(dumpdev);
 	if (nblks <= ctod(1))
 		goto bad;
 	dumpblks = cpu_dumpsize();
 	if (dumpblks < 0)
 		goto bad;
 	dumpblks += ctod(cpu_dump_mempagecnt());
 	/* 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;
+	}
 	/* dumpsize is in page units, and doesn't include headers. */
 	dumpsize = cpu_dump_mempagecnt();
 	/* 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;
 	/* If we were using the FPU, forget about it. */
 	if (pcb->pcb_fpcpu != NULL) {
 		fpusave_lwp(l, false);
+	}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: pmap.h,v 1.25 2011/08/13 12:09:38 cherry Exp $	*/
+/*	$NetBSD: pmap.h,v 1.26 2011/08/27 16:23:44 christos Exp $	*/
 /*
  * 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.
 @@ -167,26 +167,27 @@
 #define PDIR_SLOT_PTE	L4_SLOT_PTE
 #define PDIR_SLOT_APTE	L4_SLOT_APTE
 /*
  * the following defines give the virtual addresses of various MMU
  * data structures:
  * PTE_BASE and APTE_BASE: the base VA of the linear PTE mappings
  * PTD_BASE and APTD_BASE: the base VA of the recursive mapping of the PTD
  * PDP_PDE and APDP_PDE: the VA of the PDE that points back to the PDP/APDP
+ *
  */
 #define PTE_BASE  ((pt_entry_t *) (L4_SLOT_PTE * NBPD_L4))
 #define KERN_BASE  ((pt_entry_t *) (L4_SLOT_KERN * NBPD_L4))
 #define APTE_BASE ((pt_entry_t *) (VA_SIGN_NEG((L4_SLOT_APTE * NBPD_L4))))
 #define L1_BASE		PTE_BASE
 #define AL1_BASE	APTE_BASE
 #define L2_BASE ((pd_entry_t *)((char *)L1_BASE + L4_SLOT_PTE * NBPD_L3))
 #define L3_BASE ((pd_entry_t *)((char *)L2_BASE + L4_SLOT_PTE * NBPD_L2))
 #define L4_BASE ((pd_entry_t *)((char *)L3_BASE + L4_SLOT_PTE * NBPD_L1))
 #define AL2_BASE ((pd_entry_t *)((char *)AL1_BASE + L4_SLOT_PTE * NBPD_L3))
 #define AL3_BASE ((pd_entry_t *)((char *)AL2_BASE + L4_SLOT_PTE * NBPD_L2))
 #define AL4_BASE ((pd_entry_t *)((char *)AL3_BASE + L4_SLOT_PTE * NBPD_L1))