pmap_qenter/qremove: Use void * instead of vm_offset_t

Effort:		CHERI upstreaming
Reviewed by:	kib
Sponsored by:	AFRL, DARPA
Pull Request:	https://github.com/freebsd/freebsd-src/pull/2068

sys/amd64/amd64/mp_machdep.c

@@ -324,7 +324,7 @@ amd64_mp_alloc_pcpu(void)
 			m = vm_page_alloc_noobj(VM_ALLOC_ZERO);
 		if (m == NULL)
 			panic("cannot alloc pcpu page for cpu %d", cpu);
-		pmap_qenter((vm_offset_t)&__pcpu[cpu], &m, 1);
+		pmap_qenter(&__pcpu[cpu], &m, 1);
 	}
 }
 

sys/amd64/amd64/pmap.c

@@ -2442,7 +2442,7 @@ pmap_init_pv_table(void)
 			vm_page_t m = vm_page_alloc_noobj_domain(domain, 0);
 			if (m == NULL)
 				panic("failed to allocate PV table page");
-			pmap_qenter((vm_offset_t)pvd + j, &m, 1);
+			pmap_qenter((char *)pvd + j, &m, 1);
 		}
 
 		for (j = 0; j < s / sizeof(*pvd); j++) {
@@ -3939,9 +3939,10 @@ pmap_map(vm_offset_t *virt, vm_paddr_t start, vm_paddr_t end, int prot)
  * Note: SMP coherent.  Uses a ranged shootdown IPI.
  */
 void
-pmap_qenter(vm_offset_t sva, vm_page_t *ma, int count)
+pmap_qenter(void *va, vm_page_t *ma, int count)
 {
 	pt_entry_t *endpte, oldpte, pa, *pte;
+	vm_offset_t sva = (vm_offset_t)va;
 	vm_page_t m;
 	int cache_bits;
 
@@ -3970,11 +3971,11 @@ pmap_qenter(vm_offset_t sva, vm_page_t *ma, int count)
  * Note: SMP coherent.  Uses a ranged shootdown IPI.
  */
 void
-pmap_qremove(vm_offset_t sva, int count)
+pmap_qremove(void *sva, int count)
 {
 	vm_offset_t va;
 
-	va = sva;
+	va = (vm_offset_t)sva;
 	while (count-- > 0) {
 		/*
 		 * pmap_enter() calls within the kernel virtual
@@ -3992,7 +3993,7 @@ pmap_qremove(vm_offset_t sva, int count)
 		pmap_kremove(va);
 		va += PAGE_SIZE;
 	}
-	pmap_invalidate_range(kernel_pmap, sva, va);
+	pmap_invalidate_range(kernel_pmap, (vm_offset_t)sva, va);
 }
 
 /***************************************************
@@ -9520,7 +9521,7 @@ pmap_unmapdev(void *p, vm_size_t size)
 		}
 	}
 	if (pmap_initialized) {
-		pmap_qremove(va, atop(size));
+		pmap_qremove((void *)va, atop(size));
 		kva_free(va, size);
 	}
 }
@@ -10545,7 +10546,7 @@ pmap_map_io_transient(vm_page_t page[], void *vaddr[], int count,
 				 * thread to the CPU and instead add a global
 				 * mapping visible to all CPUs.
 				 */
-				pmap_qenter((vm_offset_t)vaddr[i], &page[i], 1);
+				pmap_qenter(vaddr[i], &page[i], 1);
 			} else {
 				pmap_kenter_attr((vm_offset_t)vaddr[i], paddr,
 				    page[i]->md.pat_mode);
@@ -10570,7 +10571,7 @@ pmap_unmap_io_transient(vm_page_t page[], void *vaddr[], int count,
 		paddr = VM_PAGE_TO_PHYS(page[i]);
 		if (paddr >= dmaplimit) {
 			if (can_fault)
-				pmap_qremove((vm_offset_t)vaddr[i], 1);
+				pmap_qremove(vaddr[i], 1);
 			vmem_free(kernel_arena, (vm_offset_t)vaddr[i],
 			    PAGE_SIZE);
 		}

sys/arm/arm/mem.c

@@ -121,7 +121,7 @@ memrw(struct cdev *dev, struct uio *uio, int flags)
 			c = min(c, (u_int)(PAGE_SIZE - o));
 			c = min(c, (u_int)iov->iov_len);
 			error = uiomove((caddr_t)&_tmppt[o], (int)c, uio);
-			pmap_qremove((vm_offset_t)_tmppt, 1);
+			pmap_qremove(_tmppt, 1);
 			sx_xunlock(&tmppt_lock);
 			continue;
 		}

sys/arm/arm/pmap-v6.c

@@ -1819,8 +1819,9 @@ pmap_init(void)
  *  Note: SMP coherent.  Uses a ranged shootdown IPI.
  */
 void
-pmap_qenter(vm_offset_t sva, vm_page_t *ma, int count)
+pmap_qenter(void *va, vm_page_t *ma, int count)
 {
+	vm_offset_t sva = (vm_offset_t)va;
 	u_int anychanged;
 	pt2_entry_t *epte2p, *pte2p, pte2;
 	vm_page_t m;
@@ -1851,16 +1852,16 @@ pmap_qenter(vm_offset_t sva, vm_page_t *ma, int count)
  *  Note: SMP coherent.  Uses a ranged shootdown IPI.
  */
 void
-pmap_qremove(vm_offset_t sva, int count)
+pmap_qremove(void *sva, int count)
 {
 	vm_offset_t va;
 
-	va = sva;
+	va = (vm_offset_t)sva;
 	while (count-- > 0) {
 		pmap_kremove(va);
 		va += PAGE_SIZE;
 	}
-	tlb_flush_range(sva, va - sva);
+	tlb_flush_range((vm_offset_t)sva, va - (vm_offset_t)sva);
 }
 
 /*
@@ -2946,7 +2947,7 @@ pmap_pv_reclaim(pmap_t locked_pmap)
 			PV_STAT(pc_chunk_frees++);
 			/* Entire chunk is free; return it. */
 			m_pc = PHYS_TO_VM_PAGE(pmap_kextract((vm_offset_t)pc));
-			pmap_qremove((vm_offset_t)pc, 1);
+			pmap_qremove(pc, 1);
 			pmap_pte2list_free(&pv_vafree, (vm_offset_t)pc);
 			break;
 		}
@@ -2979,7 +2980,7 @@ free_pv_chunk(struct pv_chunk *pc)
 	PV_STAT(pc_chunk_frees++);
 	/* entire chunk is free, return it */
 	m = PHYS_TO_VM_PAGE(pmap_kextract((vm_offset_t)pc));
-	pmap_qremove((vm_offset_t)pc, 1);
+	pmap_qremove(pc, 1);
 	vm_page_unwire_noq(m);
 	vm_page_free(m);
 	pmap_pte2list_free(&pv_vafree, (vm_offset_t)pc);
@@ -3088,7 +3089,7 @@ get_pv_entry(pmap_t pmap, bool try)
 	PV_STAT(pc_chunk_count++);
 	PV_STAT(pc_chunk_allocs++);
 	pc = (struct pv_chunk *)pmap_pte2list_alloc(&pv_vafree);
-	pmap_qenter((vm_offset_t)pc, &m, 1);
+	pmap_qenter(pc, &m, 1);
 	pc->pc_pmap = pmap;
 	pc->pc_map[0] = pc_freemask[0] & ~1ul;	/* preallocated bit 0 */
 	for (field = 1; field < _NPCM; field++)

sys/arm/include/sf_buf.h

@@ -33,14 +33,14 @@ static inline void
 sf_buf_map(struct sf_buf *sf, int flags)
 {
 
-	pmap_qenter(sf->kva, &(sf->m), 1);
+	pmap_qenter((void *)sf->kva, &(sf->m), 1);
 }
 
 static inline int
 sf_buf_unmap(struct sf_buf *sf)
 {
 
-	pmap_qremove(sf->kva, 1);
+	pmap_qremove((void *)sf->kva, 1);
 	return (1);
 }
 #endif /* !_MACHINE_SF_BUF_H_ */

sys/arm/nvidia/drm2/tegra_bo.c

@@ -58,7 +58,7 @@ tegra_bo_destruct(struct tegra_bo *bo)
 
 	size = round_page(bo->gem_obj.size);
 	if (bo->vbase != 0)
-		pmap_qremove(bo->vbase, bo->npages);
+		pmap_qremove((void *)bo->vbase, bo->npages);
 
 	vm_page_iter_init(&pages, bo->cdev_pager);
 	VM_OBJECT_WLOCK(bo->cdev_pager);
@@ -166,7 +166,7 @@ tegra_bo_init_pager(struct tegra_bo *bo)
 	}
 	VM_OBJECT_WUNLOCK(bo->cdev_pager);
 
-	pmap_qenter(bo->vbase, bo->m, bo->npages);
+	pmap_qenter((void *)bo->vbase, bo->m, bo->npages);
 	return (0);
 }
 

sys/arm64/arm64/pmap.c

@@ -1649,7 +1649,7 @@ pmap_init_pv_table(void)
 			    VM_ALLOC_ZERO);
 			if (m == NULL)
 				panic("failed to allocate PV table page");
-			pmap_qenter((vm_offset_t)pvd + j, &m, 1);
+			pmap_qenter((char *)pvd + j, &m, 1);
 		}
 
 		for (j = 0; j < s / sizeof(*pvd); j++) {
@@ -2575,7 +2575,7 @@ pmap_map(vm_offset_t *virt, vm_paddr_t start, vm_paddr_t end, int prot)
  * Note: SMP coherent.  Uses a ranged shootdown IPI.
  */
 void
-pmap_qenter(vm_offset_t sva, vm_page_t *ma, int count)
+pmap_qenter(void *sva, vm_page_t *ma, int count)
 {
 	pd_entry_t *pde;
 	pt_entry_t attr, old_l3e, *pte;
@@ -2584,7 +2584,7 @@ pmap_qenter(vm_offset_t sva, vm_page_t *ma, int count)
 	int i, lvl;
 
 	old_l3e = 0;
-	va = sva;
+	va = (vm_offset_t)sva;
 	for (i = 0; i < count; i++) {
 		pde = pmap_pde(kernel_pmap, va, &lvl);
 		KASSERT(pde != NULL,
@@ -2602,7 +2602,8 @@ pmap_qenter(vm_offset_t sva, vm_page_t *ma, int count)
 		va += L3_SIZE;
 	}
 	if ((old_l3e & ATTR_DESCR_VALID) != 0)
-		pmap_s1_invalidate_range(kernel_pmap, sva, va, true);
+		pmap_s1_invalidate_range(kernel_pmap, (vm_offset_t)sva, va,
+		    true);
 	else {
 		/*
 		 * Because the old entries were invalid and the new mappings
@@ -2617,16 +2618,17 @@ pmap_qenter(vm_offset_t sva, vm_page_t *ma, int count)
  * kernel -- it is meant only for temporary mappings.
  */
 void
-pmap_qremove(vm_offset_t sva, int count)
+pmap_qremove(void *sva, int count)
 {
 	pt_entry_t *pte;
 	vm_offset_t va;
 
-	KASSERT(ADDR_IS_CANONICAL(sva),
-	    ("%s: Address not in canonical form: %lx", __func__, sva));
-	KASSERT(ADDR_IS_KERNEL(sva), ("usermode va %lx", sva));
+	va = (vm_offset_t)sva;
+
+	KASSERT(ADDR_IS_CANONICAL(va),
+	    ("%s: Address not in canonical form: %p", __func__, sva));
+	KASSERT(ADDR_IS_KERNEL(va), ("usermode va %p", sva));
 
-	va = sva;
 	while (count-- > 0) {
 		pte = pmap_pte_exists(kernel_pmap, va, 3, NULL);
 		if (pte != NULL) {
@@ -2635,7 +2637,7 @@ pmap_qremove(vm_offset_t sva, int count)
 
 		va += PAGE_SIZE;
 	}
-	pmap_s1_invalidate_range(kernel_pmap, sva, va, true);
+	pmap_s1_invalidate_range(kernel_pmap, (vm_offset_t)sva, va, true);
 }
 
 /***************************************************

sys/compat/linux/linux_vdso.c

@@ -64,12 +64,12 @@ __elfN(linux_shared_page_init)(char **mapping, vm_size_t size)
 {
 	vm_page_t m;
 	vm_object_t obj;
-	vm_offset_t addr;
+	char *addr;
 	size_t n, pages;
 
 	pages = size / PAGE_SIZE;
 
-	addr = kva_alloc(size);
+	addr = (char *)kva_alloc(size);
 	obj = vm_pager_allocate(OBJT_PHYS, 0, size,
 	    VM_PROT_DEFAULT, 0, NULL);
 	VM_OBJECT_WLOCK(obj);
@@ -81,7 +81,7 @@ __elfN(linux_shared_page_init)(char **mapping, vm_size_t size)
 		pmap_qenter(addr + n * PAGE_SIZE, &m, 1);
 	}
 	VM_OBJECT_WUNLOCK(obj);
-	*mapping = (char *)addr;
+	*mapping = addr;
 	return (obj);
 }
 
@@ -92,7 +92,7 @@ __elfN(linux_shared_page_fini)(vm_object_t obj, void *mapping,
 	vm_offset_t va;
 
 	va = (vm_offset_t)mapping;
-	pmap_qremove(va, size / PAGE_SIZE);
+	pmap_qremove(mapping, size / PAGE_SIZE);
 	kva_free(va, size);
 	vm_object_deallocate(obj);
 }

sys/compat/linuxkpi/common/src/linux_page.c

@@ -424,17 +424,17 @@ iounmap(void *addr)
 void *
 vmap(struct page **pages, unsigned int count, unsigned long flags, int prot)
 {
-	vm_offset_t off;
+	void *off;
 	size_t size;
 
 	size = count * PAGE_SIZE;
-	off = kva_alloc(size);
-	if (off == 0)
+	off = (void *)kva_alloc(size);
+	if (off == NULL)
 		return (NULL);
-	vmmap_add((void *)off, size);
+	vmmap_add(off, size);
 	pmap_qenter(off, pages, count);
 
-	return ((void *)off);
+	return (off);
 }
 
 #define	VMAP_MAX_CHUNK_SIZE (65536U / sizeof(struct vm_page)) /* KMEM_ZMAX */
@@ -443,17 +443,18 @@ void *
 linuxkpi_vmap_pfn(unsigned long *pfns, unsigned int count, int prot)
 {
 	vm_page_t m, *ma, fma;
-	vm_offset_t off, coff;
+	void *off;
+	char *coff;
 	vm_paddr_t pa;
 	vm_memattr_t attr;
 	size_t size;
 	unsigned int i, c, chunk;
 
 	size = ptoa(count);
-	off = kva_alloc(size);
-	if (off == 0)
+	off = (void *)kva_alloc(size);
+	if (off == NULL)
 		return (NULL);
-	vmmap_add((void *)off, size);
+	vmmap_add(off, size);
 
 	chunk = MIN(count, VMAP_MAX_CHUNK_SIZE);
 	attr = pgprot2cachemode(prot);
@@ -489,7 +490,7 @@ linuxkpi_vmap_pfn(unsigned long *pfns, unsigned int count, int prot)
 	free(fma, M_TEMP);
 	free(ma, M_TEMP);
 
-	return ((void *)off);
+	return (off);
 }
 
 void
@@ -500,7 +501,7 @@ vunmap(void *addr)
 	vmmap = vmmap_remove(addr);
 	if (vmmap == NULL)
 		return;
-	pmap_qremove((vm_offset_t)addr, vmmap->vm_size / PAGE_SIZE);
+	pmap_qremove(addr, vmmap->vm_size / PAGE_SIZE);
 	kva_free((vm_offset_t)addr, vmmap->vm_size);
 	kfree(vmmap);
 }

sys/dev/drm2/ttm/ttm_bo_util.c

@@ -517,7 +517,7 @@ static int ttm_bo_kmap_ttm(struct ttm_buffer_object *bo,
 				pmap_page_set_memattr(ttm->pages[start_page +
 				    i], prot);
 			}
-			pmap_qenter((vm_offset_t)map->virtual,
+			pmap_qenter(map->virtual,
 			    &ttm->pages[start_page], num_pages);
 		}
 	}
@@ -571,7 +571,7 @@ void ttm_bo_kunmap(struct ttm_bo_kmap_obj *map)
 		pmap_unmapdev(map->virtual, map->size);
 		break;
 	case ttm_bo_map_vmap:
-		pmap_qremove((vm_offset_t)(map->virtual), map->num_pages);
+		pmap_qremove(map->virtual, map->num_pages);
 		kva_free((vm_offset_t)map->virtual,
 		    map->num_pages * PAGE_SIZE);
 		break;

sys/dev/gve/gve_qpl.c

@@ -46,7 +46,7 @@ gve_free_qpl(struct gve_priv *priv, struct gve_queue_page_list *qpl)
 	}
 
 	if (qpl->kva) {
-		pmap_qremove(qpl->kva, qpl->num_pages);
+		pmap_qremove((void *)qpl->kva, qpl->num_pages);
 		kva_free(qpl->kva, PAGE_SIZE * qpl->num_pages);
 	}
 
@@ -59,7 +59,7 @@ gve_free_qpl(struct gve_priv *priv, struct gve_queue_page_list *qpl)
 		 */
 		if (vm_page_unwire_noq(qpl->pages[i])) {
 			if (!qpl->kva) {
-				pmap_qremove((vm_offset_t)qpl->dmas[i].cpu_addr, 1);
+				pmap_qremove(qpl->dmas[i].cpu_addr, 1);
 				kva_free((vm_offset_t)qpl->dmas[i].cpu_addr, PAGE_SIZE);
 			}
 			vm_page_free(qpl->pages[i]);
@@ -126,7 +126,7 @@ gve_alloc_qpl(struct gve_priv *priv, uint32_t id, int npages, bool single_kva)
 				err = ENOMEM;
 				goto abort;
 			}
-			pmap_qenter((vm_offset_t)qpl->dmas[i].cpu_addr, &(qpl->pages[i]), 1);
+			pmap_qenter(qpl->dmas[i].cpu_addr, &(qpl->pages[i]), 1);
 		} else
 			qpl->dmas[i].cpu_addr = (void *)(qpl->kva + (PAGE_SIZE * i));
 
@@ -135,7 +135,7 @@ gve_alloc_qpl(struct gve_priv *priv, uint32_t id, int npages, bool single_kva)
 	}
 
 	if (single_kva)
-		pmap_qenter(qpl->kva, qpl->pages, npages);
+		pmap_qenter((void *)qpl->kva, qpl->pages, npages);
 
 	for (i = 0; i < npages; i++) {
 		err = gve_dmamap_create(priv, /*size=*/PAGE_SIZE, /*align=*/PAGE_SIZE,
@@ -244,7 +244,7 @@ void
 gve_mextadd_free(struct mbuf *mbuf)
 {
 	vm_page_t page = (vm_page_t)mbuf->m_ext.ext_arg1;
-	vm_offset_t va = (vm_offset_t)mbuf->m_ext.ext_arg2;
+	void *va = mbuf->m_ext.ext_arg2;
 
 	/*
 	 * Free the page only if this is the last ref.
@@ -253,7 +253,7 @@ gve_mextadd_free(struct mbuf *mbuf)
 	 */
 	if (__predict_false(vm_page_unwire_noq(page))) {
 		pmap_qremove(va, 1);
-		kva_free(va, PAGE_SIZE);
+		kva_free((vm_offset_t)va, PAGE_SIZE);
 		vm_page_free(page);
 	}
 }

sys/dev/hwt/hwt_vm.c

@@ -171,7 +171,7 @@ hwt_vm_alloc_pages(struct hwt_vm *vm, int kva_req)
 		VM_OBJECT_WLOCK(vm->obj);
 		vm_page_insert(m, vm->obj, i);
 		if (kva_req)
-			pmap_qenter(vm->kvaddr + i * PAGE_SIZE, &m, 1);
+			pmap_qenter((char *)vm->kvaddr + i * PAGE_SIZE, &m, 1);
 		VM_OBJECT_WUNLOCK(vm->obj);
 	}
 
@@ -442,7 +442,7 @@ hwt_vm_destroy_buffers(struct hwt_vm *vm)
 	int i;
 
 	if (vm->ctx->hwt_backend->kva_req && vm->kvaddr != 0) {
-		pmap_qremove(vm->kvaddr, vm->npages);
+		pmap_qremove((void *)vm->kvaddr, vm->npages);
 		kva_free(vm->kvaddr, vm->npages * PAGE_SIZE);
 	}
 	VM_OBJECT_WLOCK(vm->obj);

sys/dev/md/md.c

@@ -286,7 +286,7 @@ struct md_s {
 		struct {
 			struct vnode *vnode;
 			char file[PATH_MAX];
-			vm_offset_t kva;
+			char *kva;
 		} s_vnode;
 
 		/* MD_SWAP related fields */
@@ -983,8 +983,7 @@ mdstart_vnode(struct md_s *sc, struct bio *bp)
 		    ("npages %d too large", npages));
 		pmap_qenter(sc->s_vnode.kva, &bp->bio_ma[atop(ma_offs)],
 		    npages);
-		aiov.iov_base = (void *)(sc->s_vnode.kva + (ma_offs &
-		    PAGE_MASK));
+		aiov.iov_base = sc->s_vnode.kva + (ma_offs & PAGE_MASK);
 		aiov.iov_len = iolen;
 		auio.uio_iov = &aiov;
 		auio.uio_iovcnt = 1;
@@ -1513,7 +1512,7 @@ mdcreate_vnode(struct md_s *sc, struct md_req *mdr, struct thread *td)
 		goto bad;
 	}
 
-	sc->s_vnode.kva = kva_alloc(maxphys + PAGE_SIZE);
+	sc->s_vnode.kva = (char *)kva_alloc(maxphys + PAGE_SIZE);
 	return (0);
 bad:
 	VOP_UNLOCK(nd.ni_vp);
@@ -1567,8 +1566,8 @@ mddestroy(struct md_s *sc, struct thread *td)
 			    sc->flags & MD_READONLY ?  FREAD : (FREAD|FWRITE),
 			    sc->cred, td);
 		}
-		if (sc->s_vnode.kva != 0)
-			kva_free(sc->s_vnode.kva, maxphys + PAGE_SIZE);
+		if (sc->s_vnode.kva != NULL)
+			kva_free((vm_offset_t)sc->s_vnode.kva, maxphys + PAGE_SIZE);
 		break;
 	case MD_SWAP:
 		if (sc->s_swap.object != NULL)

sys/dev/pci/controller/pci_n1sdp.c

@@ -83,7 +83,7 @@ static int
 n1sdp_init(struct generic_pcie_n1sdp_softc *sc)
 {
 	struct pcie_discovery_data *shared_data;
-	vm_offset_t vaddr;
+	void *vaddr;
 	vm_paddr_t paddr_rc;
 	vm_paddr_t paddr;
 	vm_page_t m[BDF_TABLE_SIZE / PAGE_SIZE];
@@ -100,8 +100,8 @@ n1sdp_init(struct generic_pcie_n1sdp_softc *sc)
 		MPASS(m[i] != NULL);
 	}
 
-	vaddr = kva_alloc((vm_size_t)BDF_TABLE_SIZE);
-	if (vaddr == 0) {
+	vaddr = (void *)kva_alloc((vm_size_t)BDF_TABLE_SIZE);
+	if (vaddr == NULL) {
 		printf("%s: Can't allocate KVA memory.", __func__);
 		error = ENXIO;
 		goto out;
@@ -130,7 +130,7 @@ n1sdp_init(struct generic_pcie_n1sdp_softc *sc)
 
 out_pmap:
 	pmap_qremove(vaddr, nitems(m));
-	kva_free(vaddr, (vm_size_t)BDF_TABLE_SIZE);
+	kva_free((vm_offset_t)vaddr, (vm_size_t)BDF_TABLE_SIZE);
 
 out:
 	vm_phys_fictitious_unreg_range(paddr, paddr + BDF_TABLE_SIZE);

sys/dev/spibus/spigen.c

@@ -73,7 +73,7 @@ struct spigen_softc {
 
 struct spigen_mmap {
 	vm_object_t bufobj;
-	vm_offset_t kvaddr;
+	void	   *kvaddr;
 	size_t      bufsize;
 };
 
@@ -235,10 +235,10 @@ spigen_transfer_mmapped(struct cdev *cdev, struct spigen_transfer_mmapped *stm)
 	if (mmap->bufsize < stm->stm_command_length + stm->stm_data_length)
 		return (E2BIG);
 
-	transfer.tx_cmd = transfer.rx_cmd = (void *)((uintptr_t)mmap->kvaddr);
+	transfer.tx_cmd = transfer.rx_cmd = mmap->kvaddr;
 	transfer.tx_cmd_sz = transfer.rx_cmd_sz = stm->stm_command_length;
 	transfer.tx_data = transfer.rx_data =
-	    (void *)((uintptr_t)mmap->kvaddr + stm->stm_command_length);
+	    (void *)((char *)mmap->kvaddr + stm->stm_command_length);
 	transfer.tx_data_sz = transfer.rx_data_sz = stm->stm_data_length;
 	error = SPIBUS_TRANSFER(device_get_parent(dev), dev, &transfer);
 
@@ -283,9 +283,9 @@ spigen_mmap_cleanup(void *arg)
 {
 	struct spigen_mmap *mmap = arg;
 
-	if (mmap->kvaddr != 0) {
+	if (mmap->kvaddr != NULL) {
 		pmap_qremove(mmap->kvaddr, mmap->bufsize / PAGE_SIZE);
-		kva_free(mmap->kvaddr, mmap->bufsize);
+		kva_free((vm_offset_t)mmap->kvaddr, mmap->bufsize);
 	}
 	if (mmap->bufobj != NULL)
 		vm_object_deallocate(mmap->bufobj);
@@ -312,7 +312,7 @@ spigen_mmap_single(struct cdev *cdev, vm_ooffset_t *offset,
 		return (EBUSY);
 
 	mmap = malloc(sizeof(*mmap), M_DEVBUF, M_ZERO | M_WAITOK);
-	if ((mmap->kvaddr = kva_alloc(size)) == 0) {
+	if ((mmap->kvaddr = (void *)kva_alloc(size)) == 0) {
 		spigen_mmap_cleanup(mmap);
 		return (ENOMEM);
 	}

sys/fs/nfsclient/nfs_clbio.c

@@ -116,7 +116,7 @@ ncl_getpages(struct vop_getpages_args *ap)
 	int i, error, nextoff, size, toff, count, npages;
 	struct uio uio;
 	struct iovec iov;
-	vm_offset_t kva;
+	void *kva;
 	struct buf *bp;
 	struct vnode *vp;
 	struct thread *td;
@@ -180,13 +180,13 @@ ncl_getpages(struct vop_getpages_args *ap)
 	 */
 	bp = uma_zalloc(ncl_pbuf_zone, M_WAITOK);
 
-	kva = (vm_offset_t) bp->b_data;
+	kva = bp->b_data;
 	pmap_qenter(kva, pages, npages);
 	VM_CNT_INC(v_vnodein);
 	VM_CNT_ADD(v_vnodepgsin, npages);
 
 	count = npages << PAGE_SHIFT;
-	iov.iov_base = (caddr_t) kva;
+	iov.iov_base = kva;
 	iov.iov_len = count;
 	uio.uio_iov = &iov;
 	uio.uio_iovcnt = 1;

sys/fs/p9fs/p9fs_vnops.c

@@ -2179,7 +2179,7 @@ p9fs_putpages(struct vop_putpages_args *ap)
 	struct ucred *cred;
 	struct p9fs_node *np;
 	vm_page_t *pages;
-	vm_offset_t kva;
+	void *kva;
 	struct buf *bp;
 
 	vp = ap->a_vp;
@@ -2205,13 +2205,13 @@ p9fs_putpages(struct vop_putpages_args *ap)
 		rtvals[i] = VM_PAGER_ERROR;
 
 	bp = uma_zalloc(p9fs_pbuf_zone, M_WAITOK);
-	kva = (vm_offset_t) bp->b_data;
+	kva = bp->b_data;
 	pmap_qenter(kva, pages, npages);
 
 	VM_CNT_INC(v_vnodeout);
 	VM_CNT_ADD(v_vnodepgsout, count);
 
-	iov.iov_base = (caddr_t) kva;
+	iov.iov_base = kva;
 	iov.iov_len = count;
 	uio.uio_iov = &iov;
 	uio.uio_iovcnt = 1;

sys/fs/smbfs/smbfs_io.c

@@ -425,7 +425,7 @@ smbfs_getpages(struct vop_getpages_args *ap)
 	int i, error, nextoff, size, toff, npages, count;
 	struct uio uio;
 	struct iovec iov;
-	vm_offset_t kva;
+	void *kva;
 	struct buf *bp;
 	struct vnode *vp;
 	struct thread *td;
@@ -466,13 +466,13 @@ smbfs_getpages(struct vop_getpages_args *ap)
 
 	bp = uma_zalloc(smbfs_pbuf_zone, M_WAITOK);
 
-	kva = (vm_offset_t) bp->b_data;
+	kva = bp->b_data;
 	pmap_qenter(kva, pages, npages);
 	VM_CNT_INC(v_vnodein);
 	VM_CNT_ADD(v_vnodepgsin, npages);
 
 	count = npages << PAGE_SHIFT;
-	iov.iov_base = (caddr_t) kva;
+	iov.iov_base = kva;
 	iov.iov_len = count;
 	uio.uio_iov = &iov;
 	uio.uio_iovcnt = 1;
@@ -559,7 +559,7 @@ smbfs_putpages(struct vop_putpages_args *ap)
 #else
 	struct uio uio;
 	struct iovec iov;
-	vm_offset_t kva;
+	void *kva;
 	struct buf *bp;
 	int i, npages, count;
 	int *rtvals;
@@ -584,12 +584,12 @@ smbfs_putpages(struct vop_putpages_args *ap)
 
 	bp = uma_zalloc(smbfs_pbuf_zone, M_WAITOK);
 
-	kva = (vm_offset_t) bp->b_data;
+	kva = bp->b_data;
 	pmap_qenter(kva, pages, npages);
 	VM_CNT_INC(v_vnodeout);
 	VM_CNT_ADD(v_vnodepgsout, count);
 
-	iov.iov_base = (caddr_t) kva;
+	iov.iov_base = kva;
 	iov.iov_len = count;
 	uio.uio_iov = &iov;
 	uio.uio_iovcnt = 1;

sys/geom/geom_io.c

@@ -782,7 +782,7 @@ g_io_transient_map_bio(struct bio *bp)
 		}
 	}
 	atomic_add_int(&inflight_transient_maps, 1);
-	pmap_qenter((vm_offset_t)addr, bp->bio_ma, OFF_TO_IDX(size));
+	pmap_qenter((void *)addr, bp->bio_ma, OFF_TO_IDX(size));
 	bp->bio_data = (caddr_t)addr + bp->bio_ma_offset;
 	bp->bio_flags |= BIO_TRANSIENT_MAPPING;
 	bp->bio_flags &= ~BIO_UNMAPPED;

sys/i386/i386/mem.c

@@ -142,7 +142,7 @@ memrw(struct cdev *dev, struct uio *uio, int flags)
 		c = PAGE_SIZE - o;
 		c = min(c, (u_int)iov->iov_len);
 		error = uiomove((caddr_t)&ptvmmap[o], (int)c, uio);
-		pmap_qremove((vm_offset_t)ptvmmap, 1);
+		pmap_qremove(ptvmmap, 1);
 		sx_xunlock(&memsxlock);
 	}
 

sys/i386/i386/pmap.c

@@ -1845,11 +1845,13 @@ __CONCAT(PMTYPE, map)(vm_offset_t *virt, vm_paddr_t start, vm_paddr_t end,
  * Note: SMP coherent.  Uses a ranged shootdown IPI.
  */
 static void
-__CONCAT(PMTYPE, qenter)(vm_offset_t sva, vm_page_t *ma, int count)
+__CONCAT(PMTYPE, qenter)(void *va, vm_page_t *ma, int count)
 {
+	vm_offset_t sva;
 	pt_entry_t *endpte, oldpte, pa, *pte;
 	vm_page_t m;
 
+	sva = (vm_offset_t)va;
 	oldpte = 0;
 	pte = vtopte(sva);
 	endpte = pte + count;
@@ -1874,16 +1876,16 @@ __CONCAT(PMTYPE, qenter)(vm_offset_t sva, vm_page_t *ma, int count)
  * Note: SMP coherent.  Uses a ranged shootdown IPI.
  */
 static void
-__CONCAT(PMTYPE, qremove)(vm_offset_t sva, int count)
+__CONCAT(PMTYPE, qremove)(void *sva, int count)
 {
 	vm_offset_t va;
 
-	va = sva;
+	va = (vm_offset_t)sva;
 	while (count-- > 0) {
 		pmap_kremove(va);
 		va += PAGE_SIZE;
 	}
-	pmap_invalidate_range_int(kernel_pmap, sva, va);
+	pmap_invalidate_range_int(kernel_pmap, (vm_offset_t)sva, va);
 }
 
 /***************************************************
@@ -2085,7 +2087,7 @@ __CONCAT(PMTYPE, pinit)(pmap_t pmap)
 #endif
 	}
 
-	pmap_qenter((vm_offset_t)pmap->pm_pdir, pmap->pm_ptdpg, NPGPTD);
+	pmap_qenter(pmap->pm_pdir, pmap->pm_ptdpg, NPGPTD);
 #ifdef PMAP_PAE_COMP
 	if ((cpu_feature & CPUID_PAT) == 0) {
 		pmap_invalidate_cache_range(
@@ -2220,7 +2222,7 @@ __CONCAT(PMTYPE, release)(pmap_t pmap)
 	KASSERT(CPU_EMPTY(&pmap->pm_active),
 	    ("releasing active pmap %p", pmap));
 
-	pmap_qremove((vm_offset_t)pmap->pm_pdir, NPGPTD);
+	pmap_qremove(pmap->pm_pdir, NPGPTD);
 
 	for (i = 0; i < NPGPTD; i++) {
 		m = pmap->pm_ptdpg[i];
@@ -2414,7 +2416,7 @@ pmap_pv_reclaim(pmap_t locked_pmap)
 			PV_STAT(pc_chunk_frees++);
 			/* Entire chunk is free; return it. */
 			m_pc = PHYS_TO_VM_PAGE(pmap_kextract((vm_offset_t)pc));
-			pmap_qremove((vm_offset_t)pc, 1);
+			pmap_qremove(pc, 1);
 			pmap_ptelist_free(&pv_vafree, (vm_offset_t)pc);
 			break;
 		}
@@ -2484,7 +2486,7 @@ free_pv_chunk(struct pv_chunk *pc)
 	PV_STAT(pc_chunk_frees++);
 	/* entire chunk is free, return it */
 	m = PHYS_TO_VM_PAGE(pmap_kextract((vm_offset_t)pc));
-	pmap_qremove((vm_offset_t)pc, 1);
+	pmap_qremove(pc, 1);
 	vm_page_unwire_noq(m);
 	vm_page_free(m);
 	pmap_ptelist_free(&pv_vafree, (vm_offset_t)pc);
@@ -2556,7 +2558,7 @@ get_pv_entry(pmap_t pmap, bool try)
 	PV_STAT(pc_chunk_count++);
 	PV_STAT(pc_chunk_allocs++);
 	pc = (struct pv_chunk *)pmap_ptelist_alloc(&pv_vafree);
-	pmap_qenter((vm_offset_t)pc, &m, 1);
+	pmap_qenter(pc, &m, 1);
 	pc->pc_pmap = pmap;
 	pc->pc_map[0] = pc_freemask[0] & ~1ul;	/* preallocated bit 0 */
 	for (field = 1; field < _NPCM; field++)
@@ -5608,7 +5610,7 @@ __CONCAT(PMTYPE, unmapdev)(void *p, vm_size_t size)
 		}
 	}
 	if (pmap_initialized) {
-		pmap_qremove(va, atop(size));
+		pmap_qremove((void *)va, atop(size));
 		kva_free(va, size);
 	}
 }

sys/i386/i386/pmap_base.c

@@ -844,14 +844,14 @@ pmap_map(vm_offset_t *virt, vm_paddr_t start, vm_paddr_t end, int prot)
 }
 
 void
-pmap_qenter(vm_offset_t sva, vm_page_t *ma, int count)
+pmap_qenter(void *sva, vm_page_t *ma, int count)
 {
 
 	pmap_methods_ptr->pm_qenter(sva, ma, count);
 }
 
 void
-pmap_qremove(vm_offset_t sva, int count)
+pmap_qremove(void *sva, int count)
 {
 
 	pmap_methods_ptr->pm_qremove(sva, count);

sys/i386/i386/vm_machdep.c

@@ -622,7 +622,7 @@ sf_buf_invalidate(struct sf_buf *sf)
 	 * existing mapping, in particular, the PAT
 	 * settings are recalculated.
 	 */
-	pmap_qenter(sf->kva, &m, 1);
+	pmap_qenter((void *)sf->kva, &m, 1);
 	pmap_invalidate_cache_range(sf->kva, sf->kva + PAGE_SIZE);
 }
 

sys/i386/include/pmap_base.h

@@ -99,8 +99,8 @@ struct pmap_methods {
 	vm_paddr_t (*pm_extract)(pmap_t, vm_offset_t);
 	vm_page_t (*pm_extract_and_hold)(pmap_t, vm_offset_t, vm_prot_t);
 	vm_offset_t (*pm_map)(vm_offset_t *, vm_paddr_t, vm_paddr_t, int);
-	void (*pm_qenter)(vm_offset_t sva, vm_page_t *, int);
-	void (*pm_qremove)(vm_offset_t, int);
+	void (*pm_qenter)(void *sva, vm_page_t *, int);
+	void (*pm_qremove)(void *, int);
 	void (*pm_release)(pmap_t);
 	void (*pm_protect)(pmap_t, vm_offset_t, vm_offset_t, vm_prot_t);
 	void (*pm_remove)(pmap_t, vm_offset_t, vm_offset_t);

sys/kern/kern_kcov.c

@@ -124,7 +124,7 @@ typedef enum {
 struct kcov_info {
 	struct thread	*thread;	/* (l) */
 	vm_object_t	bufobj;		/* (o) */
-	vm_offset_t	kvaddr;		/* (o) */
+	void		*kvaddr;	/* (o) */
 	size_t		entries;	/* (o) */
 	size_t		bufsize;	/* (o) */
 	kcov_state_t	state;		/* (s) */
@@ -206,9 +206,9 @@ trace_pc(uintptr_t ret)
 	if (info->mode != KCOV_MODE_TRACE_PC)
 		return;
 
-	KASSERT(info->kvaddr != 0, ("%s: NULL buf while running", __func__));
+	KASSERT(info->kvaddr != NULL, ("%s: NULL buf while running", __func__));
 
-	buf = (uint64_t *)info->kvaddr;
+	buf = info->kvaddr;
 
 	/* The first entry of the buffer holds the index */
 	index = buf[0];
@@ -237,9 +237,9 @@ trace_cmp(uint64_t type, uint64_t arg1, uint64_t arg2, uint64_t ret)
 	if (info->mode != KCOV_MODE_TRACE_CMP)
 		return (false);
 
-	KASSERT(info->kvaddr != 0, ("%s: NULL buf while running", __func__));
+	KASSERT(info->kvaddr != NULL, ("%s: NULL buf while running", __func__));
 
-	buf = (uint64_t *)info->kvaddr;
+	buf = info->kvaddr;
 
 	/* The first entry of the buffer holds the index */
 	index = buf[0];
@@ -347,7 +347,7 @@ kcov_mmap_single(struct cdev *dev, vm_ooffset_t *offset, vm_size_t size,
 	if ((error = devfs_get_cdevpriv((void **)&info)) != 0)
 		return (error);
 
-	if (info->kvaddr == 0 || size / KCOV_ELEMENT_SIZE != info->entries)
+	if (info->kvaddr == NULL || size / KCOV_ELEMENT_SIZE != info->entries)
 		return (EINVAL);
 
 	vm_object_reference(info->bufobj);
@@ -362,7 +362,7 @@ kcov_alloc(struct kcov_info *info, size_t entries)
 	size_t n, pages;
 	vm_page_t m;
 
-	KASSERT(info->kvaddr == 0, ("kcov_alloc: Already have a buffer"));
+	KASSERT(info->kvaddr == NULL, ("kcov_alloc: Already have a buffer"));
 	KASSERT(info->state == KCOV_STATE_OPEN,
 	    ("kcov_alloc: Not in open state (%x)", info->state));
 
@@ -373,7 +373,7 @@ kcov_alloc(struct kcov_info *info, size_t entries)
 	info->bufsize = roundup2(entries * KCOV_ELEMENT_SIZE, PAGE_SIZE);
 	pages = info->bufsize / PAGE_SIZE;
 
-	if ((info->kvaddr = kva_alloc(info->bufsize)) == 0)
+	if ((info->kvaddr = (void *)kva_alloc(info->bufsize)) == 0)
 		return (ENOMEM);
 
 	info->bufobj = vm_pager_allocate(OBJT_PHYS, 0, info->bufsize,
@@ -385,7 +385,7 @@ kcov_alloc(struct kcov_info *info, size_t entries)
 		    VM_ALLOC_ZERO | VM_ALLOC_WIRED);
 		vm_page_valid(m);
 		vm_page_xunbusy(m);
-		pmap_qenter(info->kvaddr + n * PAGE_SIZE, &m, 1);
+		pmap_qenter((char *)info->kvaddr + n * PAGE_SIZE, &m, 1);
 	}
 	VM_OBJECT_WUNLOCK(info->bufobj);
 
@@ -400,9 +400,9 @@ kcov_free(struct kcov_info *info)
 	struct pctrie_iter pages;
 	vm_page_t m;
 
-	if (info->kvaddr != 0) {
+	if (info->kvaddr != NULL) {
 		pmap_qremove(info->kvaddr, info->bufsize / PAGE_SIZE);
-		kva_free(info->kvaddr, info->bufsize);
+		kva_free((vm_offset_t)info->kvaddr, info->bufsize);
 	}
 	if (info->bufobj != NULL) {
 		vm_page_iter_limit_init(&pages, info->bufobj,

sys/kern/kern_physio.c

@@ -158,8 +158,7 @@ physio(struct cdev *dev, struct uio *uio, int ioflag)
 				}
 				poff = (vm_offset_t)base & PAGE_MASK;
 				if (pbuf && sa) {
-					pmap_qenter((vm_offset_t)sa,
-					    pages, npages);
+					pmap_qenter(sa, pages, npages);
 					bp->bio_data = sa + poff;
 				} else {
 					bp->bio_ma = pages;
@@ -179,7 +178,7 @@ physio(struct cdev *dev, struct uio *uio, int ioflag)
 
 			if (pages) {
 				if (pbuf)
-					pmap_qremove((vm_offset_t)sa, npages);
+					pmap_qremove(sa, npages);
 				vm_page_unhold_pages(pages, npages);
 			}
 

sys/kern/kern_sharedpage.c

@@ -115,7 +115,7 @@ static void
 shared_page_init(void *dummy __unused)
 {
 	vm_page_t m;
-	vm_offset_t addr;
+	void *addr;
 
 	sx_init(&shared_page_alloc_sx, "shpsx");
 	shared_page_obj = vm_pager_allocate(OBJT_PHYS, 0, PAGE_SIZE,
@@ -125,9 +125,9 @@ shared_page_init(void *dummy __unused)
 	VM_OBJECT_WUNLOCK(shared_page_obj);
 	vm_page_valid(m);
 	vm_page_xunbusy(m);
-	addr = kva_alloc(PAGE_SIZE);
+	addr = (void *)kva_alloc(PAGE_SIZE);
 	pmap_qenter(addr, &m, 1);
-	shared_page_mapping = (char *)addr;
+	shared_page_mapping = addr;
 }
 
 SYSINIT(shp, SI_SUB_EXEC, SI_ORDER_FIRST, shared_page_init, NULL);

sys/kern/vfs_aio.c

@@ -1341,7 +1341,7 @@ aio_qbio(struct proc *p, struct kaiocb *job)
 			goto destroy_bios;
 		}
 		if (pbuf != NULL) {
-			pmap_qenter((vm_offset_t)pbuf->b_data, pages, npages);
+			pmap_qenter(pbuf->b_data, pages, npages);
 			bp->bio_data = pbuf->b_data + poff;
 			pbuf->b_npages = npages;
 			atomic_add_int(&num_buf_aio, 1);
@@ -2462,7 +2462,7 @@ aio_biocleanup(struct bio *bp)
 	/* Release mapping into kernel space. */
 	if (pbuf != NULL) {
 		MPASS(pbuf->b_npages <= atop(maxphys) + 1);
-		pmap_qremove((vm_offset_t)pbuf->b_data, pbuf->b_npages);
+		pmap_qremove(pbuf->b_data, pbuf->b_npages);
 		vm_page_unhold_pages(pbuf->b_pages, pbuf->b_npages);
 		uma_zfree(pbuf_zone, pbuf);
 		atomic_subtract_int(&num_buf_aio, 1);

sys/kern/vfs_bio.c

@@ -1536,10 +1536,9 @@ bpmap_qenter(struct buf *bp)
 	 * bp->b_data is relative to bp->b_offset, but
 	 * bp->b_offset may be offset into the first page.
 	 */
-	bp->b_data = (caddr_t)trunc_page((vm_offset_t)bp->b_data);
-	pmap_qenter((vm_offset_t)bp->b_data, bp->b_pages, bp->b_npages);
-	bp->b_data = (caddr_t)((vm_offset_t)bp->b_data |
-	    (vm_offset_t)(bp->b_offset & PAGE_MASK));
+	bp->b_data = trunc_page(bp->b_data);
+	pmap_qenter(bp->b_data, bp->b_pages, bp->b_npages);
+	bp->b_data += (bp->b_offset & PAGE_MASK);
 }
 
 static inline struct bufdomain *
@@ -3018,8 +3017,7 @@ vfs_vmio_iodone(struct buf *bp)
 	vm_object_pip_wakeupn(obj, bp->b_npages);
 	if (bogus && buf_mapped(bp)) {
 		BUF_CHECK_MAPPED(bp);
-		pmap_qenter(trunc_page((vm_offset_t)bp->b_data),
-		    bp->b_pages, bp->b_npages);
+		pmap_qenter(trunc_page(bp->b_data), bp->b_pages, bp->b_npages);
 	}
 }
 
@@ -3036,7 +3034,7 @@ vfs_vmio_invalidate(struct buf *bp)
 
 	if (buf_mapped(bp)) {
 		BUF_CHECK_MAPPED(bp);
-		pmap_qremove(trunc_page((vm_offset_t)bp->b_data), bp->b_npages);
+		pmap_qremove(trunc_page((char *)bp->b_data), bp->b_npages);
 	} else
 		BUF_CHECK_UNMAPPED(bp);
 	/*
@@ -3092,7 +3090,7 @@ vfs_vmio_truncate(struct buf *bp, int desiredpages)
 
 	if (buf_mapped(bp)) {
 		BUF_CHECK_MAPPED(bp);
-		pmap_qremove((vm_offset_t)trunc_page((vm_offset_t)bp->b_data) +
+		pmap_qremove(trunc_page(bp->b_data) +
 		    (desiredpages << PAGE_SHIFT), bp->b_npages - desiredpages);
 	} else
 		BUF_CHECK_UNMAPPED(bp);
@@ -4490,7 +4488,7 @@ biodone(struct bio *bp)
 		start = trunc_page((vm_offset_t)bp->bio_data);
 		end = round_page((vm_offset_t)bp->bio_data + bp->bio_length);
 		bp->bio_data = unmapped_buf;
-		pmap_qremove(start, atop(end - start));
+		pmap_qremove((void *)start, atop(end - start));
 		vmem_free(transient_arena, start, end - start);
 		atomic_add_int(&inflight_transient_maps, -1);
 	}
@@ -4687,7 +4685,7 @@ vfs_unbusy_pages(struct buf *bp)
 			bp->b_pages[i] = m;
 			if (buf_mapped(bp)) {
 				BUF_CHECK_MAPPED(bp);
-				pmap_qenter(trunc_page((vm_offset_t)bp->b_data),
+				pmap_qenter(trunc_page(bp->b_data),
 				    bp->b_pages, bp->b_npages);
 			} else
 				BUF_CHECK_UNMAPPED(bp);
@@ -4850,8 +4848,7 @@ vfs_busy_pages(struct buf *bp, int clear_modify)
 	}
 	if (bogus && buf_mapped(bp)) {
 		BUF_CHECK_MAPPED(bp);
-		pmap_qenter(trunc_page((vm_offset_t)bp->b_data),
-		    bp->b_pages, bp->b_npages);
+		pmap_qenter(trunc_page(bp->b_data), bp->b_pages, bp->b_npages);
 	}
 }
 
@@ -5051,7 +5048,7 @@ vm_hold_load_pages(struct buf *bp, vm_offset_t from, vm_offset_t to)
 		 */
 		p = vm_page_alloc_noobj(VM_ALLOC_SYSTEM | VM_ALLOC_WIRED |
 		    VM_ALLOC_COUNT((to - pg) >> PAGE_SHIFT) | VM_ALLOC_WAITOK);
-		pmap_qenter(pg, &p, 1);
+		pmap_qenter((void *)pg, &p, 1);
 		bp->b_pages[index] = p;
 	}
 	bp->b_npages = index;
@@ -5061,14 +5058,14 @@ vm_hold_load_pages(struct buf *bp, vm_offset_t from, vm_offset_t to)
 static void
 vm_hold_free_pages(struct buf *bp, int newbsize)
 {
-	vm_offset_t from;
+	char *from;
 	vm_page_t p;
 	int index, newnpages;
 
 	BUF_CHECK_MAPPED(bp);
 
-	from = round_page((vm_offset_t)bp->b_data + newbsize);
-	newnpages = (from - trunc_page((vm_offset_t)bp->b_data)) >> PAGE_SHIFT;
+	from = round_page(bp->b_data + newbsize);
+	newnpages = (from - trunc_page(bp->b_data)) >> PAGE_SHIFT;
 	if (bp->b_npages > newnpages)
 		pmap_qremove(from, bp->b_npages - newnpages);
 	for (index = newnpages; index < bp->b_npages; index++) {
@@ -5112,7 +5109,7 @@ vmapbuf(struct buf *bp, void *uaddr, size_t len, int mapbuf)
 	bp->b_npages = pidx;
 	bp->b_offset = ((vm_offset_t)uaddr) & PAGE_MASK;
 	if (mapbuf || !unmapped_buf_allowed) {
-		pmap_qenter((vm_offset_t)bp->b_kvabase, bp->b_pages, pidx);
+		pmap_qenter(bp->b_kvabase, bp->b_pages, pidx);
 		bp->b_data = bp->b_kvabase + bp->b_offset;
 	} else
 		bp->b_data = unmapped_buf;
@@ -5132,7 +5129,7 @@ vunmapbuf(struct buf *bp)
 
 	npages = bp->b_npages;
 	if (buf_mapped(bp))
-		pmap_qremove(trunc_page((vm_offset_t)bp->b_data), npages);
+		pmap_qremove(trunc_page(bp->b_data), npages);
 	vm_page_unhold_pages(bp->b_pages, npages);
 
 	bp->b_data = unmapped_buf;

sys/kern/vfs_cluster.c

@@ -539,8 +539,7 @@ cluster_rbuild(struct vnode *vp, u_quad_t filesize, daddr_t lbn,
 		    bp->b_bufsize, bp->b_kvasize);
 
 	if (buf_mapped(bp)) {
-		pmap_qenter(trunc_page((vm_offset_t) bp->b_data),
-		    (vm_page_t *)bp->b_pages, bp->b_npages);
+		pmap_qenter(trunc_page(bp->b_data), bp->b_pages, bp->b_npages);
 	}
 	return (bp);
 }
@@ -564,8 +563,7 @@ cluster_callback(struct buf *bp)
 		error = bp->b_error;
 
 	if (buf_mapped(bp)) {
-		pmap_qremove(trunc_page((vm_offset_t) bp->b_data),
-		    bp->b_npages);
+		pmap_qremove(trunc_page(bp->b_data), bp->b_npages);
 	}
 	/*
 	 * Move memory from the large cluster buffer into the component
@@ -1020,8 +1018,8 @@ cluster_wbuild(struct vnode *vp, long size, daddr_t start_lbn, int len,
 		}
 	finishcluster:
 		if (buf_mapped(bp)) {
-			pmap_qenter(trunc_page((vm_offset_t) bp->b_data),
-			    (vm_page_t *)bp->b_pages, bp->b_npages);
+			pmap_qenter(trunc_page(bp->b_data), bp->b_pages,
+			    bp->b_npages);
 		}
 		if (bp->b_bufsize > bp->b_kvasize)
 			panic(

sys/powerpc/aim/mmu_oea.c

@@ -299,8 +299,8 @@ int moea_page_wired_mappings(vm_page_t);
 int moea_pinit(pmap_t);
 void moea_pinit0(pmap_t);
 void moea_protect(pmap_t, vm_offset_t, vm_offset_t, vm_prot_t);
-void moea_qenter(vm_offset_t, vm_page_t *, int);
-void moea_qremove(vm_offset_t, int);
+void moea_qenter(void *, vm_page_t *, int);
+void moea_qremove(void *, int);
 void moea_release(pmap_t);
 void moea_remove(pmap_t, vm_offset_t, vm_offset_t);
 void moea_remove_all(vm_page_t);
@@ -1846,11 +1846,11 @@ moea_protect(pmap_t pm, vm_offset_t sva, vm_offset_t eva,
  * references recorded.  Existing mappings in the region are overwritten.
  */
 void
-moea_qenter(vm_offset_t sva, vm_page_t *m, int count)
+moea_qenter(void *sva, vm_page_t *m, int count)
 {
 	vm_offset_t va;
 
-	va = sva;
+	va = (vm_offset_t)sva;
 	while (count-- > 0) {
 		moea_kenter(va, VM_PAGE_TO_PHYS(*m));
 		va += PAGE_SIZE;
@@ -1863,11 +1863,11 @@ moea_qenter(vm_offset_t sva, vm_page_t *m, int count)
  * temporary mappings entered by moea_qenter.
  */
 void
-moea_qremove(vm_offset_t sva, int count)
+moea_qremove(void *sva, int count)
 {
 	vm_offset_t va;
 
-	va = sva;
+	va = (vm_offset_t)sva;
 	while (count-- > 0) {
 		moea_kremove(va);
 		va += PAGE_SIZE;

sys/powerpc/aim/mmu_oea64.c

@@ -379,8 +379,8 @@ int moea64_page_wired_mappings(vm_page_t);
 int moea64_pinit(pmap_t);
 void moea64_pinit0(pmap_t);
 void moea64_protect(pmap_t, vm_offset_t, vm_offset_t, vm_prot_t);
-void moea64_qenter(vm_offset_t, vm_page_t *, int);
-void moea64_qremove(vm_offset_t, int);
+void moea64_qenter(void *, vm_page_t *, int);
+void moea64_qremove(void *, int);
 void moea64_release(pmap_t);
 void moea64_remove(pmap_t, vm_offset_t, vm_offset_t);
 void moea64_remove_pages(pmap_t);
@@ -2603,8 +2603,11 @@ moea64_protect(pmap_t pm, vm_offset_t sva, vm_offset_t eva,
  * references recorded.  Existing mappings in the region are overwritten.
  */
 void
-moea64_qenter(vm_offset_t va, vm_page_t *m, int count)
+moea64_qenter(void *sva, vm_page_t *m, int count)
 {
+	vm_offset_t va;
+
+	va = (vm_offset_t)sva;
 	while (count-- > 0) {
 		moea64_kenter(va, VM_PAGE_TO_PHYS(*m));
 		va += PAGE_SIZE;
@@ -2617,8 +2620,11 @@ moea64_qenter(vm_offset_t va, vm_page_t *m, int count)
  * temporary mappings entered by moea64_qenter.
  */
 void
-moea64_qremove(vm_offset_t va, int count)
+moea64_qremove(void *sva, int count)
 {
+	vm_offset_t va;
+
+	va = (vm_offset_t)sva;
 	while (count-- > 0) {
 		moea64_kremove(va);
 		va += PAGE_SIZE;
@@ -3180,15 +3186,16 @@ moea64_mapdev(vm_paddr_t pa, vm_size_t size)
 void
 moea64_unmapdev(void *p, vm_size_t size)
 {
-	vm_offset_t base, offset, va;
+	void *base;
+	vm_offset_t offset, va;
 
 	va = (vm_offset_t)p;
-	base = trunc_page(va);
+	base = trunc_page(p);
 	offset = va & PAGE_MASK;
 	size = roundup2(offset + size, PAGE_SIZE);
 
 	moea64_qremove(base, atop(size));
-	kva_free(base, size);
+	kva_free((vm_offset_t)base, size);
 }
 
 void

sys/powerpc/aim/mmu_radix.c

@@ -452,8 +452,8 @@ int mmu_radix_page_wired_mappings(vm_page_t);
 int mmu_radix_pinit(pmap_t);
 void mmu_radix_protect(pmap_t, vm_offset_t, vm_offset_t, vm_prot_t);
 bool mmu_radix_ps_enabled(pmap_t);
-void mmu_radix_qenter(vm_offset_t, vm_page_t *, int);
-void mmu_radix_qremove(vm_offset_t, int);
+void mmu_radix_qenter(void *, vm_page_t *, int);
+void mmu_radix_qremove(void *, int);
 void *mmu_radix_quick_enter_page(vm_page_t);
 void mmu_radix_quick_remove_page(void *);
 int mmu_radix_ts_referenced(vm_page_t);
@@ -4665,20 +4665,19 @@ mmu_radix_protect(pmap_t pmap, vm_offset_t sva, vm_offset_t eva,
 }
 
 void
-mmu_radix_qenter(vm_offset_t sva, vm_page_t *ma, int count)
+mmu_radix_qenter(void *sva, vm_page_t *ma, int count)
 {
-
-	CTR4(KTR_PMAP, "%s(%#x, %p, %d)", __func__, sva, ma, count);
 	pt_entry_t oldpte, pa, *pte;
 	vm_page_t m;
 	uint64_t cache_bits, attr_bits;
 	vm_offset_t va;
 
+	CTR4(KTR_PMAP, "%s(%p, %p, %d)", __func__, sva, ma, count);
 	oldpte = 0;
 	attr_bits = RPTE_EAA_R | RPTE_EAA_W | RPTE_EAA_P | PG_M | PG_A;
-	va = sva;
+	va = (vm_offset_t)sva;
 	pte = kvtopte(va);
-	while (va < sva + PAGE_SIZE * count) {
+	while (va < (vm_offset_t)sva + PAGE_SIZE * count) {
 		if (__predict_false((va & L3_PAGE_MASK) == 0))
 			pte = kvtopte(va);
 		MPASS(pte == pmap_pte(kernel_pmap, va));
@@ -4700,31 +4699,31 @@ mmu_radix_qenter(vm_offset_t sva, vm_page_t *ma, int count)
 		pte++;
 	}
 	if (__predict_false((oldpte & RPTE_VALID) != 0))
-		pmap_invalidate_range(kernel_pmap, sva, sva + count *
-		    PAGE_SIZE);
+		pmap_invalidate_range(kernel_pmap, (vm_offset_t)sva,
+		    (vm_offset_t)sva + count * PAGE_SIZE);
 	else
 		ptesync();
 }
 
 void
-mmu_radix_qremove(vm_offset_t sva, int count)
+mmu_radix_qremove(void *sva, int count)
 {
 	vm_offset_t va;
 	pt_entry_t *pte;
 
-	CTR3(KTR_PMAP, "%s(%#x, %d)", __func__, sva, count);
-	KASSERT(sva >= VM_MIN_KERNEL_ADDRESS, ("usermode or dmap va %lx", sva));
+	va = (vm_offset_t)sva;
+	CTR3(KTR_PMAP, "%s(%p, %d)", __func__, sva, count);
+	KASSERT(va >= VM_MIN_KERNEL_ADDRESS, ("usermode or dmap va %p", sva));
 
-	va = sva;
 	pte = kvtopte(va);
-	while (va < sva + PAGE_SIZE * count) {
+	while (va < (vm_offset_t)sva + PAGE_SIZE * count) {
 		if (__predict_false((va & L3_PAGE_MASK) == 0))
 			pte = kvtopte(va);
 		pte_clear(pte);
 		pte++;
 		va += PAGE_SIZE;
 	}
-	pmap_invalidate_range(kernel_pmap, sva, va);
+	pmap_invalidate_range(kernel_pmap, (vm_offset_t)sva, va);
 }
 
 /***************************************************
@@ -5970,7 +5969,7 @@ mmu_radix_unmapdev(void *p, vm_size_t size)
 	va = trunc_page(va);
 
 	if (pmap_initialized) {
-		mmu_radix_qremove(va, atop(size));
+		mmu_radix_qremove((void *)va, atop(size));
 		kva_free(va, size);
 	}
 }

sys/powerpc/booke/pmap.c

@@ -320,8 +320,8 @@ static int		mmu_booke_pinit(pmap_t);
 static void		mmu_booke_pinit0(pmap_t);
 static void		mmu_booke_protect(pmap_t, vm_offset_t, vm_offset_t,
     vm_prot_t);
-static void		mmu_booke_qenter(vm_offset_t, vm_page_t *, int);
-static void		mmu_booke_qremove(vm_offset_t, int);
+static void		mmu_booke_qenter(void *, vm_page_t *, int);
+static void		mmu_booke_qremove(void *, int);
 static void		mmu_booke_release(pmap_t);
 static void		mmu_booke_remove(pmap_t, vm_offset_t, vm_offset_t);
 static void		mmu_booke_remove_all(vm_page_t);
@@ -1101,11 +1101,11 @@ mmu_booke_init(void)
  * references recorded.  Existing mappings in the region are overwritten.
  */
 static void
-mmu_booke_qenter(vm_offset_t sva, vm_page_t *m, int count)
+mmu_booke_qenter(void *sva, vm_page_t *m, int count)
 {
 	vm_offset_t va;
 
-	va = sva;
+	va = (vm_offset_t)sva;
 	while (count-- > 0) {
 		mmu_booke_kenter(va, VM_PAGE_TO_PHYS(*m));
 		va += PAGE_SIZE;
@@ -1118,11 +1118,11 @@ mmu_booke_qenter(vm_offset_t sva, vm_page_t *m, int count)
  * temporary mappings entered by mmu_booke_qenter.
  */
 static void
-mmu_booke_qremove(vm_offset_t sva, int count)
+mmu_booke_qremove(void *sva, int count)
 {
 	vm_offset_t va;
 
-	va = sva;
+	va = (vm_offset_t)sva;
 	while (count-- > 0) {
 		mmu_booke_kremove(va);
 		va += PAGE_SIZE;
@@ -2329,7 +2329,8 @@ static void
 mmu_booke_unmapdev(void *p, vm_size_t size)
 {
 #ifdef SUPPORTS_SHRINKING_TLB1
-	vm_offset_t base, offset, va;
+	void *base;
+	vm_offset_t offset, va;
 
 	/*
 	 * Unmap only if this is inside kernel virtual space.
@@ -2340,7 +2341,7 @@ mmu_booke_unmapdev(void *p, vm_size_t size)
 		offset = va & PAGE_MASK;
 		size = roundup(offset + size, PAGE_SIZE);
 		mmu_booke_qremove(base, atop(size));
-		kva_free(base, size);
+		kva_free((vm_offset_t)base, size);
 	}
 #endif
 }

sys/powerpc/include/mmuvar.h

@@ -75,8 +75,8 @@ typedef	void	(*pmap_page_init_t)(vm_page_t);
 typedef	int	(*pmap_page_wired_mappings_t)(vm_page_t);
 typedef	void	(*pmap_pinit0_t)(pmap_t);
 typedef	void	(*pmap_protect_t)(pmap_t, vm_offset_t, vm_offset_t, vm_prot_t);
-typedef	void	(*pmap_qenter_t)(vm_offset_t, vm_page_t *, int);
-typedef	void	(*pmap_qremove_t)(vm_offset_t, int);
+typedef	void	(*pmap_qenter_t)(void *, vm_page_t *, int);
+typedef	void	(*pmap_qremove_t)(void *, int);
 typedef	void	(*pmap_release_t)(pmap_t);
 typedef	void	(*pmap_remove_t)(pmap_t, vm_offset_t, vm_offset_t);
 typedef	void	(*pmap_remove_all_t)(vm_page_t);

sys/powerpc/powerpc/pmap_dispatch.c

@@ -150,8 +150,8 @@ DEFINE_PMAP_IFUNC(bool, page_is_mapped, (vm_page_t));
 DEFINE_PMAP_IFUNC(int, page_wired_mappings, (vm_page_t));
 DEFINE_PMAP_IFUNC(void, protect, (pmap_t, vm_offset_t, vm_offset_t, vm_prot_t));
 DEFINE_PMAP_IFUNC(bool, ps_enabled, (pmap_t));
-DEFINE_PMAP_IFUNC(void, qenter, (vm_offset_t, vm_page_t *, int));
-DEFINE_PMAP_IFUNC(void, qremove, (vm_offset_t, int));
+DEFINE_PMAP_IFUNC(void, qenter, (void *, vm_page_t *, int));
+DEFINE_PMAP_IFUNC(void, qremove, (void *, int));
 DEFINE_PMAP_IFUNC(void *, quick_enter_page, (vm_page_t));
 DEFINE_PMAP_IFUNC(void, quick_remove_page, (void *));
 DEFINE_PMAP_IFUNC(int, ts_referenced, (vm_page_t));

sys/riscv/riscv/pmap.c

@@ -1385,7 +1385,7 @@ pmap_map(vm_offset_t *virt, vm_paddr_t start, vm_paddr_t end, int prot)
  * Note: SMP coherent.  Uses a ranged shootdown IPI.
  */
 void
-pmap_qenter(vm_offset_t sva, vm_page_t *ma, int count)
+pmap_qenter(void *sva, vm_page_t *ma, int count)
 {
 	pt_entry_t *l3;
 	vm_paddr_t pa;
@@ -1395,7 +1395,7 @@ pmap_qenter(vm_offset_t sva, vm_page_t *ma, int count)
 	pn_t pn;
 	int i;
 
-	va = sva;
+	va = (vm_offset_t)sva;
 	for (i = 0; i < count; i++) {
 		m = ma[i];
 		pa = VM_PAGE_TO_PHYS(m);
@@ -1409,7 +1409,7 @@ pmap_qenter(vm_offset_t sva, vm_page_t *ma, int count)
 
 		va += L3_SIZE;
 	}
-	pmap_invalidate_range(kernel_pmap, sva, va);
+	pmap_invalidate_range(kernel_pmap, (vm_offset_t)sva, va);
 }
 
 /*
@@ -1418,19 +1418,20 @@ pmap_qenter(vm_offset_t sva, vm_page_t *ma, int count)
  * Note: SMP coherent.  Uses a ranged shootdown IPI.
  */
 void
-pmap_qremove(vm_offset_t sva, int count)
+pmap_qremove(void *sva, int count)
 {
 	pt_entry_t *l3;
 	vm_offset_t va;
 
-	KASSERT(sva >= VM_MIN_KERNEL_ADDRESS, ("usermode va %lx", sva));
+	va = (vm_offset_t)sva;
+	KASSERT(va >= VM_MIN_KERNEL_ADDRESS, ("usermode va %p", sva));
 
-	for (va = sva; count-- > 0; va += PAGE_SIZE) {
+	for (; count-- > 0; va += PAGE_SIZE) {
 		l3 = pmap_l3(kernel_pmap, va);
 		KASSERT(l3 != NULL, ("pmap_kremove: Invalid address"));
 		pmap_clear(l3);
 	}
-	pmap_invalidate_range(kernel_pmap, sva, va);
+	pmap_invalidate_range(kernel_pmap, (vm_offset_t)sva, va);
 }
 
 bool

sys/sys/sf_buf.h

@@ -135,7 +135,7 @@ static inline void
 sf_buf_map(struct sf_buf *sf, int flags)
 {
 
-	pmap_qenter(sf->kva, &sf->m, 1);
+	pmap_qenter((void *)sf->kva, &sf->m, 1);
 }
 
 static inline int

sys/vm/pmap.h

@@ -152,8 +152,8 @@ int		 pmap_page_wired_mappings(vm_page_t m);
 int		 pmap_pinit(pmap_t);
 void		 pmap_pinit0(pmap_t);
 void		 pmap_protect(pmap_t, vm_offset_t, vm_offset_t, vm_prot_t);
-void		 pmap_qenter(vm_offset_t, vm_page_t *, int);
-void		 pmap_qremove(vm_offset_t, int);
+void		 pmap_qenter(void *, vm_page_t *, int);
+void		 pmap_qremove(void *, int);
 void		*pmap_quick_enter_page(vm_page_t);
 void		 pmap_quick_remove_page(void *);
 void		 pmap_release(pmap_t);

sys/vm/swap_pager.c

@@ -995,8 +995,8 @@ swp_pager_strategy(struct buf *bp)
 				bp->b_data = unmapped_buf;
 				bp->b_offset = 0;
 			} else {
-				pmap_qenter((vm_offset_t)bp->b_data,
-				    &bp->b_pages[0], bp->b_bcount / PAGE_SIZE);
+				pmap_qenter(bp->b_data, bp->b_pages,
+				    bp->b_bcount / PAGE_SIZE);
 			}
 			sp->sw_strategy(bp, sp);
 			return;
@@ -1728,7 +1728,7 @@ swp_pager_async_iodone(struct buf *bp)
 	 * remove the mapping for kernel virtual
 	 */
 	if (buf_mapped(bp))
-		pmap_qremove((vm_offset_t)bp->b_data, bp->b_npages);
+		pmap_qremove(bp->b_data, bp->b_npages);
 	else
 		bp->b_data = bp->b_kvabase;
 

sys/vm/uma_core.c

@@ -1955,7 +1955,8 @@ pcpu_page_alloc(uma_zone_t zone, vm_size_t bytes, int domain, uint8_t *pflag,
     int wait)
 {
 	struct pglist alloctail;
-	vm_offset_t addr, zkva;
+	void *addr;
+	char *zkva;
 	int cpu, flags;
 	vm_page_t p, p_next;
 #ifdef NUMA
@@ -1988,14 +1989,14 @@ pcpu_page_alloc(uma_zone_t zone, vm_size_t bytes, int domain, uint8_t *pflag,
 			goto fail;
 		TAILQ_INSERT_TAIL(&alloctail, p, plinks.q);
 	}
-	if ((addr = kva_alloc(bytes)) == 0)
+	if ((addr = (void *)kva_alloc(bytes)) == NULL)
 		goto fail;
 	zkva = addr;
 	TAILQ_FOREACH(p, &alloctail, plinks.q) {
 		pmap_qenter(zkva, &p, 1);
 		zkva += PAGE_SIZE;
 	}
-	return ((void*)addr);
+	return (addr);
 fail:
 	TAILQ_FOREACH_SAFE(p, &alloctail, plinks.q, p_next) {
 		vm_page_unwire_noq(p);
@@ -2021,7 +2022,8 @@ noobj_alloc(uma_zone_t zone, vm_size_t bytes, int domain, uint8_t *flags,
 {
 	TAILQ_HEAD(, vm_page) alloctail;
 	u_long npages;
-	vm_offset_t retkva, zkva;
+	void *retkva;
+	char *zkva;
 	vm_page_t p, p_next;
 	uma_keg_t keg;
 	int req;
@@ -2051,7 +2053,7 @@ noobj_alloc(uma_zone_t zone, vm_size_t bytes, int domain, uint8_t *flags,
 		return (NULL);
 	}
 	*flags = UMA_SLAB_PRIV;
-	zkva = keg->uk_kva +
+	zkva = (char *)keg->uk_kva +
 	    atomic_fetchadd_long(&keg->uk_offset, round_page(bytes));
 	retkva = zkva;
 	TAILQ_FOREACH(p, &alloctail, plinks.q) {
@@ -2059,7 +2061,7 @@ noobj_alloc(uma_zone_t zone, vm_size_t bytes, int domain, uint8_t *flags,
 		zkva += PAGE_SIZE;
 	}
 
-	return ((void *)retkva);
+	return (retkva);
 }
 
 /*
@@ -2155,7 +2157,7 @@ pcpu_page_free(void *mem, vm_size_t size, uint8_t flags)
 		vm_page_unwire_noq(m);
 		vm_page_free(m);
 	}
-	pmap_qremove(sva, size >> PAGE_SHIFT);
+	pmap_qremove(mem, size >> PAGE_SHIFT);
 	kva_free(sva, size);
 }
 

sys/vm/vm_glue.c

@@ -472,12 +472,12 @@ vm_thread_stack_create(struct domainset *ds, int pages, int flags)
 			continue;
 		}
 		if (KSTACK_GUARD_PAGES != 0) {
-			pmap_qremove(ks - ptoa(KSTACK_GUARD_PAGES),
+			pmap_qremove((char *)ks - ptoa(KSTACK_GUARD_PAGES),
 			    KSTACK_GUARD_PAGES);
 		}
 		for (i = 0; i < pages; i++)
 			vm_page_valid(ma[i]);
-		pmap_qenter(ks, ma, pages);
+		pmap_qenter((char *)ks, ma, pages);
 		return (ks);
 	} while (vm_domainset_iter_policy(&di, &domain) == 0);
 
@@ -494,7 +494,7 @@ vm_thread_stack_dispose(vm_offset_t ks, int pages)
 
 	pindex = vm_kstack_pindex(ks, pages);
 	domain = vm_phys_domain(vtophys(ks));
-	pmap_qremove(ks, pages);
+	pmap_qremove((void *)ks, pages);
 	VM_OBJECT_WLOCK(obj);
 	for (i = 0; i < pages; i++) {
 		m = vm_page_lookup(obj, pindex + i);

sys/vm/vm_kern.c

@@ -781,7 +781,7 @@ kmem_init_zero_region(void)
 	m = vm_page_alloc_noobj(VM_ALLOC_WIRED | VM_ALLOC_ZERO |
 	    VM_ALLOC_NOFREE);
 	for (i = 0; i < ZERO_REGION_SIZE; i += PAGE_SIZE)
-		pmap_qenter(addr + i, &m, 1);
+		pmap_qenter((char *)addr + i, &m, 1);
 	pmap_protect(kernel_pmap, addr, addr + ZERO_REGION_SIZE, VM_PROT_READ);
 
 	zero_region = (const void *)addr;

sys/vm/vnode_pager.c

@@ -1094,7 +1094,7 @@ vnode_pager_generic_getpages(struct vnode *vp, vm_page_t *m, int count,
 		bp->b_offset = 0;
 	} else {
 		bp->b_data = bp->b_kvabase;
-		pmap_qenter((vm_offset_t)bp->b_data, bp->b_pages, bp->b_npages);
+		pmap_qenter(bp->b_data, bp->b_pages, bp->b_npages);
 	}
 
 	/* Build a minimal buffer header. */
@@ -1175,14 +1175,13 @@ vnode_pager_generic_getpages_done(struct buf *bp)
 	if (error == 0 && bp->b_bcount != ptoa(bp->b_npages)) {
 		if (!buf_mapped(bp)) {
 			bp->b_data = bp->b_kvabase;
-			pmap_qenter((vm_offset_t)bp->b_data, bp->b_pages,
-			    bp->b_npages);
+			pmap_qenter(bp->b_data, bp->b_pages, bp->b_npages);
 		}
 		bzero(bp->b_data + bp->b_bcount,
 		    ptoa(bp->b_npages) - bp->b_bcount);
 	}
 	if (buf_mapped(bp)) {
-		pmap_qremove((vm_offset_t)bp->b_data, bp->b_npages);
+		pmap_qremove(bp->b_data, bp->b_npages);
 		bp->b_data = unmapped_buf;
 	}
 

sys/x86/iommu/amd_drv.c

@@ -203,7 +203,7 @@ amdiommu_free_dev_tbl(struct amdiommu_unit *sc)
 	u_int devtbl_sz;
 
 	devtbl_sz = amdiommu_devtbl_sz(sc);
-	pmap_qremove((vm_offset_t)sc->dev_tbl, atop(devtbl_sz));
+	pmap_qremove(sc->dev_tbl, atop(devtbl_sz));
 	kva_free((vm_offset_t)sc->dev_tbl, devtbl_sz);
 	sc->dev_tbl = NULL;
 	vm_object_deallocate(sc->devtbl_obj);
@@ -280,7 +280,7 @@ amdiommu_create_dev_tbl(struct amdiommu_unit *sc)
 		for (u_int j = 0; j < atop(seg_sz);
 		     j++, seg_vaddr += PAGE_SIZE, m++) {
 			pmap_zero_page(m);
-			pmap_qenter(seg_vaddr, &m, 1);
+			pmap_qenter((void *)seg_vaddr, &m, 1);
 		}
 		amdiommu_write8(sc, devtab_base_regs[i], rval);
 	}