kva_alloc/free: 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/pmap.c

@@ -2415,7 +2415,7 @@ pmap_init_pv_table(void)
 	pv_npg = howmany(pmap_last_pa, NBPDR);
 	s = (vm_size_t)pv_npg * sizeof(struct pmap_large_md_page);
 	s = round_page(s);
-	pv_table = (struct pmap_large_md_page *)kva_alloc(s);
+	pv_table = kva_alloc(s);
 	if (pv_table == NULL)
 		panic("%s: kva_alloc failed\n", __func__);
 
@@ -9448,7 +9448,7 @@ pmap_mapdev_internal(vm_paddr_t pa, vm_size_t size, int mode, int flags)
 			if (!i)
 				return ((void *)(va + offset));
 		}
-		va = kva_alloc(size);
+		va = (vm_offset_t)kva_alloc(size);
 		if (va == 0)
 			panic("%s: Couldn't allocate KVA", __func__);
 	}
@@ -9522,7 +9522,7 @@ pmap_unmapdev(void *p, vm_size_t size)
 	}
 	if (pmap_initialized) {
 		pmap_qremove((void *)va, atop(size));
-		kva_free(va, size);
+		kva_free((void *)va, size);
 	}
 }
 

sys/arm/arm/pmap-v6.c

@@ -1213,7 +1213,7 @@ pmap_bootstrap(vm_offset_t firstaddr)
 	mtx_init(&pc->pc_cmap_lock, "SYSMAPS", NULL, MTX_DEF);
 	SYSMAP(caddr_t, pc->pc_cmap1_pte2p, pc->pc_cmap1_addr, 1);
 	SYSMAP(caddr_t, pc->pc_cmap2_pte2p, pc->pc_cmap2_addr, 1);
-	SYSMAP(vm_offset_t, pc->pc_qmap_pte2p, pc->pc_qmap_addr, 1);
+	SYSMAP(caddr_t, pc->pc_qmap_pte2p, pc->pc_qmap_addr, 1);
 
 	/*
 	 * Crashdump maps.
@@ -1249,7 +1249,7 @@ static void
 pmap_init_reserved_pages(void *dummy __unused)
 {
 	struct pcpu *pc;
-	vm_offset_t pages;
+	char *pages;
 	int i;
 
 	CPU_FOREACH(i) {
@@ -1262,13 +1262,13 @@ pmap_init_reserved_pages(void *dummy __unused)
 			continue;
 		mtx_init(&pc->pc_cmap_lock, "SYSMAPS", NULL, MTX_DEF);
 		pages = kva_alloc(PAGE_SIZE * 3);
-		if (pages == 0)
+		if (pages == NULL)
 			panic("%s: unable to allocate KVA", __func__);
-		pc->pc_cmap1_pte2p = pt2map_entry(pages);
-		pc->pc_cmap2_pte2p = pt2map_entry(pages + PAGE_SIZE);
-		pc->pc_qmap_pte2p = pt2map_entry(pages + (PAGE_SIZE * 2));
-		pc->pc_cmap1_addr = (caddr_t)pages;
-		pc->pc_cmap2_addr = (caddr_t)(pages + PAGE_SIZE);
+		pc->pc_cmap1_pte2p = pt2map_entry((vm_offset_t)pages);
+		pc->pc_cmap2_pte2p = pt2map_entry((vm_offset_t)pages + PAGE_SIZE);
+		pc->pc_qmap_pte2p = pt2map_entry((vm_offset_t)pages + (PAGE_SIZE * 2));
+		pc->pc_cmap1_addr = pages;
+		pc->pc_cmap2_addr = pages + PAGE_SIZE;
 		pc->pc_qmap_addr = pages + (PAGE_SIZE * 2);
 	}
 }
@@ -1803,7 +1803,7 @@ pmap_init(void)
 		TAILQ_INIT(&pv_table[i].pv_list);
 
 	pv_maxchunks = MAX(pv_entry_max / _NPCPV, maxproc);
-	pv_chunkbase = (struct pv_chunk *)kva_alloc(PAGE_SIZE * pv_maxchunks);
+	pv_chunkbase = kva_alloc(PAGE_SIZE * pv_maxchunks);
 	if (pv_chunkbase == NULL)
 		panic("%s: not enough kvm for pv chunks", __func__);
 	pmap_pte2list_init(&pv_vafree, pv_chunkbase, pv_maxchunks);
@@ -6021,7 +6021,7 @@ pmap_quick_enter_page(vm_page_t m)
 
 	pte2_store(pte2p, PTE2_KERN_NG(VM_PAGE_TO_PHYS(m), PTE2_AP_KRW,
 	    vm_page_pte2_attr(m)));
-	return ((void *)pc->pc_qmap_addr);
+	return (pc->pc_qmap_addr);
 }
 
 void
@@ -6033,12 +6033,12 @@ pmap_quick_remove_page(void *addr)
 	pc = get_pcpu();
 	pte2p = pc->pc_qmap_pte2p;
 
-	KASSERT(addr == (void *)pc->pc_qmap_addr,
+	KASSERT(addr == pc->pc_qmap_addr,
 	    ("%s: invalid address", __func__));
 	KASSERT(pte2_load(pte2p) != 0, ("%s: PTE2 not in use", __func__));
 
 	pte2_clear(pte2p);
-	tlb_flush(pc->pc_qmap_addr);
+	tlb_flush((vm_offset_t)pc->pc_qmap_addr);
 	critical_exit();
 }
 

sys/arm/include/pcpu.h

@@ -55,7 +55,7 @@ struct vmspace;
 	void *pc_cmap2_pte2p;						\
 	caddr_t pc_cmap1_addr;						\
 	caddr_t pc_cmap2_addr;						\
-	vm_offset_t pc_qmap_addr;					\
+	caddr_t pc_qmap_addr;						\
 	void *pc_qmap_pte2p;						\
 	unsigned int pc_dbreg[32];					\
 	int pc_dbreg_cmd;						\

sys/arm64/arm64/pmap.c

@@ -1627,7 +1627,7 @@ pmap_init_pv_table(void)
 		    pmap_l2_pindex(seg->start);
 		s += round_page(pages * sizeof(*pvd));
 	}
-	pv_table = (struct pmap_large_md_page *)kva_alloc(s);
+	pv_table = kva_alloc(s);
 	if (pv_table == NULL)
 		panic("%s: kva_alloc failed\n", __func__);
 
@@ -8086,7 +8086,7 @@ pmap_mapbios(vm_paddr_t pa, vm_size_t size)
 		offset = pa & PAGE_MASK;
 		size = round_page(offset + size);
 
-		va = kva_alloc(size);
+		va = (vm_offset_t)kva_alloc(size);
 		if (va == 0)
 			panic("%s: Couldn't allocate KVA", __func__);
 
@@ -8174,7 +8174,7 @@ pmap_unmapbios(void *p, vm_size_t size)
 		/* Unmap and invalidate the pages */
 		pmap_kremove_device(va, size);
 
-		kva_free(va, size);
+		kva_free((void *)va, size);
 	}
 }
 
@@ -8475,7 +8475,7 @@ static pt_entry_t *
 pmap_demote_l1(pmap_t pmap, pt_entry_t *l1, vm_offset_t va)
 {
 	pt_entry_t *l2, newl2, oldl1;
-	vm_offset_t tmpl1;
+	char *tmpl1;
 	vm_paddr_t l2phys, phys;
 	vm_page_t ml2;
 	int i;
@@ -8492,10 +8492,10 @@ pmap_demote_l1(pmap_t pmap, pt_entry_t *l1, vm_offset_t va)
 	KASSERT((oldl1 & ATTR_SW_NO_PROMOTE) == 0,
 	    ("pmap_demote_l1: Demoting entry with no-demote flag set"));
 
-	tmpl1 = 0;
+	tmpl1 = NULL;
 	if (va <= (vm_offset_t)l1 && va + L1_SIZE > (vm_offset_t)l1) {
 		tmpl1 = kva_alloc(PAGE_SIZE);
-		if (tmpl1 == 0)
+		if (tmpl1 == NULL)
 			return (NULL);
 	}
 
@@ -8525,8 +8525,8 @@ pmap_demote_l1(pmap_t pmap, pt_entry_t *l1, vm_offset_t va)
 	    L2_BLOCK), ("Invalid l2 page (%lx != %lx)", l2[0],
 	    ATTR_CONTIGUOUS | (oldl1 & ~ATTR_DESCR_MASK) | L2_BLOCK));
 
-	if (tmpl1 != 0) {
-		pmap_kenter(tmpl1, PAGE_SIZE,
+	if (tmpl1 != NULL) {
+		pmap_kenter((vm_offset_t)tmpl1, PAGE_SIZE,
 		    DMAP_TO_PHYS((vm_offset_t)l1) & ~L3_OFFSET,
 		    VM_MEMATTR_WRITE_BACK);
 		l1 = (pt_entry_t *)(tmpl1 + ((vm_offset_t)l1 & PAGE_MASK));
@@ -8536,8 +8536,8 @@ pmap_demote_l1(pmap_t pmap, pt_entry_t *l1, vm_offset_t va)
 
 	counter_u64_add(pmap_l1_demotions, 1);
 fail:
-	if (tmpl1 != 0) {
-		pmap_kremove(tmpl1);
+	if (tmpl1 != NULL) {
+		pmap_kremove((vm_offset_t)tmpl1);
 		kva_free(tmpl1, PAGE_SIZE);
 	}
 
@@ -8605,7 +8605,7 @@ pmap_demote_l2_locked(pmap_t pmap, pt_entry_t *l2, vm_offset_t va,
     struct rwlock **lockp)
 {
 	pt_entry_t *l3, newl3, oldl2;
-	vm_offset_t tmpl2;
+	char *tmpl2;
 	vm_paddr_t l3phys;
 	vm_page_t ml3;
 
@@ -8622,10 +8622,10 @@ pmap_demote_l2_locked(pmap_t pmap, pt_entry_t *l2, vm_offset_t va,
 	    ("pmap_demote_l2: Demoting entry with no-demote flag set"));
 	va &= ~L2_OFFSET;
 
-	tmpl2 = 0;
+	tmpl2 = NULL;
 	if (va <= (vm_offset_t)l2 && va + L2_SIZE > (vm_offset_t)l2) {
 		tmpl2 = kva_alloc(PAGE_SIZE);
-		if (tmpl2 == 0)
+		if (tmpl2 == NULL)
 			return (NULL);
 	}
 
@@ -8720,8 +8720,8 @@ pmap_demote_l2_locked(pmap_t pmap, pt_entry_t *l2, vm_offset_t va,
 	/*
 	 * Map the temporary page so we don't lose access to the l2 table.
 	 */
-	if (tmpl2 != 0) {
-		pmap_kenter(tmpl2, PAGE_SIZE,
+	if (tmpl2 != NULL) {
+		pmap_kenter((vm_offset_t)tmpl2, PAGE_SIZE,
 		    DMAP_TO_PHYS((vm_offset_t)l2) & ~L3_OFFSET,
 		    VM_MEMATTR_WRITE_BACK);
 		l2 = (pt_entry_t *)(tmpl2 + ((vm_offset_t)l2 & PAGE_MASK));
@@ -8755,8 +8755,8 @@ pmap_demote_l2_locked(pmap_t pmap, pt_entry_t *l2, vm_offset_t va,
 	    " in pmap %p %lx", va, pmap, l3[0]);
 
 fail:
-	if (tmpl2 != 0) {
-		pmap_kremove(tmpl2);
+	if (tmpl2 != NULL) {
+		pmap_kremove((vm_offset_t)tmpl2);
 		kva_free(tmpl2, PAGE_SIZE);
 	}
 
@@ -8784,7 +8784,7 @@ static bool
 pmap_demote_l2c(pmap_t pmap, pt_entry_t *l2p, vm_offset_t va)
 {
 	pd_entry_t *l2c_end, *l2c_start, l2e, mask, nbits, *tl2p;
-	vm_offset_t tmpl3;
+	char *tmpl3;
 	register_t intr;
 
 	PMAP_LOCK_ASSERT(pmap, MA_OWNED);
@@ -8792,13 +8792,13 @@ pmap_demote_l2c(pmap_t pmap, pt_entry_t *l2p, vm_offset_t va)
 	l2c_start = (pd_entry_t *)((uintptr_t)l2p & ~((L2C_ENTRIES *
 	    sizeof(pd_entry_t)) - 1));
 	l2c_end = l2c_start + L2C_ENTRIES;
-	tmpl3 = 0;
+	tmpl3 = NULL;
 	if ((va & ~L2C_OFFSET) < (vm_offset_t)l2c_end &&
 	    (vm_offset_t)l2c_start < (va & ~L2C_OFFSET) + L2C_SIZE) {
 		tmpl3 = kva_alloc(PAGE_SIZE);
-		if (tmpl3 == 0)
+		if (tmpl3 == NULL)
 			return (false);
-		pmap_kenter(tmpl3, PAGE_SIZE,
+		pmap_kenter((vm_offset_t)tmpl3, PAGE_SIZE,
 		    DMAP_TO_PHYS((vm_offset_t)l2c_start) & ~L3_OFFSET,
 		    VM_MEMATTR_WRITE_BACK);
 		l2c_start = (pd_entry_t *)(tmpl3 +
@@ -8857,8 +8857,8 @@ pmap_demote_l2c(pmap_t pmap, pt_entry_t *l2p, vm_offset_t va)
 	dsb(ishst);
 
 	intr_restore(intr);
-	if (tmpl3 != 0) {
-		pmap_kremove(tmpl3);
+	if (tmpl3 != NULL) {
+		pmap_kremove((vm_offset_t)tmpl3);
 		kva_free(tmpl3, PAGE_SIZE);
 	}
 	counter_u64_add(pmap_l2c_demotions, 1);
@@ -8874,20 +8874,20 @@ static bool
 pmap_demote_l3c(pmap_t pmap, pt_entry_t *l3p, vm_offset_t va)
 {
 	pt_entry_t *l3c_end, *l3c_start, l3e, mask, nbits, *tl3p;
-	vm_offset_t tmpl3;
+	char *tmpl3;
 	register_t intr;
 
 	PMAP_LOCK_ASSERT(pmap, MA_OWNED);
 	l3c_start = (pt_entry_t *)((uintptr_t)l3p & ~((L3C_ENTRIES *
 	    sizeof(pt_entry_t)) - 1));
 	l3c_end = l3c_start + L3C_ENTRIES;
-	tmpl3 = 0;
+	tmpl3 = NULL;
 	if ((va & ~L3C_OFFSET) < (vm_offset_t)l3c_end &&
 	    (vm_offset_t)l3c_start < (va & ~L3C_OFFSET) + L3C_SIZE) {
 		tmpl3 = kva_alloc(PAGE_SIZE);
-		if (tmpl3 == 0)
+		if (tmpl3 == NULL)
 			return (false);
-		pmap_kenter(tmpl3, PAGE_SIZE,
+		pmap_kenter((vm_offset_t)tmpl3, PAGE_SIZE,
 		    DMAP_TO_PHYS((vm_offset_t)l3c_start) & ~L3_OFFSET,
 		    VM_MEMATTR_WRITE_BACK);
 		l3c_start = (pt_entry_t *)(tmpl3 +
@@ -8946,8 +8946,8 @@ pmap_demote_l3c(pmap_t pmap, pt_entry_t *l3p, vm_offset_t va)
 	dsb(ishst);
 
 	intr_restore(intr);
-	if (tmpl3 != 0) {
-		pmap_kremove(tmpl3);
+	if (tmpl3 != NULL) {
+		pmap_kremove((vm_offset_t)tmpl3);
 		kva_free(tmpl3, PAGE_SIZE);
 	}
 	counter_u64_add(pmap_l3c_demotions, 1);

sys/arm64/spe/arm_spe_backend.c

@@ -229,15 +229,15 @@ spe_backend_deinit(struct hwt_context *ctx)
 		CPU_FOREACH_ISSET(cpu_id, &ctx->cpu_map) {
 			info = &spe_info_cpu[cpu_id];
 			printf("CPU %u:\n", cpu_id);
-			hex_dump((void *)info->kvaddr, 128);
-			hex_dump((void *)(info->kvaddr + (info->buf_size/2)), 128);
+			hex_dump(info->kvaddr, 128);
+			hex_dump((char *)info->kvaddr + (info->buf_size/2), 128);
 		}
 	} else {
 		TAILQ_FOREACH(thr, &ctx->threads, next) {
 			info = (struct arm_spe_info *)thr->private;
 			printf("TID %u:\n", thr->thread_id);
-			hex_dump((void *)info->kvaddr, 128);
-			hex_dump((void *)(info->kvaddr + (info->buf_size/2)), 128);
+			hex_dump(info->kvaddr, 128);
+			hex_dump((char *)info->kvaddr + (info->buf_size/2), 128);
 		}
 	}
 #endif

sys/arm64/spe/arm_spe_dev.h

@@ -111,7 +111,7 @@ struct arm_spe_info {
 
 	/* buffer is split in half as a ping-pong buffer */
 	vm_object_t             bufobj;
-	vm_offset_t             kvaddr;
+	char			*kvaddr;
 	size_t                  buf_size;
 	uint8_t                 buf_idx : 1; /* 0 = first half of buf, 1 = 2nd half */
 	struct arm_spe_buf_info buf_info[2];
@@ -141,24 +141,25 @@ struct arm_spe_queue {
 
 static inline vm_offset_t buf_start_addr(u_int buf_idx, struct arm_spe_info *info)
 {
-	vm_offset_t addr;
+	char *addr;
 	if (buf_idx == 0)
 		addr = info->kvaddr;
 	if (buf_idx == 1)
-	addr = info->kvaddr + (info->buf_size/2);
+		addr = info->kvaddr + (info->buf_size/2);
 
-	return (addr);
+	return ((vm_offset_t)addr);
 }
 
 static inline vm_offset_t buf_end_addr(u_int buf_idx, struct arm_spe_info *info)
 {
-	vm_offset_t addr;
+	char *addr;
+
 	if (buf_idx == 0)
 		addr = info->kvaddr + (info->buf_size/2);
 	if (buf_idx == 1)
 		addr = info->kvaddr + info->buf_size;
 
-	return (addr);
+	return ((vm_offset_t)addr);
 }
 
 #endif /* _ARM64_ARM_SPE_DEV_H_ */

sys/compat/linux/linux_vdso.c

@@ -69,7 +69,7 @@ __elfN(linux_shared_page_init)(char **mapping, vm_size_t size)
 
 	pages = size / PAGE_SIZE;
 
-	addr = (char *)kva_alloc(size);
+	addr = kva_alloc(size);
 	obj = vm_pager_allocate(OBJT_PHYS, 0, size,
 	    VM_PROT_DEFAULT, 0, NULL);
 	VM_OBJECT_WLOCK(obj);
@@ -89,11 +89,8 @@ void
 __elfN(linux_shared_page_fini)(vm_object_t obj, void *mapping,
     vm_size_t size)
 {
-	vm_offset_t va;
-
-	va = (vm_offset_t)mapping;
 	pmap_qremove(mapping, size / PAGE_SIZE);
-	kva_free(va, size);
+	kva_free(mapping, size);
 	vm_object_deallocate(obj);
 }
 

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

@@ -428,7 +428,7 @@ vmap(struct page **pages, unsigned int count, unsigned long flags, int prot)
 	size_t size;
 
 	size = count * PAGE_SIZE;
-	off = (void *)kva_alloc(size);
+	off = kva_alloc(size);
 	if (off == NULL)
 		return (NULL);
 	vmmap_add(off, size);
@@ -451,7 +451,7 @@ linuxkpi_vmap_pfn(unsigned long *pfns, unsigned int count, int prot)
 	unsigned int i, c, chunk;
 
 	size = ptoa(count);
-	off = (void *)kva_alloc(size);
+	off = kva_alloc(size);
 	if (off == NULL)
 		return (NULL);
 	vmmap_add(off, size);
@@ -502,7 +502,7 @@ vunmap(void *addr)
 	if (vmmap == NULL)
 		return;
 	pmap_qremove(addr, vmmap->vm_size / PAGE_SIZE);
-	kva_free((vm_offset_t)addr, vmmap->vm_size);
+	kva_free(addr, vmmap->vm_size);
 	kfree(vmmap);
 }
 

sys/dev/drm2/ttm/ttm_bo_util.c

@@ -510,7 +510,7 @@ static int ttm_bo_kmap_ttm(struct ttm_buffer_object *bo,
 			VM_MEMATTR_DEFAULT : ttm_io_prot(mem->placement);
 		map->bo_kmap_type = ttm_bo_map_vmap;
 		map->num_pages = num_pages;
-		map->virtual = (void *)kva_alloc(num_pages * PAGE_SIZE);
+		map->virtual = kva_alloc(num_pages * PAGE_SIZE);
 		if (map->virtual != NULL) {
 			for (i = 0; i < num_pages; i++) {
 				/* XXXKIB hack */
@@ -572,8 +572,7 @@ void ttm_bo_kunmap(struct ttm_bo_kmap_obj *map)
 		break;
 	case ttm_bo_map_vmap:
 		pmap_qremove(map->virtual, map->num_pages);
-		kva_free((vm_offset_t)map->virtual,
-		    map->num_pages * PAGE_SIZE);
+		kva_free(map->virtual, map->num_pages * PAGE_SIZE);
 		break;
 	case ttm_bo_map_kmap:
 		sf_buf_free(map->sf);

sys/dev/gve/gve_qpl.c

@@ -47,7 +47,7 @@ gve_free_qpl(struct gve_priv *priv, struct gve_queue_page_list *qpl)
 
 	if (qpl->kva) {
 		pmap_qremove(qpl->kva, qpl->num_pages);
-		kva_free((vm_offset_t)qpl->kva, PAGE_SIZE * qpl->num_pages);
+		kva_free(qpl->kva, PAGE_SIZE * qpl->num_pages);
 	}
 
 	for (i = 0; i < qpl->num_pages; i++) {
@@ -60,7 +60,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(qpl->dmas[i].cpu_addr, 1);
-				kva_free((vm_offset_t)qpl->dmas[i].cpu_addr, PAGE_SIZE);
+				kva_free(qpl->dmas[i].cpu_addr, PAGE_SIZE);
 			}
 			vm_page_free(qpl->pages[i]);
 		}
@@ -106,7 +106,7 @@ gve_alloc_qpl(struct gve_priv *priv, uint32_t id, int npages, bool single_kva)
 
 	qpl->kva = NULL;
 	if (single_kva) {
-		qpl->kva = (char *)kva_alloc(PAGE_SIZE * npages);
+		qpl->kva = kva_alloc(PAGE_SIZE * npages);
 		if (!qpl->kva) {
 			device_printf(priv->dev, "Failed to create the single kva for QPL %d\n", id);
 			err = ENOMEM;
@@ -120,7 +120,7 @@ gve_alloc_qpl(struct gve_priv *priv, uint32_t id, int npages, bool single_kva)
 						    VM_ALLOC_ZERO);
 
 		if (!single_kva) {
-			qpl->dmas[i].cpu_addr = (void *)kva_alloc(PAGE_SIZE);
+			qpl->dmas[i].cpu_addr = kva_alloc(PAGE_SIZE);
 			if (!qpl->dmas[i].cpu_addr) {
 				device_printf(priv->dev, "Failed to create kva for page %d in QPL %d", i, id);
 				err = ENOMEM;
@@ -253,7 +253,7 @@ gve_mextadd_free(struct mbuf *mbuf)
 	 */
 	if (__predict_false(vm_page_unwire_noq(page))) {
 		pmap_qremove(va, 1);
-		kva_free((vm_offset_t)va, PAGE_SIZE);
+		kva_free(va, PAGE_SIZE);
 		vm_page_free(page);
 	}
 }

sys/dev/hwt/hwt_vm.c

@@ -127,7 +127,7 @@ hwt_vm_alloc_pages(struct hwt_vm *vm, int kva_req)
 
 	if (kva_req) {
 		vm->kvaddr = kva_alloc(vm->npages * PAGE_SIZE);
-		if (!vm->kvaddr)
+		if (vm->kvaddr == NULL)
 			return (ENOMEM);
 	}
 
@@ -441,8 +441,8 @@ hwt_vm_destroy_buffers(struct hwt_vm *vm)
 	vm_page_t m;
 	int i;
 
-	if (vm->ctx->hwt_backend->kva_req && vm->kvaddr != 0) {
-		pmap_qremove((void *)vm->kvaddr, vm->npages);
+	if (vm->ctx->hwt_backend->kva_req && vm->kvaddr != NULL) {
+		pmap_qremove(vm->kvaddr, vm->npages);
 		kva_free(vm->kvaddr, vm->npages * PAGE_SIZE);
 	}
 	VM_OBJECT_WLOCK(vm->obj);

sys/dev/hwt/hwt_vm.h

@@ -33,7 +33,7 @@ struct hwt_vm {
 	vm_page_t			*pages;
 	int				npages;
 	vm_object_t			obj;
-	vm_offset_t			kvaddr;
+	void				*kvaddr;
 	struct cdev			*cdev;
 
 	struct hwt_context		*ctx;

sys/dev/md/md.c

@@ -1512,7 +1512,7 @@ mdcreate_vnode(struct md_s *sc, struct md_req *mdr, struct thread *td)
 		goto bad;
 	}
 
-	sc->s_vnode.kva = (char *)kva_alloc(maxphys + PAGE_SIZE);
+	sc->s_vnode.kva = kva_alloc(maxphys + PAGE_SIZE);
 	return (0);
 bad:
 	VOP_UNLOCK(nd.ni_vp);
@@ -1567,7 +1567,7 @@ mddestroy(struct md_s *sc, struct thread *td)
 			    sc->cred, td);
 		}
 		if (sc->s_vnode.kva != NULL)
-			kva_free((vm_offset_t)sc->s_vnode.kva, maxphys + PAGE_SIZE);
+			kva_free(sc->s_vnode.kva, maxphys + PAGE_SIZE);
 		break;
 	case MD_SWAP:
 		if (sc->s_swap.object != NULL)

sys/dev/pci/controller/pci_n1sdp.c

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

sys/dev/spibus/spigen.c

@@ -285,7 +285,7 @@ spigen_mmap_cleanup(void *arg)
 
 	if (mmap->kvaddr != NULL) {
 		pmap_qremove(mmap->kvaddr, mmap->bufsize / PAGE_SIZE);
-		kva_free((vm_offset_t)mmap->kvaddr, mmap->bufsize);
+		kva_free(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 = (void *)kva_alloc(size)) == 0) {
+	if ((mmap->kvaddr = kva_alloc(size)) == 0) {
 		spigen_mmap_cleanup(mmap);
 		return (ENOMEM);
 	}

sys/dev/xdma/xdma.h

@@ -93,7 +93,7 @@ struct xchan_buf {
 	bus_dmamap_t			map;
 	uint32_t			nsegs;
 	uint32_t			nsegs_left;
-	vm_offset_t			vaddr;
+	void				*vaddr;
 	vm_offset_t			paddr;
 	vm_size_t			size;
 };

sys/dev/xdma/xdma_sg.c

@@ -75,9 +75,9 @@ xchan_bufs_free_reserved(xdma_channel_t *xchan)
 		xr = &xchan->xr_mem[i];
 		size = xr->buf.size;
 		if (xr->buf.vaddr) {
-			pmap_kremove_device(xr->buf.vaddr, size);
+			pmap_kremove_device((vm_offset_t)xr->buf.vaddr, size);
 			kva_free(xr->buf.vaddr, size);
-			xr->buf.vaddr = 0;
+			xr->buf.vaddr = NULL;
 		}
 		if (xr->buf.paddr) {
 			vmem_free(xchan->vmem, xr->buf.paddr, size);
@@ -115,13 +115,13 @@ xchan_bufs_alloc_reserved(xdma_channel_t *xchan)
 		xr->buf.size = size;
 		xr->buf.paddr = addr;
 		xr->buf.vaddr = kva_alloc(size);
-		if (xr->buf.vaddr == 0) {
+		if (xr->buf.vaddr == NULL) {
 			device_printf(xdma->dev,
 			    "%s: Can't allocate KVA\n", __func__);
 			xchan_bufs_free_reserved(xchan);
 			return (ENOMEM);
 		}
-		pmap_kenter_device(xr->buf.vaddr, size, addr);
+		pmap_kenter_device((vm_offset_t)xr->buf.vaddr, size, addr);
 	}
 
 	return (0);
@@ -346,7 +346,7 @@ xchan_seg_done(xdma_channel_t *xchan,
 			if (xr->req_type == XR_TYPE_MBUF &&
 			    xr->direction == XDMA_DEV_TO_MEM)
 				m_copyback(xr->m, 0, st->transferred,
-				    (void *)xr->buf.vaddr);
+				    xr->buf.vaddr);
 		} else if (xchan->caps & XCHAN_CAP_IOMMU) {
 			if (xr->direction == XDMA_MEM_TO_DEV)
 				addr = xr->src_addr;
@@ -500,7 +500,7 @@ _xdma_load_data(xdma_channel_t *xchan, struct xdma_request *xr,
 		if (xchan->caps & XCHAN_CAP_BOUNCE) {
 			if (xr->direction == XDMA_MEM_TO_DEV)
 				m_copydata(m, 0, m->m_pkthdr.len,
-				    (void *)xr->buf.vaddr);
+				    xr->buf.vaddr);
 			seg[0].ds_addr = (bus_addr_t)xr->buf.paddr;
 		} else if (xchan->caps & XCHAN_CAP_IOMMU) {
 			addr = mtod(m, bus_addr_t);

sys/i386/i386/copyout.c

@@ -89,11 +89,11 @@ copyout_init_tramp(void)
 
 int
 cp_slow0(vm_offset_t uva, size_t len, bool write,
-    void (*f)(vm_offset_t, void *), void *arg)
+    void (*f)(void *, void *), void *arg)
 {
 	struct pcpu *pc;
 	vm_page_t m[2];
-	vm_offset_t kaddr;
+	char *kaddr;
 	int error, i, plen;
 	bool sleepable;
 
@@ -117,7 +117,7 @@ cp_slow0(vm_offset_t uva, size_t len, bool write,
 		sx_xlock(&pc->pc_copyout_slock);
 		kaddr = pc->pc_copyout_saddr;
 	}
-	pmap_cp_slow0_map(kaddr, plen, m);
+	pmap_cp_slow0_map((vm_offset_t)kaddr, plen, m);
 	kaddr += uva - trunc_page(uva);
 	f(kaddr, arg);
 	sched_unpin();
@@ -130,23 +130,25 @@ cp_slow0(vm_offset_t uva, size_t len, bool write,
 }
 
 struct copyinstr_arg0 {
-	vm_offset_t kc;
+	char *kc;
 	size_t len;
 	size_t alen;
 	bool end;
 };
 
 static void
-copyinstr_slow0(vm_offset_t kva, void *arg)
+copyinstr_slow0(void *kva, void *arg)
 {
 	struct copyinstr_arg0 *ca;
+	char *src;
 	char c;
 
 	ca = arg;
+	src = kva;
 	MPASS(ca->alen == 0 && ca->len > 0 && !ca->end);
 	while (ca->alen < ca->len && !ca->end) {
-		c = *(char *)(kva + ca->alen);
-		*(char *)ca->kc = c;
+		c = *(src + ca->alen);
+		*ca->kc = c;
 		ca->alen++;
 		ca->kc++;
 		if (c == '\0')
@@ -164,7 +166,7 @@ copyinstr(const void *udaddr, void *kaddr, size_t maxlen, size_t *lencopied)
 
 	error = 0;
 	ca.end = false;
-	for (plen = 0, uc = (vm_offset_t)udaddr, ca.kc = (vm_offset_t)kaddr;
+	for (plen = 0, uc = (vm_offset_t)udaddr, ca.kc = kaddr;
 	    plen < maxlen && !ca.end; uc += ca.alen, plen += ca.alen) {
 		ca.len = round_page(uc) - uc;
 		if (ca.len == 0)
@@ -185,17 +187,17 @@ copyinstr(const void *udaddr, void *kaddr, size_t maxlen, size_t *lencopied)
 }
 
 struct copyin_arg0 {
-	vm_offset_t kc;
+	char *kc;
 	size_t len;
 };
 
 static void
-copyin_slow0(vm_offset_t kva, void *arg)
+copyin_slow0(void *kva, void *arg)
 {
 	struct copyin_arg0 *ca;
 
 	ca = arg;
-	bcopy((void *)kva, (void *)ca->kc, ca->len);
+	bcopy(kva, ca->kc, ca->len);
 }
 
 int
@@ -211,7 +213,7 @@ copyin(const void *udaddr, void *kaddr, size_t len)
 	if (len == 0 || (fast_copyout && len <= TRAMP_COPYOUT_SZ &&
 	    copyin_fast_tramp(udaddr, kaddr, len, pmap_get_kcr3()) == 0))
 		return (0);
-	for (plen = 0, uc = (vm_offset_t)udaddr, ca.kc = (vm_offset_t)kaddr;
+	for (plen = 0, uc = (vm_offset_t)udaddr, ca.kc = kaddr;
 	    plen < len; uc += ca.len, ca.kc += ca.len, plen += ca.len) {
 		ca.len = round_page(uc) - uc;
 		if (ca.len == 0)
@@ -225,12 +227,12 @@ copyin(const void *udaddr, void *kaddr, size_t len)
 }
 
 static void
-copyout_slow0(vm_offset_t kva, void *arg)
+copyout_slow0(void *kva, void *arg)
 {
 	struct copyin_arg0 *ca;
 
 	ca = arg;
-	bcopy((void *)ca->kc, (void *)kva, ca->len);
+	bcopy(ca->kc, kva, ca->len);
 }
 
 int
@@ -246,7 +248,7 @@ copyout(const void *kaddr, void *udaddr, size_t len)
 	if (len == 0 || (fast_copyout && len <= TRAMP_COPYOUT_SZ &&
 	    copyout_fast_tramp(kaddr, udaddr, len, pmap_get_kcr3()) == 0))
 		return (0);
-	for (plen = 0, uc = (vm_offset_t)udaddr, ca.kc = (vm_offset_t)kaddr;
+	for (plen = 0, uc = (vm_offset_t)udaddr, ca.kc = __DECONST(void *, kaddr);
 	    plen < len; uc += ca.len, ca.kc += ca.len, plen += ca.len) {
 		ca.len = round_page(uc) - uc;
 		if (ca.len == 0)
@@ -265,7 +267,7 @@ copyout(const void *kaddr, void *udaddr, size_t len)
  */
 
 static void
-fubyte_slow0(vm_offset_t kva, void *arg)
+fubyte_slow0(void *kva, void *arg)
 {
 
 	*(int *)arg = *(u_char *)kva;
@@ -291,7 +293,7 @@ fubyte(volatile const void *base)
 }
 
 static void
-fuword16_slow0(vm_offset_t kva, void *arg)
+fuword16_slow0(void *kva, void *arg)
 {
 
 	*(int *)arg = *(uint16_t *)kva;
@@ -317,7 +319,7 @@ fuword16(volatile const void *base)
 }
 
 static void
-fueword_slow0(vm_offset_t kva, void *arg)
+fueword_slow0(void *kva, void *arg)
 {
 
 	*(uint32_t *)arg = *(uint32_t *)kva;
@@ -354,7 +356,7 @@ fueword32(volatile const void *base, int32_t *val)
  */
 
 static void
-subyte_slow0(vm_offset_t kva, void *arg)
+subyte_slow0(void *kva, void *arg)
 {
 
 	*(u_char *)kva = *(int *)arg;
@@ -374,7 +376,7 @@ subyte(volatile void *base, int byte)
 }
 
 static void
-suword16_slow0(vm_offset_t kva, void *arg)
+suword16_slow0(void *kva, void *arg)
 {
 
 	*(int *)kva = *(uint16_t *)arg;
@@ -395,7 +397,7 @@ suword16(volatile void *base, int word)
 }
 
 static void
-suword_slow0(vm_offset_t kva, void *arg)
+suword_slow0(void *kva, void *arg)
 {
 
 	*(int *)kva = *(uint32_t *)arg;
@@ -428,7 +430,7 @@ struct casueword_arg0 {
 };
 
 static void
-casueword_slow0(vm_offset_t kva, void *arg)
+casueword_slow0(void *kva, void *arg)
 {
 	struct casueword_arg0 *ca;
 

sys/i386/i386/pmap.c

@@ -665,7 +665,7 @@ __CONCAT(PMTYPE, bootstrap)(vm_paddr_t firstaddr)
 	mtx_init(&pc->pc_cmap_lock, "SYSMAPS", NULL, MTX_DEF);
 	SYSMAP(caddr_t, pc->pc_cmap_pte1, pc->pc_cmap_addr1, 1)
 	SYSMAP(caddr_t, pc->pc_cmap_pte2, pc->pc_cmap_addr2, 1)
-	SYSMAP(vm_offset_t, pte, pc->pc_qmap_addr, 1)
+	SYSMAP(caddr_t, pte, pc->pc_qmap_addr, 1)
 
 	SYSMAP(caddr_t, CMAP3, CADDR3, 1);
 
@@ -723,7 +723,7 @@ static void
 pmap_init_reserved_pages(void *dummy __unused)
 {
 	struct pcpu *pc;
-	vm_offset_t pages;
+	char *pages;
 	int i;
 
 #ifdef PMAP_PAE_COMP
@@ -738,13 +738,13 @@ pmap_init_reserved_pages(void *dummy __unused)
 		mtx_init(&pc->pc_copyout_mlock, "cpmlk", NULL, MTX_DEF |
 		    MTX_NEW);
 		pc->pc_copyout_maddr = kva_alloc(ptoa(2));
-		if (pc->pc_copyout_maddr == 0)
+		if (pc->pc_copyout_maddr == NULL)
 			panic("unable to allocate non-sleepable copyout KVA");
 		sx_init(&pc->pc_copyout_slock, "cpslk");
 		pc->pc_copyout_saddr = kva_alloc(ptoa(2));
-		if (pc->pc_copyout_saddr == 0)
+		if (pc->pc_copyout_saddr == NULL)
 			panic("unable to allocate sleepable copyout KVA");
-		pc->pc_pmap_eh_va = kva_alloc(ptoa(1));
+		pc->pc_pmap_eh_va = (vm_offset_t)kva_alloc(ptoa(1));
 		if (pc->pc_pmap_eh_va == 0)
 			panic("unable to allocate pmap_extract_and_hold KVA");
 		pc->pc_pmap_eh_ptep = (char *)vtopte(pc->pc_pmap_eh_va);
@@ -758,12 +758,12 @@ pmap_init_reserved_pages(void *dummy __unused)
 
 		mtx_init(&pc->pc_cmap_lock, "SYSMAPS", NULL, MTX_DEF);
 		pages = kva_alloc(PAGE_SIZE * 3);
-		if (pages == 0)
+		if (pages == NULL)
 			panic("unable to allocate CMAP KVA");
-		pc->pc_cmap_pte1 = vtopte(pages);
-		pc->pc_cmap_pte2 = vtopte(pages + PAGE_SIZE);
-		pc->pc_cmap_addr1 = (caddr_t)pages;
-		pc->pc_cmap_addr2 = (caddr_t)(pages + PAGE_SIZE);
+		pc->pc_cmap_pte1 = vtopte((vm_offset_t)pages);
+		pc->pc_cmap_pte2 = vtopte((vm_offset_t)pages + PAGE_SIZE);
+		pc->pc_cmap_addr1 = pages;
+		pc->pc_cmap_addr2 = pages + PAGE_SIZE;
 		pc->pc_qmap_addr = pages + ptoa(2);
 	}
 }
@@ -1038,7 +1038,7 @@ __CONCAT(PMTYPE, init)(void)
 		TAILQ_INIT(&pv_table[i].pv_list);
 
 	pv_maxchunks = MAX(pv_entry_max / _NPCPV, maxproc);
-	pv_chunkbase = (struct pv_chunk *)kva_alloc(PAGE_SIZE * pv_maxchunks);
+	pv_chunkbase = kva_alloc(PAGE_SIZE * pv_maxchunks);
 	if (pv_chunkbase == NULL)
 		panic("pmap_init: not enough kvm for pv chunks");
 	pmap_ptelist_init(&pv_vafree, pv_chunkbase, pv_maxchunks);
@@ -2060,7 +2060,7 @@ __CONCAT(PMTYPE, pinit)(pmap_t pmap)
 	 * page directory table.
 	 */
 	if (pmap->pm_pdir == NULL) {
-		pmap->pm_pdir = (pd_entry_t *)kva_alloc(NBPTD);
+		pmap->pm_pdir = kva_alloc(NBPTD);
 		if (pmap->pm_pdir == NULL)
 			return (0);
 #ifdef PMAP_PAE_COMP
@@ -5562,7 +5562,7 @@ __CONCAT(PMTYPE, mapdev_attr)(vm_paddr_t pa, vm_size_t size, int mode,
 			    (flags & MAPDEV_SETATTR) == 0))
 				return ((void *)(ppim->va + offset));
 		}
-		va = kva_alloc(size);
+		va = (vm_offset_t)kva_alloc(size);
 		if (va == 0)
 			panic("%s: Couldn't allocate KVA", __func__);
 	}
@@ -5611,7 +5611,7 @@ __CONCAT(PMTYPE, unmapdev)(void *p, vm_size_t size)
 	}
 	if (pmap_initialized) {
 		pmap_qremove((void *)va, atop(size));
-		kva_free(va, size);
+		kva_free((void *)va, size);
 	}
 }
 
@@ -5934,33 +5934,33 @@ __CONCAT(PMTYPE, align_superpage)(vm_object_t object, vm_ooffset_t offset,
 static void *
 __CONCAT(PMTYPE, quick_enter_page)(vm_page_t m)
 {
-	vm_offset_t qaddr;
+	void *qaddr;
 	pt_entry_t *pte;
 
 	critical_enter();
 	qaddr = PCPU_GET(qmap_addr);
-	pte = vtopte(qaddr);
+	pte = vtopte((vm_offset_t)qaddr);
 
 	KASSERT(*pte == 0,
 	    ("pmap_quick_enter_page: PTE busy %#jx", (uintmax_t)*pte));
 	*pte = PG_V | PG_RW | VM_PAGE_TO_PHYS(m) | PG_A | PG_M |
 	    pmap_cache_bits(kernel_pmap, pmap_page_get_memattr(m), false);
-	invlpg(qaddr);
+	invlpg((vm_offset_t)qaddr);
 
-	return ((void *)qaddr);
+	return (qaddr);
 }
 
 static void
 __CONCAT(PMTYPE, quick_remove_page)(void *addr)
 {
-	vm_offset_t qaddr;
+	void *qaddr;
 	pt_entry_t *pte;
 
 	qaddr = PCPU_GET(qmap_addr);
-	pte = vtopte(qaddr);
+	pte = vtopte((vm_offset_t)qaddr);
 
 	KASSERT(*pte != 0, ("pmap_quick_remove_page: PTE not in use"));
-	KASSERT(addr == (void *)qaddr,
+	KASSERT(addr == qaddr,
 	    ("pmap_quick_remove_page: invalid address"));
 
 	*pte = 0;

sys/i386/include/md_var.h

@@ -53,7 +53,7 @@ struct	segment_descriptor;
 union savefpu;
 
 int	cp_slow0(vm_offset_t uva, size_t len, bool write,
-	    void (*f)(vm_offset_t, void *), void *arg);
+	    void (*f)(void *, void *), void *arg);
 void	cpu_switch_load_gs(void) __asm(__STRING(cpu_switch_load_gs));
 void	copyout_init_tramp(void);
 void	doreti_iret(void) __asm(__STRING(doreti_iret));

sys/i386/include/pcpu.h

@@ -71,9 +71,9 @@ _Static_assert(sizeof(struct monitorbuf) == 128, "2x cache line");
 	void	*pc_cmap_pte2;						\
 	caddr_t	pc_cmap_addr1;						\
 	caddr_t	pc_cmap_addr2;						\
-	vm_offset_t pc_qmap_addr;	/* KVA for temporary mappings */\
-	vm_offset_t pc_copyout_maddr;					\
-	vm_offset_t pc_copyout_saddr;					\
+	caddr_t pc_qmap_addr;		/* KVA for temporary mappings */\
+	void	*pc_copyout_maddr;					\
+	void	*pc_copyout_saddr;					\
 	struct	mtx pc_copyout_mlock;					\
 	struct	sx pc_copyout_slock;					\
 	char	*pc_copyout_buf;					\

sys/i386/linux/linux_copyout.c

@@ -51,12 +51,12 @@ struct futex_st0 {
 };
 
 static void
-futex_xchgl_slow0(vm_offset_t kva, void *arg)
+futex_xchgl_slow0(void *kva, void *arg)
 {
 	struct futex_st0 *st;
 
 	st = arg;
-	*st->oldval = atomic_swap_int((int *)kva, st->oparg);
+	*st->oldval = atomic_swap_int(kva, st->oparg);
 }
 
 int
@@ -73,12 +73,12 @@ futex_xchgl(int oparg, uint32_t *uaddr, int *oldval)
 }
 
 static void
-futex_addl_slow0(vm_offset_t kva, void *arg)
+futex_addl_slow0(void *kva, void *arg)
 {
 	struct futex_st0 *st;
 
 	st = arg;
-	*st->oldval = atomic_fetchadd_int((int *)kva, st->oparg);
+	*st->oldval = atomic_fetchadd_int(kva, st->oparg);
 }
 
 int
@@ -95,14 +95,14 @@ futex_addl(int oparg, uint32_t *uaddr, int *oldval)
 }
 
 static void
-futex_orl_slow0(vm_offset_t kva, void *arg)
+futex_orl_slow0(void *kva, void *arg)
 {
 	struct futex_st0 *st;
 	int old;
 
 	st = arg;
 	old = *(int *)kva;
-	while (!atomic_fcmpset_int((int *)kva, &old, old | st->oparg))
+	while (!atomic_fcmpset_int(kva, &old, old | st->oparg))
 		;
 	*st->oldval = old;
 }
@@ -121,14 +121,14 @@ futex_orl(int oparg, uint32_t *uaddr, int *oldval)
 }
 
 static void
-futex_andl_slow0(vm_offset_t kva, void *arg)
+futex_andl_slow0(void *kva, void *arg)
 {
 	struct futex_st0 *st;
 	int old;
 
 	st = arg;
 	old = *(int *)kva;
-	while (!atomic_fcmpset_int((int *)kva, &old, old & st->oparg))
+	while (!atomic_fcmpset_int(kva, &old, old & st->oparg))
 		;
 	*st->oldval = old;
 }
@@ -147,14 +147,14 @@ futex_andl(int oparg, uint32_t *uaddr, int *oldval)
 }
 
 static void
-futex_xorl_slow0(vm_offset_t kva, void *arg)
+futex_xorl_slow0(void *kva, void *arg)
 {
 	struct futex_st0 *st;
 	int old;
 
 	st = arg;
 	old = *(int *)kva;
-	while (!atomic_fcmpset_int((int *)kva, &old, old ^ st->oparg))
+	while (!atomic_fcmpset_int(kva, &old, old ^ st->oparg))
 		;
 	*st->oldval = old;
 }

sys/i386/pci/pci_cfgreg.c

@@ -492,7 +492,7 @@ pcie_init_cache(void)
 		if (pcie_array == NULL)
 			return (false);
 
-		va = kva_alloc(PCIE_CACHE * PAGE_SIZE);
+		va = (vm_offset_t)kva_alloc(PCIE_CACHE * PAGE_SIZE);
 		if (va == 0) {
 			free(pcie_array, M_DEVBUF);
 			return (false);

sys/kern/kern_kcov.c

@@ -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 = (void *)kva_alloc(info->bufsize)) == 0)
+	if ((info->kvaddr = kva_alloc(info->bufsize)) == 0)
 		return (ENOMEM);
 
 	info->bufobj = vm_pager_allocate(OBJT_PHYS, 0, info->bufsize,
@@ -402,7 +402,7 @@ kcov_free(struct kcov_info *info)
 
 	if (info->kvaddr != NULL) {
 		pmap_qremove(info->kvaddr, info->bufsize / PAGE_SIZE);
-		kva_free((vm_offset_t)info->kvaddr, info->bufsize);
+		kva_free(info->kvaddr, info->bufsize);
 	}
 	if (info->bufobj != NULL) {
 		vm_page_iter_limit_init(&pages, info->bufobj,

sys/kern/kern_sharedpage.c

@@ -125,7 +125,7 @@ shared_page_init(void *dummy __unused)
 	VM_OBJECT_WUNLOCK(shared_page_obj);
 	vm_page_valid(m);
 	vm_page_xunbusy(m);
-	addr = (void *)kva_alloc(PAGE_SIZE);
+	addr = kva_alloc(PAGE_SIZE);
 	pmap_qenter(addr, &m, 1);
 	shared_page_mapping = addr;
 }

sys/kern/subr_devmap.c

@@ -255,7 +255,8 @@ pmap_mapdev(vm_paddr_t pa, vm_size_t size)
 void *
 pmap_mapdev_attr(vm_paddr_t pa, vm_size_t size, vm_memattr_t ma)
 {
-	vm_offset_t va, offset;
+	char *va;
+	vm_offset_t offset;
 #ifdef __HAVE_STATIC_DEVMAP
 	void * rva;
 
@@ -278,8 +279,9 @@ pmap_mapdev_attr(vm_paddr_t pa, vm_size_t size, vm_memattr_t ma)
 #ifdef PMAP_MAPDEV_EARLY_SIZE
 	if (early_boot) {
 		akva_devmap_vaddr = trunc_page(akva_devmap_vaddr - size);
-		va = akva_devmap_vaddr;
-		KASSERT(va >= (VM_MAX_KERNEL_ADDRESS - PMAP_MAPDEV_EARLY_SIZE),
+		va = (char *)akva_devmap_vaddr;
+		KASSERT((vm_offset_t)va >=
+		    (VM_MAX_KERNEL_ADDRESS - PMAP_MAPDEV_EARLY_SIZE),
 		    ("%s: Too many early devmap mappings", __func__));
 	} else
 #endif
@@ -291,34 +293,33 @@ pmap_mapdev_attr(vm_paddr_t pa, vm_size_t size, vm_memattr_t ma)
 	else
 #endif
 		va = kva_alloc(size);
-	if (!va)
+	if (va == NULL)
 		panic("pmap_mapdev: Couldn't alloc kernel virtual memory");
 
-	pmap_kenter(va, size, pa, ma);
+	pmap_kenter((vm_offset_t)va, size, pa, ma);
 
-	return ((void *)(va + offset));
+	return (va + offset);
 }
 
 /*
  * Unmap device memory and free the kva space.
  */
 void
-pmap_unmapdev(void *p, vm_size_t size)
+pmap_unmapdev(void *va, vm_size_t size)
 {
-	vm_offset_t offset, va;
+	vm_offset_t offset;
 
 #ifdef __HAVE_STATIC_DEVMAP
 	/* Nothing to do if we find the mapping in the static table. */
-	if (devmap_vtop(p, size) != DEVMAP_PADDR_NOTFOUND)
+	if (devmap_vtop(va, size) != DEVMAP_PADDR_NOTFOUND)
 		return;
 #endif
 
-	va = (vm_offset_t)p;
-	offset = va & PAGE_MASK;
+	offset = (vm_offset_t)va & PAGE_MASK;
 	va = trunc_page(va);
 	size = round_page(size + offset);
 
-	pmap_kremove_device(va, size);
+	pmap_kremove_device((vm_offset_t)va, size);
 	kva_free(va, size);
 }
 

sys/kern/subr_sfbuf.c

@@ -93,7 +93,7 @@ sf_buf_init(void *arg)
 
 	sf_buf_active = hashinit(nsfbufs, M_TEMP, &sf_buf_hashmask);
 	TAILQ_INIT(&sf_buf_freelist);
-	sf_base = kva_alloc(nsfbufs * PAGE_SIZE);
+	sf_base = (vm_offset_t)kva_alloc(nsfbufs * PAGE_SIZE);
 	sf_bufs = malloc(nsfbufs * sizeof(struct sf_buf), M_TEMP,
 	    M_WAITOK | M_ZERO);
 	for (i = 0; i < nsfbufs; i++) {

sys/kern/vfs_bio.c

@@ -1225,7 +1225,7 @@ bufinit(void)
 	mtx_init(&bdlock, "buffer daemon lock", NULL, MTX_DEF);
 	mtx_init(&bdirtylock, "dirty buf lock", NULL, MTX_DEF);
 
-	unmapped_buf = (caddr_t)kva_alloc(maxphys);
+	unmapped_buf = kva_alloc(maxphys);
 #ifdef INVARIANTS
 	poisoned_buf = unmapped_buf;
 #endif

sys/powerpc/aim/mmu_oea.c

@@ -2695,7 +2695,8 @@ moea_mapdev(vm_paddr_t pa, vm_size_t size)
 void *
 moea_mapdev_attr(vm_paddr_t pa, vm_size_t size, vm_memattr_t ma)
 {
-	vm_offset_t va, tmpva, ppa, offset;
+	char *va;
+	vm_offset_t tmpva, ppa, offset;
 	int i;
 
 	ppa = trunc_page(pa);
@@ -2713,10 +2714,10 @@ moea_mapdev_attr(vm_paddr_t pa, vm_size_t size, vm_memattr_t ma)
 	}
 
 	va = kva_alloc(size);
-	if (!va)
+	if (va == NULL)
 		panic("moea_mapdev: Couldn't alloc kernel virtual memory");
 
-	for (tmpva = va; size > 0;) {
+	for (tmpva = (vm_offset_t)va; size > 0;) {
 		moea_kenter_attr(tmpva, ppa, ma);
 		tlbie(tmpva);
 		size -= PAGE_SIZE;
@@ -2724,13 +2725,14 @@ moea_mapdev_attr(vm_paddr_t pa, vm_size_t size, vm_memattr_t ma)
 		ppa += PAGE_SIZE;
 	}
 
-	return ((void *)(va + offset));
+	return (va + offset);
 }
 
 void
 moea_unmapdev(void *p, vm_size_t size)
 {
-	vm_offset_t base, offset, va;
+	void *base;
+	vm_offset_t offset, va;
 
 	/*
 	 * If this is outside kernel virtual space, then it's a
@@ -2738,10 +2740,10 @@ moea_unmapdev(void *p, vm_size_t size)
 	 */
 	va = (vm_offset_t)p;
 	if ((va >= VM_MIN_KERNEL_ADDRESS) && (va <= virtual_end)) {
-		base = trunc_page(va);
+		base = trunc_page(p);
 		offset = va & PAGE_MASK;
 		size = roundup(offset + size, PAGE_SIZE);
-		moea_qremove(base, atop(size));
+		moea_qremove((vm_offset_t)base, atop(size));
 		kva_free(base, size);
 	}
 }

sys/powerpc/aim/mmu_oea64.c

@@ -1260,11 +1260,11 @@ moea64_pmap_init_qpages(void *dummy __unused)
 	CPU_FOREACH(i) {
 		pc = pcpu_find(i);
 		pc->pc_qmap_addr = kva_alloc(PAGE_SIZE);
-		if (pc->pc_qmap_addr == 0)
+		if (pc->pc_qmap_addr == NULL)
 			panic("pmap_init_qpages: unable to allocate KVA");
 		PMAP_LOCK(kernel_pmap);
-		pc->pc_aim.qmap_pvo =
-		    moea64_pvo_find_va(kernel_pmap, pc->pc_qmap_addr);
+		pc->pc_aim.qmap_pvo = moea64_pvo_find_va(kernel_pmap,
+		    (vm_offset_t)pc->pc_qmap_addr);
 		PMAP_UNLOCK(kernel_pmap);
 		mtx_init(&pc->pc_aim.qmap_lock, "qmap lock", NULL, MTX_DEF);
 	}
@@ -1577,7 +1577,7 @@ moea64_quick_enter_page(vm_page_t m)
 	moea64_pte_replace(pvo, MOEA64_PTE_INVALIDATE);
 	isync();
 
-	return ((void *)PCPU_GET(qmap_addr));
+	return (PCPU_GET(qmap_addr));
 }
 
 void *
@@ -1592,7 +1592,7 @@ moea64_quick_remove_page(void *addr)
 {
 
 	mtx_assert(PCPU_PTR(aim.qmap_lock), MA_OWNED);
-	KASSERT((void *)PCPU_GET(qmap_addr) == addr,
+	KASSERT(PCPU_GET(qmap_addr) == addr,
 	    ("moea64_quick_remove_page: invalid address"));
 	mtx_unlock(PCPU_PTR(aim.qmap_lock));
 	sched_unpin();	
@@ -3155,7 +3155,8 @@ moea64_dev_direct_mapped(vm_paddr_t pa, vm_size_t size)
 void *
 moea64_mapdev_attr(vm_paddr_t pa, vm_size_t size, vm_memattr_t ma)
 {
-	vm_offset_t va, tmpva, ppa, offset;
+	char *va;
+	vm_offset_t tmpva, ppa, offset;
 
 	ppa = trunc_page(pa);
 	offset = pa & PAGE_MASK;
@@ -3163,17 +3164,17 @@ moea64_mapdev_attr(vm_paddr_t pa, vm_size_t size, vm_memattr_t ma)
 
 	va = kva_alloc(size);
 
-	if (!va)
+	if (va == NULL)
 		panic("moea64_mapdev: Couldn't alloc kernel virtual memory");
 
-	for (tmpva = va; size > 0;) {
+	for (tmpva = (vm_offset_t)va; size > 0;) {
 		moea64_kenter_attr(tmpva, ppa, ma);
 		size -= PAGE_SIZE;
 		tmpva += PAGE_SIZE;
 		ppa += PAGE_SIZE;
 	}
 
-	return ((void *)(va + offset));
+	return (va + offset);
 }
 
 void *
@@ -3184,18 +3185,17 @@ moea64_mapdev(vm_paddr_t pa, vm_size_t size)
 }
 
 void
-moea64_unmapdev(void *p, vm_size_t size)
+moea64_unmapdev(void *va, vm_size_t size)
 {
 	void *base;
-	vm_offset_t offset, va;
+	vm_offset_t offset;
 
-	va = (vm_offset_t)p;
-	base = trunc_page(p);
-	offset = va & PAGE_MASK;
+	base = trunc_page(va);
+	offset = (vm_offset_t)va & PAGE_MASK;
 	size = roundup2(offset + size, PAGE_SIZE);
 
 	moea64_qremove(base, atop(size));
-	kva_free((vm_offset_t)base, size);
+	kva_free(base, size);
 }
 
 void

sys/powerpc/aim/mmu_radix.c

@@ -5894,7 +5894,8 @@ mmu_radix_align_superpage(vm_object_t object, vm_ooffset_t offset,
 static void *
 mmu_radix_mapdev_attr(vm_paddr_t pa, vm_size_t size, vm_memattr_t attr)
 {
-	vm_offset_t va, tmpva, ppa, offset;
+	char *va;
+	vm_offset_t tmpva, ppa, offset;
 
 	ppa = trunc_page(pa);
 	offset = pa & PAGE_MASK;
@@ -5907,10 +5908,10 @@ mmu_radix_mapdev_attr(vm_paddr_t pa, vm_size_t size, vm_memattr_t attr)
 		printf("%s(%#lx, %lu, %d)\n", __func__, pa, size, attr);
 	KASSERT(size > 0, ("%s(%#lx, %lu, %d)", __func__, pa, size, attr));
 
-	if (!va)
+	if (va == NULL)
 		panic("%s: Couldn't alloc kernel virtual memory", __func__);
 
-	for (tmpva = va; size > 0;) {
+	for (tmpva = (vm_offset_t)va; size > 0;) {
 		mmu_radix_kenter_attr(tmpva, ppa, attr);
 		size -= PAGE_SIZE;
 		tmpva += PAGE_SIZE;
@@ -5918,7 +5919,7 @@ mmu_radix_mapdev_attr(vm_paddr_t pa, vm_size_t size, vm_memattr_t attr)
 	}
 	ptesync();
 
-	return ((void *)(va + offset));
+	return (va + offset);
 }
 
 static void *
@@ -5953,23 +5954,23 @@ mmu_radix_page_set_memattr(vm_page_t m, vm_memattr_t ma)
 }
 
 static void
-mmu_radix_unmapdev(void *p, vm_size_t size)
+mmu_radix_unmapdev(void *va, vm_size_t size)
 {
-	vm_offset_t offset, va;
+	vm_offset_t offset;
 
-	CTR3(KTR_PMAP, "%s(%p, %#x)", __func__, p, size);
+	CTR3(KTR_PMAP, "%s(%p, %#x)", __func__, va, size);
 
 	/* If we gave a direct map region in pmap_mapdev, do nothing */
-	va = (vm_offset_t)p;
-	if (va >= DMAP_MIN_ADDRESS && va < DMAP_MAX_ADDRESS)
+	if ((vm_offset_t)va >= DMAP_MIN_ADDRESS &&
+	    (vm_offset_t)va < DMAP_MAX_ADDRESS)
 		return;
 
-	offset = va & PAGE_MASK;
+	offset = (vm_offset_t)va & PAGE_MASK;
 	size = round_page(offset + size);
 	va = trunc_page(va);
 
 	if (pmap_initialized) {
-		mmu_radix_qremove((void *)va, atop(size));
+		mmu_radix_qremove(va, atop(size));
 		kva_free(va, size);
 	}
 }

sys/powerpc/booke/pmap.c

@@ -1002,7 +1002,7 @@ booke_pmap_init_qpages(void)
 	CPU_FOREACH(i) {
 		pc = pcpu_find(i);
 		pc->pc_qmap_addr = kva_alloc(PAGE_SIZE);
-		if (pc->pc_qmap_addr == 0)
+		if (pc->pc_qmap_addr == NULL)
 			panic("pmap_init_qpages: unable to allocate KVA");
 	}
 }

sys/powerpc/booke/pmap_32.c

@@ -875,7 +875,7 @@ static void *
 mmu_booke_quick_enter_page(vm_page_t m)
 {
 	vm_paddr_t paddr;
-	vm_offset_t qaddr;
+	void *qaddr;
 	uint32_t flags;
 	pte_t *pte;
 
@@ -888,7 +888,7 @@ mmu_booke_quick_enter_page(vm_page_t m)
 	critical_enter();
 	qaddr = PCPU_GET(qmap_addr);
 
-	pte = pte_find(kernel_pmap, qaddr);
+	pte = pte_find(kernel_pmap, (vm_offset_t)qaddr);
 
 	KASSERT(*pte == 0, ("mmu_booke_quick_enter_page: PTE busy"));
 
@@ -897,16 +897,17 @@ mmu_booke_quick_enter_page(vm_page_t m)
  	 * not be present in other TLBs.  Is there a better instruction
 	 * sequence to use? Or just forget it & use mmu_booke_kenter()... 
 	 */
-	__asm __volatile("tlbivax 0, %0" :: "r"(qaddr & MAS2_EPN_MASK));
+	__asm __volatile("tlbivax 0, %0" ::
+			 "r" ((vm_offset_t)qaddr & MAS2_EPN_MASK));
 	__asm __volatile("isync; msync");
 
 	*pte = PTE_RPN_FROM_PA(paddr) | flags;
 
 	/* Flush the real memory from the instruction cache. */
 	if ((flags & (PTE_I | PTE_G)) == 0)
-		__syncicache((void *)qaddr, PAGE_SIZE);
+		__syncicache(qaddr, PAGE_SIZE);
 
-	return ((void *)qaddr);
+	return (qaddr);
 }
 
 static void
@@ -916,7 +917,7 @@ mmu_booke_quick_remove_page(void *addr)
 
 	pte = pte_find(kernel_pmap, (vm_offset_t)addr);
 
-	KASSERT(PCPU_GET(qmap_addr) == (vm_offset_t)addr,
+	KASSERT(PCPU_GET(qmap_addr) == addr,
 	    ("mmu_booke_quick_remove_page: invalid address"));
 	KASSERT(*pte != 0,
 	    ("mmu_booke_quick_remove_page: PTE not in use"));

sys/powerpc/include/pcpu.h

@@ -53,7 +53,7 @@ struct pvo_entry;
 	register_t	pc_disisave[CPUSAVE_LEN];			\
 	register_t	pc_dbsave[CPUSAVE_LEN];				\
 	void		*pc_restore;					\
-	vm_offset_t	pc_qmap_addr;
+	void		*pc_qmap_addr;
 
 #define PCPU_MD_AIM32_FIELDS						\
 	struct pvo_entry *qmap_pvo;					\

sys/powerpc/mpc85xx/platform_mpc85xx.c

@@ -342,7 +342,8 @@ mpc85xx_smp_start_cpu_epapr(platform_t plat, struct pcpu *pc)
 {
 	vm_paddr_t rel_pa, bptr;
 	volatile struct cpu_release *rel;
-	vm_offset_t rel_va, rel_page;
+	char *rel_page;
+	void *rel_va;
 	phandle_t node;
 	int i;
 
@@ -357,13 +358,13 @@ mpc85xx_smp_start_cpu_epapr(platform_t plat, struct pcpu *pc)
 	}
 
 	rel_page = kva_alloc(PAGE_SIZE);
-	if (rel_page == 0)
+	if (rel_page == NULL)
 		return (ENOMEM);
 
 	critical_enter();
 	rel_va = rel_page + (rel_pa & PAGE_MASK);
-	pmap_kenter(rel_page, rel_pa & ~PAGE_MASK);
-	rel = (struct cpu_release *)rel_va;
+	pmap_kenter((vm_offset_t)rel_page, rel_pa & ~PAGE_MASK);
+	rel = rel_va;
 	bptr = pmap_kextract((uintptr_t)__boot_page);
 
 	cpu_flush_dcache(__DEVOLATILE(struct cpu_release *,rel), sizeof(*rel));
@@ -376,7 +377,7 @@ mpc85xx_smp_start_cpu_epapr(platform_t plat, struct pcpu *pc)
 		printf("Waking up CPU %d via CPU release page %p\n",
 		    pc->pc_cpuid, rel);
 	critical_exit();
-	pmap_kremove(rel_page);
+	pmap_kremove((vm_offset_t)rel_page);
 	kva_free(rel_page, PAGE_SIZE);
 
 	return (0);

sys/vm/uma_core.c

@@ -1989,7 +1989,7 @@ 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 = (void *)kva_alloc(bytes)) == NULL)
+	if ((addr = kva_alloc(bytes)) == NULL)
 		goto fail;
 	zkva = addr;
 	TAILQ_FOREACH(p, &alloctail, plinks.q) {
@@ -2158,7 +2158,7 @@ pcpu_page_free(void *mem, vm_size_t size, uint8_t flags)
 		vm_page_free(m);
 	}
 	pmap_qremove(mem, size >> PAGE_SHIFT);
-	kva_free(sva, size);
+	kva_free(mem, size);
 }
 
 #if defined(UMA_USE_DMAP) && !defined(UMA_MD_SMALL_ALLOC)
@@ -5187,7 +5187,7 @@ int
 uma_zone_reserve_kva(uma_zone_t zone, int count)
 {
 	uma_keg_t keg;
-	vm_offset_t kva;
+	void *kva;
 	u_int pages;
 
 	KEG_GET(zone, keg);
@@ -5202,12 +5202,12 @@ uma_zone_reserve_kva(uma_zone_t zone, int count)
 	if (1) {
 #endif
 		kva = kva_alloc((vm_size_t)pages * PAGE_SIZE);
-		if (kva == 0)
+		if (kva == NULL)
 			return (0);
 	} else
-		kva = 0;
+		kva = NULL;
 
-	MPASS(keg->uk_kva == 0);
+	MPASS(keg->uk_kva == NULL);
 	keg->uk_kva = kva;
 	keg->uk_offset = 0;
 	zone->uz_max_items = pages * keg->uk_ipers;

sys/vm/uma_int.h

@@ -347,7 +347,7 @@ struct uma_keg {
 	uma_free	uk_freef;	/* Free routine */
 
 	u_long		uk_offset;	/* Next free offset from base KVA */
-	vm_offset_t	uk_kva;		/* Zone base KVA */
+	void		*uk_kva;	/* Zone base KVA */
 
 	uint32_t	uk_pgoff;	/* Offset to uma_slab struct */
 	uint16_t	uk_ppera;	/* pages per allocation from backend */

sys/vm/vm_extern.h

@@ -46,9 +46,9 @@ struct cdevsw;
 struct domainset;
 
 /* These operate on kernel virtual addresses only. */
-vm_offset_t kva_alloc(vm_size_t);
-vm_offset_t kva_alloc_aligned(vm_size_t, vm_size_t);
-void kva_free(vm_offset_t, vm_size_t);
+void *kva_alloc(vm_size_t);
+void *kva_alloc_aligned(vm_size_t, vm_size_t);
+void kva_free(void *, vm_size_t);
 
 /* These operate on pageable virtual addresses. */
 vm_offset_t kmap_alloc_wait(vm_map_t, vm_size_t);

sys/vm/vm_glue.c

@@ -330,7 +330,7 @@ vm_thread_alloc_kstack_kva(vm_size_t size, int domain)
 
 	return (addr);
 #else
-	return (kva_alloc(size));
+	return ((vm_offset_t)kva_alloc(size));
 #endif
 }
 

sys/vm/vm_init.c

@@ -238,7 +238,7 @@ again:
 	 * Allocate the clean map to hold all of I/O virtual memory.
 	 */
 	size = (long)nbuf * BKVASIZE + (long)bio_transient_maxcnt * maxphys;
-	kmi->clean_sva = kva_alloc(size);
+	kmi->clean_sva = (vm_offset_t)kva_alloc(size);
 	kmi->clean_eva = kmi->clean_sva + size;
 
 	/*

sys/vm/vm_kern.c

@@ -150,10 +150,10 @@ extern void     uma_startup2(void);
  *	its use, typically with pmap_qenter().  Any attempt to create
  *	a mapping on demand through vm_fault() will result in a panic. 
  */
-vm_offset_t
+void *
 kva_alloc(vm_size_t size)
 {
-	vm_offset_t addr;
+	vmem_addr_t addr;
 
 	TSENTER();
 	size = round_page(size);
@@ -162,7 +162,7 @@ kva_alloc(vm_size_t size)
 		return (0);
 	TSEXIT();
 
-	return (addr);
+	return ((void *)addr);
 }
 
 /*
@@ -171,10 +171,10 @@ kva_alloc(vm_size_t size)
  *	Allocate a virtual address range as in kva_alloc where the base
  *	address is aligned to align.
  */
-vm_offset_t
+void *
 kva_alloc_aligned(vm_size_t size, vm_size_t align)
 {
-	vm_offset_t addr;
+	vmem_addr_t addr;
 
 	TSENTER();
 	size = round_page(size);
@@ -183,7 +183,7 @@ kva_alloc_aligned(vm_size_t size, vm_size_t align)
 		return (0);
 	TSEXIT();
 
-	return (addr);
+	return ((void *)addr);
 }
 
 /*
@@ -196,11 +196,11 @@ kva_alloc_aligned(vm_size_t size, vm_size_t align)
  *	This routine may not block on kernel maps.
  */
 void
-kva_free(vm_offset_t addr, vm_size_t size)
+kva_free(void *addr, vm_size_t size)
 {
 
 	size = round_page(size);
-	vmem_xfree(kernel_arena, addr, size);
+	vmem_xfree(kernel_arena, (uintptr_t)addr, size);
 }
 
 /*
@@ -769,7 +769,8 @@ kmap_free_wakeup(vm_map_t map, vm_offset_t addr, vm_size_t size)
 void
 kmem_init_zero_region(void)
 {
-	vm_offset_t addr, i;
+	char *addr;
+	vm_offset_t i;
 	vm_page_t m;
 
 	/*
@@ -781,8 +782,9 @@ 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((char *)addr + i, &m, 1);
-	pmap_protect(kernel_pmap, addr, addr + ZERO_REGION_SIZE, VM_PROT_READ);
+		pmap_qenter(addr + i, &m, 1);
+	pmap_protect(kernel_pmap, (vm_offset_t)addr,
+	    (vm_offset_t)addr + ZERO_REGION_SIZE, VM_PROT_READ);
 
 	zero_region = (const void *)addr;
 }

sys/vm/vm_pager.c

@@ -501,7 +501,7 @@ pbuf_init(void *mem, int size, int flags)
 
 	TSENTER();
 
-	bp->b_kvabase = (void *)kva_alloc(ptoa(PBUF_PAGES));
+	bp->b_kvabase = kva_alloc(ptoa(PBUF_PAGES));
 	if (bp->b_kvabase == NULL)
 		return (ENOMEM);
 	bp->b_kvasize = ptoa(PBUF_PAGES);

sys/x86/iommu/amd_drv.c

@@ -204,7 +204,7 @@ amdiommu_free_dev_tbl(struct amdiommu_unit *sc)
 
 	devtbl_sz = amdiommu_devtbl_sz(sc);
 	pmap_qremove(sc->dev_tbl, atop(devtbl_sz));
-	kva_free((vm_offset_t)sc->dev_tbl, devtbl_sz);
+	kva_free(sc->dev_tbl, devtbl_sz);
 	sc->dev_tbl = NULL;
 	vm_object_deallocate(sc->devtbl_obj);
 	sc->devtbl_obj = NULL;
@@ -213,7 +213,7 @@ amdiommu_free_dev_tbl(struct amdiommu_unit *sc)
 static int
 amdiommu_create_dev_tbl(struct amdiommu_unit *sc)
 {
-	vm_offset_t seg_vaddr;
+	char *seg_vaddr;
 	u_int devtbl_sz, dom, i, reclaimno, segnum_log, segnum, seg_sz;
 	int error;
 
@@ -247,10 +247,10 @@ amdiommu_create_dev_tbl(struct amdiommu_unit *sc)
 	sc->hw_ctrl |= AMDIOMMU_CTRL_COHERENT;
 	amdiommu_write8(sc, AMDIOMMU_CTRL, sc->hw_ctrl);
 
-	seg_vaddr = kva_alloc(devtbl_sz);
-	if (seg_vaddr == 0)
+	sc->dev_tbl = kva_alloc(devtbl_sz);
+	if (sc->dev_tbl == NULL)
 		return (ENOMEM);
-	sc->dev_tbl = (void *)seg_vaddr;
+	seg_vaddr = (char *)sc->dev_tbl;
 
 	for (i = 0; i < segnum; i++) {
 		vm_page_t m;
@@ -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((void *)seg_vaddr, &m, 1);
+			pmap_qenter(seg_vaddr, &m, 1);
 		}
 		amdiommu_write8(sc, devtab_base_regs[i], rval);
 	}