Index: sys/amd64/amd64/minidump_machdep.c
===================================================================
--- sys/amd64/amd64/minidump_machdep.c
+++ sys/amd64/amd64/minidump_machdep.c
@@ -212,7 +212,7 @@
 			pa = pdpe & PG_PS_FRAME;
 			for (n = 0; n < NPDEPG * NPTEPG; n++) {
 				if (dump_page_is_dumpable(pa))
-					dump_add_page(pa);
+					dump_add_page(state->dump_bitset, pa);
 				pa += PAGE_SIZE;
 			}
 			continue;
@@ -230,7 +230,7 @@
 				pa = pde & PG_PS_FRAME;
 				for (k = 0; k < NPTEPG; k++) {
 					if (dump_page_is_dumpable(pa))
-						dump_add_page(pa);
+						dump_add_page(state->dump_bitset, pa);
 					pa += PAGE_SIZE;
 				}
 				continue;
@@ -239,7 +239,7 @@
 			pa = pde & PG_FRAME;
 			/* set bit for this PTE page */
 			if (dump_page_is_dumpable(pa))
-				dump_add_page(pa);
+				dump_add_page(state->dump_bitset, pa);
 			/* and for each valid page in this 2MB block */
 			pt = (uint64_t *)PHYS_TO_DMAP(pde & PG_FRAME);
 			for (k = 0; k < NPTEPG; k++) {
@@ -248,7 +248,7 @@
 					continue;
 				pa = pte & PG_FRAME;
 				if (dump_page_is_dumpable(pa))
-					dump_add_page(pa);
+					dump_add_page(state->dump_bitset, pa);
 			}
 		}
 	}
@@ -259,12 +259,12 @@
 	dumpsize += round_page(mbp->msg_size);
 	dumpsize += round_page(sizeof(dump_avail));
 	dumpsize += round_page(BITSET_SIZE(vm_page_dump_pages));
-	VM_PAGE_DUMP_FOREACH(pa) {
+	VM_PAGE_DUMP_FOREACH(state->dump_bitset, pa) {
 		/* Clear out undumpable pages now if needed */
 		if (dump_page_is_dumpable(pa)) {
 			dumpsize += PAGE_SIZE;
 		} else {
-			dump_drop_page(pa);
+			dump_drop_page(state->dump_bitset, pa);
 		}
 	}
 	dumpsize += PAGE_SIZE;
@@ -317,7 +317,7 @@
 		goto fail;
 
 	/* Dump bitmap */
-	error = blk_write(di, (char *)vm_page_dump, 0,
+	error = blk_write(di, (char *)state->dump_bitset, 0,
 	    round_page(BITSET_SIZE(vm_page_dump_pages)));
 	if (error)
 		goto fail;
@@ -369,7 +369,7 @@
 	}
 
 	/* Dump memory chunks */
-	VM_PAGE_DUMP_FOREACH(pa) {
+	VM_PAGE_DUMP_FOREACH(state->dump_bitset, pa) {
 		error = blk_write(di, 0, pa, PAGE_SIZE);
 		if (error)
 			goto fail;
Index: sys/amd64/amd64/pmap.c
===================================================================
--- sys/amd64/amd64/pmap.c
+++ sys/amd64/amd64/pmap.c
@@ -4950,7 +4950,7 @@
 		pdpe = pmap_pdpe(kernel_pmap, va);
 		if ((*pdpe & X86_PG_V) == 0) {
 			pa = vm_phys_early_alloc(domain, PAGE_SIZE);
-			dump_add_page(pa);
+			dump_add_page(vm_page_dump, pa);
 			pagezero((void *)PHYS_TO_DMAP(pa));
 			*pdpe = (pdp_entry_t)(pa | X86_PG_V | X86_PG_RW |
 			    X86_PG_A | X86_PG_M);
@@ -4960,7 +4960,7 @@
 			panic("Unexpected pde");
 		pa = vm_phys_early_alloc(domain, NBPDR);
 		for (i = 0; i < NPDEPG; i++)
-			dump_add_page(pa + i * PAGE_SIZE);
+			dump_add_page(vm_page_dump, pa + i * PAGE_SIZE);
 		newpdir = (pd_entry_t)(pa | X86_PG_V | X86_PG_RW | X86_PG_A |
 		    X86_PG_M | PG_PS | pg_g | pg_nx);
 		pde_store(pde, newpdir);
@@ -5291,7 +5291,7 @@
 			PV_STAT(counter_u64_add(pc_chunk_frees, 1));
 			/* Entire chunk is free; return it. */
 			m_pc = PHYS_TO_VM_PAGE(DMAP_TO_PHYS((vm_offset_t)pc));
-			dump_drop_page(m_pc->phys_addr);
+			dump_drop_page(vm_page_dump, m_pc->phys_addr);
 			mtx_lock(&pvc->pvc_lock);
 			TAILQ_REMOVE(&pvc->pvc_list, pc, pc_lru);
 			break;
@@ -5393,7 +5393,7 @@
 	counter_u64_add(pv_page_count, -1);
 	/* entire chunk is free, return it */
 	m = PHYS_TO_VM_PAGE(DMAP_TO_PHYS((vm_offset_t)pc));
-	dump_drop_page(m->phys_addr);
+	dump_drop_page(vm_page_dump, m->phys_addr);
 	vm_page_unwire_noq(m);
 	vm_page_free(m);
 }
@@ -5493,7 +5493,7 @@
 		counter_u64_add(pv_page_count, 1);
 	PV_STAT(counter_u64_add(pc_chunk_count, 1));
 	PV_STAT(counter_u64_add(pc_chunk_allocs, 1));
-	dump_add_page(m->phys_addr);
+	dump_add_page(vm_page_dump, m->phys_addr);
 	pc = (void *)PHYS_TO_DMAP(m->phys_addr);
 	pc->pc_pmap = pmap;
 	pc->pc_map[0] = PC_FREE0 & ~1ul;	/* preallocated bit 0 */
@@ -5594,7 +5594,7 @@
 			counter_u64_add(pv_page_count, 1);
 		PV_STAT(counter_u64_add(pc_chunk_count, 1));
 		PV_STAT(counter_u64_add(pc_chunk_allocs, 1));
-		dump_add_page(m->phys_addr);
+		dump_add_page(vm_page_dump, m->phys_addr);
 		pc = (void *)PHYS_TO_DMAP(m->phys_addr);
 		pc->pc_pmap = pmap;
 		pc->pc_map[0] = PC_FREE0;
Index: sys/amd64/amd64/uma_machdep.c
===================================================================
--- sys/amd64/amd64/uma_machdep.c
+++ sys/amd64/amd64/uma_machdep.c
@@ -55,7 +55,7 @@
 		return (NULL);
 	pa = m->phys_addr;
 	if ((wait & M_NODUMP) == 0)
-		dump_add_page(pa);
+		dump_add_page(vm_page_dump, pa);
 	va = (void *)PHYS_TO_DMAP(pa);
 	if ((wait & M_ZERO) && (m->flags & PG_ZERO) == 0)
 		pagezero(va);
@@ -69,7 +69,7 @@
 	vm_paddr_t pa;
 
 	pa = DMAP_TO_PHYS((vm_offset_t)mem);
-	dump_drop_page(pa);
+	dump_drop_page(vm_page_dump, pa);
 	m = PHYS_TO_VM_PAGE(pa);
 	vm_page_unwire_noq(m);
 	vm_page_free(m);
Index: sys/arm/arm/minidump_machdep.c
===================================================================
--- sys/arm/arm/minidump_machdep.c
+++ sys/arm/arm/minidump_machdep.c
@@ -186,7 +186,7 @@
 	for (va = KERNBASE; va < kva_end; va += PAGE_SIZE) {
 		pa = pmap_dump_kextract(va, NULL);
 		if (pa != 0 && dump_page_is_dumpable(pa))
-			dump_add_page(pa);
+			dump_add_page(state->dump_bitset, pa);
 		ptesize += sizeof(pt2_entry_t);
 	}
 
@@ -196,12 +196,12 @@
 	dumpsize += round_page(mbp->msg_size);
 	dumpsize += round_page(nitems(dump_avail) * sizeof(uint64_t));
 	dumpsize += round_page(BITSET_SIZE(vm_page_dump_pages));
-	VM_PAGE_DUMP_FOREACH(pa) {
+	VM_PAGE_DUMP_FOREACH(state->dump_bitset, pa) {
 		/* Clear out undumpable pages now if needed */
 		if (dump_page_is_dumpable(pa))
 			dumpsize += PAGE_SIZE;
 		else
-			dump_drop_page(pa);
+			dump_drop_page(state->dump_bitset, pa);
 	}
 	dumpsize += PAGE_SIZE;
 
@@ -256,7 +256,7 @@
 		goto fail;
 
 	/* Dump bitmap */
-	error = blk_write(di, (char *)vm_page_dump, 0,
+	error = blk_write(di, (char *)state->dump_bitset, 0,
 	    round_page(BITSET_SIZE(vm_page_dump_pages)));
 	if (error)
 		goto fail;
@@ -280,7 +280,7 @@
 	}
 
 	/* Dump memory chunks */
-	VM_PAGE_DUMP_FOREACH(pa) {
+	VM_PAGE_DUMP_FOREACH(state->dump_bitset, pa) {
 		if (!count) {
 			prev_pa = pa;
 			count++;
Index: sys/arm64/arm64/minidump_machdep.c
===================================================================
--- sys/arm64/arm64/minidump_machdep.c
+++ sys/arm64/arm64/minidump_machdep.c
@@ -186,14 +186,14 @@
 			for (i = 0; i < Ln_ENTRIES * Ln_ENTRIES;
 			    i++, pa += PAGE_SIZE)
 				if (dump_page_is_dumpable(pa))
-					dump_add_page(pa);
+					dump_add_page(state->dump_bitset, pa);
 			pmapsize += (Ln_ENTRIES - 1) * PAGE_SIZE;
 			va += L1_SIZE - L2_SIZE;
 		} else if ((l2e & ATTR_DESCR_MASK) == L2_BLOCK) {
 			pa = l2e & ~ATTR_MASK;
 			for (i = 0; i < Ln_ENTRIES; i++, pa += PAGE_SIZE) {
 				if (dump_page_is_dumpable(pa))
-					dump_add_page(pa);
+					dump_add_page(state->dump_bitset, pa);
 			}
 		} else if ((l2e & ATTR_DESCR_MASK) == L2_TABLE) {
 			for (i = 0; i < Ln_ENTRIES; i++) {
@@ -202,7 +202,7 @@
 					continue;
 				pa = l3e & ~ATTR_MASK;
 				if (dump_page_is_dumpable(pa))
-					dump_add_page(pa);
+					dump_add_page(state->dump_bitset, pa);
 			}
 		}
 	}
@@ -213,11 +213,11 @@
 	dumpsize += round_page(mbp->msg_size);
 	dumpsize += round_page(sizeof(dump_avail));
 	dumpsize += round_page(BITSET_SIZE(vm_page_dump_pages));
-	VM_PAGE_DUMP_FOREACH(pa) {
+	VM_PAGE_DUMP_FOREACH(state->dump_bitset, pa) {
 		if (dump_page_is_dumpable(pa))
 			dumpsize += PAGE_SIZE;
 		else
-			dump_drop_page(pa);
+			dump_drop_page(state->dump_bitset, pa);
 	}
 	dumpsize += PAGE_SIZE;
 
@@ -269,7 +269,7 @@
 		goto fail;
 
 	/* Dump bitmap */
-	error = blk_write(di, (char *)vm_page_dump, 0,
+	error = blk_write(di, (char *)state->dump_bitset, 0,
 	    round_page(BITSET_SIZE(vm_page_dump_pages)));
 	if (error)
 		goto fail;
@@ -342,7 +342,7 @@
 	}
 
 	/* Dump memory chunks */
-	VM_PAGE_DUMP_FOREACH(pa) {
+	VM_PAGE_DUMP_FOREACH(state->dump_bitset, pa) {
 		error = blk_write(di, 0, pa, PAGE_SIZE);
 		if (error)
 			goto fail;
Index: sys/arm64/arm64/pmap.c
===================================================================
--- sys/arm64/arm64/pmap.c
+++ sys/arm64/arm64/pmap.c
@@ -2414,7 +2414,7 @@
 			PV_STAT(atomic_add_int(&pc_chunk_frees, 1));
 			/* Entire chunk is free; return it. */
 			m_pc = PHYS_TO_VM_PAGE(DMAP_TO_PHYS((vm_offset_t)pc));
-			dump_drop_page(m_pc->phys_addr);
+			dump_drop_page(vm_page_dump, m_pc->phys_addr);
 			mtx_lock(&pv_chunks_mutex);
 			TAILQ_REMOVE(&pv_chunks, pc, pc_lru);
 			break;
@@ -2503,7 +2503,7 @@
 	PV_STAT(atomic_add_int(&pc_chunk_frees, 1));
 	/* entire chunk is free, return it */
 	m = PHYS_TO_VM_PAGE(DMAP_TO_PHYS((vm_offset_t)pc));
-	dump_drop_page(m->phys_addr);
+	dump_drop_page(vm_page_dump, m->phys_addr);
 	vm_page_unwire_noq(m);
 	vm_page_free(m);
 }
@@ -2564,7 +2564,7 @@
 	}
 	PV_STAT(atomic_add_int(&pc_chunk_count, 1));
 	PV_STAT(atomic_add_int(&pc_chunk_allocs, 1));
-	dump_add_page(m->phys_addr);
+	dump_add_page(vm_page_dump, m->phys_addr);
 	pc = (void *)PHYS_TO_DMAP(m->phys_addr);
 	pc->pc_pmap = pmap;
 	pc->pc_map[0] = PC_FREE0 & ~1ul;	/* preallocated bit 0 */
@@ -2627,7 +2627,7 @@
 		}
 		PV_STAT(atomic_add_int(&pc_chunk_count, 1));
 		PV_STAT(atomic_add_int(&pc_chunk_allocs, 1));
-		dump_add_page(m->phys_addr);
+		dump_add_page(vm_page_dump, m->phys_addr);
 		pc = (void *)PHYS_TO_DMAP(m->phys_addr);
 		pc->pc_pmap = pmap;
 		pc->pc_map[0] = PC_FREE0;
Index: sys/arm64/arm64/uma_machdep.c
===================================================================
--- sys/arm64/arm64/uma_machdep.c
+++ sys/arm64/arm64/uma_machdep.c
@@ -53,7 +53,7 @@
 		return (NULL);
 	pa = m->phys_addr;
 	if ((wait & M_NODUMP) == 0)
-		dump_add_page(pa);
+		dump_add_page(vm_page_dump, pa);
 	va = (void *)PHYS_TO_DMAP(pa);
 	if ((wait & M_ZERO) && (m->flags & PG_ZERO) == 0)
 		pagezero(va);
@@ -67,7 +67,7 @@
 	vm_paddr_t pa;
 
 	pa = DMAP_TO_PHYS((vm_offset_t)mem);
-	dump_drop_page(pa);
+	dump_drop_page(vm_page_dump, pa);
 	m = PHYS_TO_VM_PAGE(pa);
 	vm_page_unwire_noq(m);
 	vm_page_free(m);
Index: sys/i386/i386/minidump_machdep_base.c
===================================================================
--- sys/i386/i386/minidump_machdep_base.c
+++ sys/i386/i386/minidump_machdep_base.c
@@ -191,7 +191,7 @@
 			pa = pde & PG_PS_FRAME;
 			for (k = 0; k < NPTEPG; k++) {
 				if (dump_page_is_dumpable(pa))
-					dump_add_page(pa);
+					dump_add_page(state->dump_bitset, pa);
 				pa += PAGE_SIZE;
 			}
 			continue;
@@ -204,7 +204,7 @@
 				if ((pte & PG_V) == PG_V) {
 					pa = pte & PG_FRAME;
 					if (dump_page_is_dumpable(pa))
-						dump_add_page(pa);
+						dump_add_page(state->dump_bitset, pa);
 				}
 			}
 		} else {
@@ -218,12 +218,12 @@
 	dumpsize += round_page(mbp->msg_size);
 	dumpsize += round_page(sizeof(dump_avail));
 	dumpsize += round_page(BITSET_SIZE(vm_page_dump_pages));
-	VM_PAGE_DUMP_FOREACH(pa) {
+	VM_PAGE_DUMP_FOREACH(state->dump_bitset, pa) {
 		/* Clear out undumpable pages now if needed */
 		if (dump_page_is_dumpable(pa)) {
 			dumpsize += PAGE_SIZE;
 		} else {
-			dump_drop_page(pa);
+			dump_drop_page(state->dump_bitset, pa);
 		}
 	}
 	dumpsize += PAGE_SIZE;
@@ -317,7 +317,7 @@
 	}
 
 	/* Dump memory chunks */
-	VM_PAGE_DUMP_FOREACH(pa) {
+	VM_PAGE_DUMP_FOREACH(state->dump_bitset, pa) {
 		error = blk_write(di, 0, pa, PAGE_SIZE);
 		if (error)
 			goto fail;
Index: sys/mips/mips/minidump_machdep.c
===================================================================
--- sys/mips/mips/minidump_machdep.c
+++ sys/mips/mips/minidump_machdep.c
@@ -134,7 +134,7 @@
 			if (pte_test(&pte[i], PTE_V)) {
 				pa = TLBLO_PTE_TO_PA(pte[i]);
 				if (dump_page_is_dumpable(pa))
-					dump_add_page(pa);
+					dump_add_page(state->dump_bitset, pa);
 			}
 		}
 	}
@@ -145,7 +145,7 @@
 	 */
 	for (pa = 0; pa < phys_avail[0]; pa += PAGE_SIZE) {
 		if (dump_page_is_dumpable(pa))
-			dump_add_page(pa);
+			dump_add_page(state->dump_bitset, pa);
 	}
 
 	/* Calculate dump size. */
@@ -154,12 +154,12 @@
 	dumpsize += round_page(mbp->msg_size);
 	dumpsize += round_page(nitems(dump_avail) * sizeof(uint64_t));
 	dumpsize += round_page(BITSET_SIZE(vm_page_dump_pages));
-	VM_PAGE_DUMP_FOREACH(pa) {
+	VM_PAGE_DUMP_FOREACH(state->dump_bitset, pa) {
 		/* Clear out undumpable pages now if needed */
 		if (dump_page_is_dumpable(pa))
 			dumpsize += PAGE_SIZE;
 		else
-			dump_drop_page(pa);
+			dump_drop_page(state->dump_bitset, pa);
 	}
 	dumpsize += PAGE_SIZE;
 
@@ -250,8 +250,8 @@
 		prev_pte = 0;
 	}
 
-	/* Dump memory chunks  page by page*/
-	VM_PAGE_DUMP_FOREACH(pa) {
+	/* Dump memory chunks page by page */
+	VM_PAGE_DUMP_FOREACH(state->dump_bitset, pa) {
 		dump_va = pmap_kenter_temporary(pa, 0);
 		error = write_buffer(di, dump_va, PAGE_SIZE);
 		if (error)
Index: sys/mips/mips/pmap.c
===================================================================
--- sys/mips/mips/pmap.c
+++ sys/mips/mips/pmap.c
@@ -1550,7 +1550,7 @@
 			/* Entire chunk is free; return it. */
 			m_pc = PHYS_TO_VM_PAGE(MIPS_DIRECT_TO_PHYS(
 			    (vm_offset_t)pc));
-			dump_drop_page(m_pc->phys_addr);
+			dump_drop_page(vm_page_dump, m_pc->phys_addr);
 			break;
 		}
 	}
@@ -1612,7 +1612,7 @@
 	PV_STAT(pc_chunk_frees++);
 	/* entire chunk is free, return it */
 	m = PHYS_TO_VM_PAGE(MIPS_DIRECT_TO_PHYS((vm_offset_t)pc));
-	dump_drop_page(m->phys_addr);
+	dump_drop_page(vm_page_dump, m->phys_addr);
 	vm_page_unwire_noq(m);
 	vm_page_free(m);
 }
@@ -1673,7 +1673,7 @@
 	}
 	PV_STAT(pc_chunk_count++);
 	PV_STAT(pc_chunk_allocs++);
-	dump_add_page(m->phys_addr);
+	dump_add_page(vm_page_dump, m->phys_addr);
 	pc = (struct pv_chunk *)MIPS_PHYS_TO_DIRECT(VM_PAGE_TO_PHYS(m));
 	pc->pc_pmap = pmap;
 	pc->pc_map[0] = pc_freemask[0] & ~1ul;	/* preallocated bit 0 */
Index: sys/mips/mips/uma_machdep.c
===================================================================
--- sys/mips/mips/uma_machdep.c
+++ sys/mips/mips/uma_machdep.c
@@ -73,7 +73,7 @@
 
 	pa = VM_PAGE_TO_PHYS(m);
 	if ((wait & M_NODUMP) == 0)
-		dump_add_page(pa);
+		dump_add_page(vm_page_dump, pa);
 	va = (void *)MIPS_PHYS_TO_DIRECT(pa);
 	if ((wait & M_ZERO) && (m->flags & PG_ZERO) == 0)
 		bzero(va, PAGE_SIZE);
@@ -87,7 +87,7 @@
 	vm_paddr_t pa;
 
 	pa = MIPS_DIRECT_TO_PHYS((vm_offset_t)mem);
-	dump_drop_page(pa);
+	dump_drop_page(vm_page_dump, pa);
 	m = PHYS_TO_VM_PAGE(pa);
 	vm_page_unwire_noq(m);
 	vm_page_free(m);
Index: sys/powerpc/aim/mmu_oea64.c
===================================================================
--- sys/powerpc/aim/mmu_oea64.c
+++ sys/powerpc/aim/mmu_oea64.c
@@ -443,7 +443,7 @@
     volatile const void *uaddr, void **kaddr, size_t ulen, size_t *klen);
 static int moea64_decode_kernel_ptr(vm_offset_t addr,
     int *is_user, vm_offset_t *decoded_addr);
-static size_t moea64_scan_pmap(void);
+static size_t moea64_scan_pmap(struct bitset *dump_bitset);
 static void *moea64_dump_pmap_init(unsigned blkpgs);
 #ifdef __powerpc64__
 static void moea64_page_array_startup(long);
@@ -3320,7 +3320,7 @@
 #ifdef __powerpc64__
 
 static size_t
-moea64_scan_pmap()
+moea64_scan_pmap(struct bitset *dump_bitset)
 {
 	struct pvo_entry *pvo;
 	vm_paddr_t pa, pa_end;
@@ -3363,11 +3363,11 @@
 			pa_end = pa + lpsize;
 			for (; pa < pa_end; pa += PAGE_SIZE) {
 				if (dump_page_is_dumpable(pa))
-					dump_add_page(pa);
+					dump_add_page(dump_bitset, pa);
 			}
 		} else {
 			if (dump_page_is_dumpable(pa))
-				dump_add_page(pa);
+				dump_add_page(dump_bitset, pa);
 		}
 	}
 	PMAP_UNLOCK(kernel_pmap);
@@ -3389,7 +3389,7 @@
 #else
 
 static size_t
-moea64_scan_pmap()
+moea64_scan_pmap(struct bitset *dump_bitset __unused)
 {
 	return (0);
 }
Index: sys/powerpc/aim/mmu_radix.c
===================================================================
--- sys/powerpc/aim/mmu_radix.c
+++ sys/powerpc/aim/mmu_radix.c
@@ -1225,7 +1225,7 @@
 		}
 		PV_STAT(atomic_add_int(&pc_chunk_count, 1));
 		PV_STAT(atomic_add_int(&pc_chunk_allocs, 1));
-		dump_add_page(m->phys_addr);
+		dump_add_page(vm_page_dump, m->phys_addr);
 		pc = (void *)PHYS_TO_DMAP(m->phys_addr);
 		pc->pc_pmap = pmap;
 		pc->pc_map[0] = PC_FREE0;
@@ -1500,7 +1500,7 @@
 			PV_STAT(atomic_add_int(&pc_chunk_frees, 1));
 			/* Entire chunk is free; return it. */
 			m_pc = PHYS_TO_VM_PAGE(DMAP_TO_PHYS((vm_offset_t)pc));
-			dump_drop_page(m_pc->phys_addr);
+			dump_drop_page(vm_page_dump, m_pc->phys_addr);
 			mtx_lock(&pv_chunks_mutex);
 			TAILQ_REMOVE(&pv_chunks, pc, pc_lru);
 			break;
@@ -1590,7 +1590,7 @@
 	PV_STAT(atomic_add_int(&pc_chunk_frees, 1));
 	/* entire chunk is free, return it */
 	m = PHYS_TO_VM_PAGE(DMAP_TO_PHYS((vm_offset_t)pc));
-	dump_drop_page(m->phys_addr);
+	dump_drop_page(vm_page_dump, m->phys_addr);
 	vm_page_unwire_noq(m);
 	vm_page_free(m);
 }
@@ -1651,7 +1651,7 @@
 	}
 	PV_STAT(atomic_add_int(&pc_chunk_count, 1));
 	PV_STAT(atomic_add_int(&pc_chunk_allocs, 1));
-	dump_add_page(m->phys_addr);
+	dump_add_page(vm_page_dump, m->phys_addr);
 	pc = (void *)PHYS_TO_DMAP(m->phys_addr);
 	pc->pc_pmap = pmap;
 	pc->pc_map[0] = PC_FREE0 & ~1ul;	/* preallocated bit 0 */
@@ -6376,7 +6376,7 @@
 		l2e = pmap_pml2e(kernel_pmap, va);
 		if ((be64toh(*l2e) & PG_V) == 0) {
 			pa = vm_phys_early_alloc(domain, PAGE_SIZE);
-			dump_add_page(pa);
+			dump_add_page(vm_page_dump, pa);
 			pagezero(PHYS_TO_DMAP(pa));
 			pde_store(l2e, (pml2_entry_t)pa);
 		}
@@ -6385,7 +6385,7 @@
 			panic("Unexpected pde %p", pde);
 		pa = vm_phys_early_alloc(domain, L3_PAGE_SIZE);
 		for (i = 0; i < NPDEPG; i++)
-			dump_add_page(pa + i * PAGE_SIZE);
+			dump_add_page(vm_page_dump, pa + i * PAGE_SIZE);
 		newl3 = (pml3_entry_t)(pa | RPTE_EAA_P | RPTE_EAA_R | RPTE_EAA_W);
 		pte_store(pde, newl3);
 	}
Index: sys/powerpc/include/dump.h
===================================================================
--- sys/powerpc/include/dump.h
+++ sys/powerpc/include/dump.h
@@ -40,7 +40,7 @@
 
 void dumpsys_pa_init(void);
 void dumpsys_unmap_chunk(vm_paddr_t, size_t, void *);
-size_t dumpsys_scan_pmap(void);
+size_t dumpsys_scan_pmap(struct bitset *);
 void *dumpsys_dump_pmap_init(unsigned blkpgs);
 void *dumpsys_dump_pmap(void *ctx, void *buf, u_long *nbytes);
 
Index: sys/powerpc/include/mmuvar.h
===================================================================
--- sys/powerpc/include/mmuvar.h
+++ sys/powerpc/include/mmuvar.h
@@ -96,7 +96,7 @@
 typedef	void	(*pmap_dumpsys_map_chunk_t)(vm_paddr_t, size_t, void **);
 typedef	void	(*pmap_dumpsys_unmap_chunk_t)(vm_paddr_t, size_t, void *);
 typedef	void	(*pmap_dumpsys_pa_init_t)(void);
-typedef	size_t	(*pmap_dumpsys_scan_pmap_t)(void);
+typedef	size_t	(*pmap_dumpsys_scan_pmap_t)(struct bitset *dump_bitset);
 typedef	void	*(*pmap_dumpsys_dump_pmap_init_t)(unsigned);
 typedef	void	*(*pmap_dumpsys_dump_pmap_t)(void *, void *, u_long *);
 typedef	vm_offset_t	(*pmap_quick_enter_page_t)(vm_page_t);
Index: sys/powerpc/powerpc/minidump_machdep.c
===================================================================
--- sys/powerpc/powerpc/minidump_machdep.c
+++ sys/powerpc/powerpc/minidump_machdep.c
@@ -204,7 +204,7 @@
 	DBG(total = dumptotal = 0;)
 
 	/* Build set of dumpable pages from kernel pmap */
-	pmapsize = dumpsys_scan_pmap();
+	pmapsize = dumpsys_scan_pmap(state->dump_bitset);
 	if (pmapsize % PAGE_SIZE != 0) {
 		printf("pmapsize not page aligned: 0x%x\n", pmapsize);
 		return (EINVAL);
@@ -217,12 +217,12 @@
 	dumpsize += round_page(sizeof(dump_avail));
 	dumpsize += round_page(BITSET_SIZE(vm_page_dump_pages));
 	dumpsize += pmapsize;
-	VM_PAGE_DUMP_FOREACH(pa) {
+	VM_PAGE_DUMP_FOREACH(state->dump_bitset, pa) {
 		/* Clear out undumpable pages now if needed */
 		if (dump_page_is_dumpable(pa))
 			dumpsize += PAGE_SIZE;
 		else
-			dump_drop_page(pa);
+			dump_drop_page(state->dump_bitset, pa);
 	}
 	dumpsys_pb_init(dumpsize);
 
@@ -290,7 +290,7 @@
 	dump_total("pmap", pmapsize);
 
 	/* Dump memory chunks */
-	VM_PAGE_DUMP_FOREACH(pa) {
+	VM_PAGE_DUMP_FOREACH(state->dump_bitset, pa) {
 		error = blk_write(di, 0, pa, PAGE_SIZE);
 		if (error)
 			goto fail;
Index: sys/powerpc/powerpc/pmap_dispatch.c
===================================================================
--- sys/powerpc/powerpc/pmap_dispatch.c
+++ sys/powerpc/powerpc/pmap_dispatch.c
@@ -188,7 +188,7 @@
 DEFINE_DUMPSYS_IFUNC(void, map_chunk, (vm_paddr_t, size_t, void **));
 DEFINE_DUMPSYS_IFUNC(void, unmap_chunk, (vm_paddr_t, size_t, void *));
 DEFINE_DUMPSYS_IFUNC(void, pa_init, (void));
-DEFINE_DUMPSYS_IFUNC(size_t, scan_pmap, (void));
+DEFINE_DUMPSYS_IFUNC(size_t, scan_pmap, (struct bitset *));
 DEFINE_DUMPSYS_IFUNC(void *, dump_pmap_init, (unsigned));
 DEFINE_DUMPSYS_IFUNC(void *, dump_pmap, (void *, void *, u_long *));
 
Index: sys/powerpc/powerpc/uma_machdep.c
===================================================================
--- sys/powerpc/powerpc/uma_machdep.c
+++ sys/powerpc/powerpc/uma_machdep.c
@@ -63,7 +63,7 @@
 	pa = VM_PAGE_TO_PHYS(m);
 #ifdef __powerpc64__
 	if ((wait & M_NODUMP) == 0)
-		dump_add_page(pa);
+		dump_add_page(vm_page_dump, pa);
 #endif
 
 	if (!hw_direct_map) {
@@ -95,7 +95,7 @@
 	KASSERT(m != NULL,
 	    ("Freeing UMA block at %p with no associated page", mem));
 #ifdef __powerpc64__
-	dump_drop_page(VM_PAGE_TO_PHYS(m));
+	dump_drop_page(vm_page_dump, VM_PAGE_TO_PHYS(m));
 #endif
 	vm_page_unwire_noq(m);
 	vm_page_free(m);
Index: sys/riscv/riscv/minidump_machdep.c
===================================================================
--- sys/riscv/riscv/minidump_machdep.c
+++ sys/riscv/riscv/minidump_machdep.c
@@ -197,7 +197,7 @@
 			pa = (l2e >> PTE_PPN1_S) << L2_SHIFT;
 			for (i = 0; i < Ln_ENTRIES; i++, pa += PAGE_SIZE) {
 				if (dump_page_is_dumpable(pa))
-					dump_add_page(pa);
+					dump_add_page(state->dump_bitset, pa);
 			}
 		} else {
 			for (i = 0; i < Ln_ENTRIES; i++) {
@@ -206,7 +206,7 @@
 					continue;
 				pa = (l3e >> PTE_PPN0_S) * PAGE_SIZE;
 				if (dump_page_is_dumpable(pa))
-					dump_add_page(pa);
+					dump_add_page(state->dump_bitset, pa);
 			}
 		}
 	}
@@ -217,12 +217,12 @@
 	dumpsize += round_page(mbp->msg_size);
 	dumpsize += round_page(sizeof(dump_avail));
 	dumpsize += round_page(BITSET_SIZE(vm_page_dump_pages));
-	VM_PAGE_DUMP_FOREACH(pa) {
+	VM_PAGE_DUMP_FOREACH(state->dump_bitset, pa) {
 		/* Clear out undumpable pages now if needed */
 		if (dump_page_is_dumpable(pa))
 			dumpsize += PAGE_SIZE;
 		else
-			dump_drop_page(pa);
+			dump_drop_page(state->dump_bitset, pa);
 	}
 	dumpsize += PAGE_SIZE;
 
@@ -321,7 +321,7 @@
 
 	/* Dump memory chunks */
 	/* XXX cluster it up and use blk_dump() */
-	VM_PAGE_DUMP_FOREACH(pa) {
+	VM_PAGE_DUMP_FOREACH(state->dump_bitset, pa) {
 		error = blk_write(di, 0, pa, PAGE_SIZE);
 		if (error)
 			goto fail;
Index: sys/riscv/riscv/pmap.c
===================================================================
--- sys/riscv/riscv/pmap.c
+++ sys/riscv/riscv/pmap.c
@@ -1641,7 +1641,7 @@
 	PV_STAT(atomic_add_int(&pc_chunk_frees, 1));
 	/* entire chunk is free, return it */
 	m = PHYS_TO_VM_PAGE(DMAP_TO_PHYS((vm_offset_t)pc));
-	dump_drop_page(m->phys_addr);
+	dump_drop_page(vm_page_dump, m->phys_addr);
 	vm_page_unwire_noq(m);
 	vm_page_free(m);
 }
@@ -1703,7 +1703,7 @@
 	}
 	PV_STAT(atomic_add_int(&pc_chunk_count, 1));
 	PV_STAT(atomic_add_int(&pc_chunk_allocs, 1));
-	dump_add_page(m->phys_addr);
+	dump_add_page(vm_page_dump, m->phys_addr);
 	pc = (void *)PHYS_TO_DMAP(m->phys_addr);
 	pc->pc_pmap = pmap;
 	pc->pc_map[0] = PC_FREE0 & ~1ul;	/* preallocated bit 0 */
Index: sys/riscv/riscv/uma_machdep.c
===================================================================
--- sys/riscv/riscv/uma_machdep.c
+++ sys/riscv/riscv/uma_machdep.c
@@ -52,7 +52,7 @@
 		return (NULL);
 	pa = m->phys_addr;
 	if ((wait & M_NODUMP) == 0)
-		dump_add_page(pa);
+		dump_add_page(vm_page_dump, pa);
 	va = (void *)PHYS_TO_DMAP(pa);
 	if ((wait & M_ZERO) && (m->flags & PG_ZERO) == 0)
 		bzero(va, PAGE_SIZE);
@@ -66,7 +66,7 @@
 	vm_paddr_t pa;
 
 	pa = DMAP_TO_PHYS((vm_offset_t)mem);
-	dump_drop_page(pa);
+	dump_drop_page(vm_page_dump, pa);
 	m = PHYS_TO_VM_PAGE(pa);
 	vm_page_unwire_noq(m);
 	vm_page_free(m);
Index: sys/vm/uma_core.c
===================================================================
--- sys/vm/uma_core.c
+++ sys/vm/uma_core.c
@@ -1904,7 +1904,7 @@
 #if defined(__aarch64__) || defined(__amd64__) || defined(__mips__) || \
     defined(__riscv) || defined(__powerpc64__)
 		if ((wait & M_NODUMP) == 0)
-			dump_add_page(pa);
+			dump_add_page(vm_page_dump, pa);
 #endif
 	}
 	/* Allocate KVA and indirectly advance bootmem. */
@@ -1934,7 +1934,7 @@
 	for (; bytes != 0; bytes -= PAGE_SIZE, m++) {
 #if defined(__aarch64__) || defined(__amd64__) || defined(__mips__) || \
     defined(__riscv) || defined(__powerpc64__)
-		dump_drop_page(VM_PAGE_TO_PHYS(m));
+		dump_drop_page(vm_page_dump, VM_PAGE_TO_PHYS(m));
 #endif
 		vm_page_unwire_noq(m);
 		vm_page_free(m);
Index: sys/vm/vm_dumpset.h
===================================================================
--- sys/vm/vm_dumpset.h
+++ sys/vm/vm_dumpset.h
@@ -54,7 +54,7 @@
 }
 
 static inline void
-dump_add_page(vm_paddr_t pa)
+dump_add_page(struct bitset *bitset, vm_paddr_t pa)
 {
 	vm_pindex_t adj;
 	int i;
@@ -64,7 +64,7 @@
 		if (pa >= dump_avail[i] && pa < dump_avail[i + 1]) {
 			BIT_SET_ATOMIC(vm_page_dump_pages,
 			    (pa >> PAGE_SHIFT) - (dump_avail[i] >> PAGE_SHIFT) +
-			    adj, vm_page_dump);
+			    adj, bitset);
 			return;
 		}
 		adj += howmany(dump_avail[i + 1], PAGE_SIZE) -
@@ -73,7 +73,7 @@
 }
 
 static inline void
-dump_drop_page(vm_paddr_t pa)
+dump_drop_page(struct bitset *bitset, vm_paddr_t pa)
 {
 	vm_pindex_t adj;
 	int i;
@@ -83,7 +83,7 @@
 		if (pa >= dump_avail[i] && pa < dump_avail[i + 1]) {
 			BIT_CLR_ATOMIC(vm_page_dump_pages,
 			    (pa >> PAGE_SHIFT) - (dump_avail[i] >> PAGE_SHIFT) +
-			    adj, vm_page_dump);
+			    adj, bitset);
 			return;
 		}
 		adj += howmany(dump_avail[i + 1], PAGE_SIZE) -
@@ -107,9 +107,9 @@
 	return ((vm_paddr_t)NULL);
 }
 
-#define VM_PAGE_DUMP_FOREACH(pa)						\
-	for (vm_pindex_t __b = BIT_FFS(vm_page_dump_pages, vm_page_dump);	\
-	    (pa) = vm_page_dump_index_to_pa(__b - 1), __b != 0;			\
-	    __b = BIT_FFS_AT(vm_page_dump_pages, vm_page_dump, __b))
+#define VM_PAGE_DUMP_FOREACH(bitset, pa)				\
+	for (vm_pindex_t __b = BIT_FFS(vm_page_dump_pages, bitset);	\
+	    (pa) = vm_page_dump_index_to_pa(__b - 1), __b != 0;		\
+	    __b = BIT_FFS_AT(vm_page_dump_pages, bitset, __b))
 
 #endif	/* _SYS_DUMPSET_H_ */
Index: sys/vm/vm_page.c
===================================================================
--- sys/vm/vm_page.c
+++ sys/vm/vm_page.c
@@ -631,7 +631,7 @@
 	 * not automatically included.
 	 */
 	for (pa = new_end; pa < end; pa += PAGE_SIZE)
-		dump_add_page(pa);
+		dump_add_page(vm_page_dump, pa);
 #endif
 	phys_avail[biggestone + 1] = new_end;
 #ifdef __amd64__
@@ -643,7 +643,7 @@
 	pa = DMAP_TO_PHYS((vm_offset_t)msgbufp->msg_ptr);
 	last_pa = pa + round_page(msgbufsize);
 	while (pa < last_pa) {
-		dump_add_page(pa);
+		dump_add_page(vm_page_dump, pa);
 		pa += PAGE_SIZE;
 	}
 #endif
@@ -734,7 +734,7 @@
 	 * Include vm_page_array and vm_reserv_array in a crash dump.
 	 */
 	for (pa = new_end; pa < end; pa += PAGE_SIZE)
-		dump_add_page(pa);
+		dump_add_page(vm_page_dump, pa);
 #endif
 	phys_avail[biggestone + 1] = new_end;