Renamed [pv]addr_t to [pv]m_t

9 files changed, 91 insertions, 91 deletions

diff --git a/arch/riscv/common/vmem.c b/arch/riscv/common/vmem.c
index d0f3ebe..ef89ec3 100644
--- a/arch/riscv/common/vmem.c
+++ b/arch/riscv/common/vmem.c
@@ -3,22 +3,22 @@
 #include <pages.h>
 #include <vmem.h>
 
-#define pte_ppn(pte) (((paddr_t)(pte)) >> 10)
-#define pte_flags(pte) (((paddr_t)(pte)) & 0xff)
-#define to_pte(p, f) ((paddr_to_pnum(p) << 10) + (f))
+#define pte_ppn(pte) (((pm_t)(pte)) >> 10)
+#define pte_flags(pte) (((pm_t)(pte)) & 0xff)
+#define to_pte(p, f) ((pm_to_pnum(p) << 10) + (f))
 #define pte_addr(pte) (pnum_to_paddr(pte_ppn(pte)))
 
 /* probably not actually this simple, right? */
 void map_vmem(struct vm_branch_t *branch,
-		paddr_t paddr, vaddr_t vaddr,
+		pm_t paddr, vm_t vaddr,
 		uint8_t flags, enum mm_order_t order)
 {
 	enum mm_order_t top = MAX_ORDER;
 	while(top != order){
-		size_t idx = paddr_to_index(vaddr, top);
+		size_t idx = pm_to_index(vaddr, top);
 
 		if(!branch->leaf[idx]){
-			paddr_t new_leaf = alloc_page(MM_KPAGE, 0);
+			pm_t new_leaf = alloc_page(MM_KPAGE, 0);
 			branch->leaf[idx] = (struct vm_branch_t *)to_pte(new_leaf, VM_V);
 			memset((void *)new_leaf, 0, sizeof(struct vm_branch_t));
 		}
@@ -27,19 +27,19 @@ void map_vmem(struct vm_branch_t *branch,
 		top--;
 	}
 
-	size_t idx = paddr_to_index(vaddr, top);
+	size_t idx = pm_to_index(vaddr, top);
 	branch->leaf[idx] = (struct vm_branch_t *)to_pte(paddr, flags);
 }
 
 void unmap_vmem(struct vm_branch_t *branch,
-		vaddr_t vaddr, enum mm_order_t order)
+		vm_t vaddr, enum mm_order_t order)
 {
 	while(order){
-		size_t idx = paddr_to_index(vaddr, order);
+		size_t idx = pm_to_index(vaddr, order);
 		branch = (struct vm_branch_t *)pte_addr(branch->leaf[idx]);
 	}
 
-	size_t idx = paddr_to_index(vaddr, order);
+	size_t idx = pm_to_index(vaddr, order);
 	if(branch->leaf[idx])
 		free_page(order, pte_addr(branch->leaf[idx]));
 
diff --git a/arch/riscv/include/pages.h b/arch/riscv/include/pages.h
index 8ca396a..362499a 100644
--- a/arch/riscv/include/pages.h
+++ b/arch/riscv/include/pages.h
@@ -13,6 +13,6 @@
 #define MM_GPAGE_SIZE SZ_1G
 #define MM_TPAGE_SIZE SZ_512G
 
-typedef uint64_t paddr_t;
+typedef uint64_t pm_t;
 
 #endif /* APOS_RISCV_PAGES_H */
diff --git a/arch/riscv/include/vmem.h b/arch/riscv/include/vmem.h
index 3c27c7b..0aad780 100644
--- a/arch/riscv/include/vmem.h
+++ b/arch/riscv/include/vmem.h
@@ -14,16 +14,16 @@
 #define VM_A (1 << 6)
 #define VM_D (1 << 7)
 
-typedef size_t vaddr_t;
+typedef size_t vm_t;
 struct __packed vm_branch_t {
 	struct vm_branch_t *leaf[512];
 };
 
 void map_vmem(struct vm_branch_t *branch,
-		paddr_t paddr, vaddr_t vaddr,
+		pm_t paddr, vm_t vaddr,
 		uint8_t flags, enum mm_order_t order);
 
-void unmap_vmem(struct vm_branch_t *branch, vaddr_t vaddr, enum mm_order_t order);
+void unmap_vmem(struct vm_branch_t *branch, vm_t vaddr, enum mm_order_t order);
 
 
 #endif /* APOS_RISCV_VMAP_H */
diff --git a/arch/riscv/init/init.c b/arch/riscv/init/init.c
index 0217c79..a64bdf5 100644
--- a/arch/riscv/init/init.c
+++ b/arch/riscv/init/init.c
@@ -12,12 +12,12 @@
 #include <vmem.h>
 #include <csr.h>
 
-struct pmem_layout_t {
-	paddr_t base;
-	paddr_t top;
+struct pm_layout_t {
+	pm_t base;
+	pm_t top;
 };
 
-static struct pmem_layout_t get_memlayout(void *fdt)
+static struct pm_layout_t get_memlayout(void *fdt)
 {
 	struct cell_info_t ci = get_reginfo(fdt, "/memory");
 	int mem_offset = fdt_path_offset(fdt, "/memory");
@@ -26,7 +26,7 @@ static struct pmem_layout_t get_memlayout(void *fdt)
 
 	/* if riscv128 comes around we will probably see addr_cells == 4, but
 	 * I'm not too concerned about it at the moment */
-	paddr_t base = (paddr_t)fdt_load_int_ptr(ci.addr_cells, mem_reg);
+	pm_t base = (pm_t)fdt_load_int_ptr(ci.addr_cells, mem_reg);
 
 	if(ci.addr_cells == 2)
 		mem_reg += sizeof(fdt64_t);
@@ -34,8 +34,8 @@ static struct pmem_layout_t get_memlayout(void *fdt)
 		mem_reg += sizeof(fdt32_t);
 
 	/* -1 because base is a legitimate memory address */
-	paddr_t top = (paddr_t)fdt_load_int_ptr(ci.size_cells, mem_reg) + base - 1;
-	return (struct pmem_layout_t){base, top};
+	pm_t top = (pm_t)fdt_load_int_ptr(ci.size_cells, mem_reg) + base - 1;
+	return (struct pm_layout_t){base, top};
 }
 
 #ifdef DEBUG
@@ -50,16 +50,16 @@ static void init_debug(void *fdt)
 #define init_debug(...)
 #endif
 
-static paddr_t get_kerneltop()
+static pm_t get_kerneltop()
 {
 	/* interesting, for some reason if I define these to be just char
 	 * pointers I get some wacky values. Not sure why that would be, but
 	 * this works. */
 	extern char __init_end, __kernel_size;
-	return (paddr_t)&__init_end + (paddr_t)&__kernel_size;
+	return (pm_t)&__init_end + (pm_t)&__kernel_size;
 }
 
-static paddr_t get_initrdtop(void *fdt)
+static pm_t get_initrdtop(void *fdt)
 {
 	int chosen_offset = fdt_path_offset(fdt, "/chosen");
 	struct cell_info_t ci = get_cellinfo(fdt, chosen_offset);
@@ -67,10 +67,10 @@ static paddr_t get_initrdtop(void *fdt)
 	void *initrd_end_ptr = (void *)fdt_getprop(fdt, chosen_offset,
 			"linux,initrd-end", NULL);
 
-	return (paddr_t)fdt_load_int_ptr(ci.addr_cells, initrd_end_ptr);
+	return (pm_t)fdt_load_int_ptr(ci.addr_cells, initrd_end_ptr);
 }
 
-static paddr_t get_initrdbase(void *fdt)
+static pm_t get_initrdbase(void *fdt)
 {
 	int chosen_offset = fdt_path_offset(fdt, "/chosen");
 	struct cell_info_t ci = get_cellinfo(fdt, chosen_offset);
@@ -78,22 +78,22 @@ static paddr_t get_initrdbase(void *fdt)
 	void *initrd_base_ptr = (void *)fdt_getprop(fdt, chosen_offset,
 			"linux,initrd-start", NULL);
 
-	return (paddr_t)fdt_load_int_ptr(ci.addr_cells, initrd_base_ptr);
+	return (pm_t)fdt_load_int_ptr(ci.addr_cells, initrd_base_ptr);
 }
 
-static paddr_t get_fdttop(void *fdt)
+static pm_t get_fdttop(void *fdt)
 {
 	const char *b = (const char *)fdt;
-	return (paddr_t)(b + fdt_totalsize(fdt));
+	return (pm_t)(b + fdt_totalsize(fdt));
 }
 
-static paddr_t get_fdtbase(void *fdt)
+static pm_t get_fdtbase(void *fdt)
 {
 	/* lol */
-	return (paddr_t)fdt;
+	return (pm_t)fdt;
 }
 
-static void mark_area_used(paddr_t base, paddr_t top)
+static void mark_area_used(pm_t base, pm_t top)
 {
 	size_t area_left = top - base;
 	/* TODO: add in a method to make sure that we use as large mappings as
@@ -114,26 +114,26 @@ static void mark_reserved_mem(void *fdt)
 	struct cell_info_t ci = get_reginfo(fdt, "/reserved-memory/mmode_resv0");
 	uint8_t *rmem_reg = (uint8_t *)fdt_getprop(fdt, rmem_offset, "reg", NULL);
 
-	paddr_t base = (paddr_t)fdt_load_int_ptr(ci.addr_cells, rmem_reg);
+	pm_t base = (pm_t)fdt_load_int_ptr(ci.addr_cells, rmem_reg);
 
 	if(ci.addr_cells == 2)
 		rmem_reg += sizeof(fdt64_t);
 	else
 		rmem_reg += sizeof(fdt32_t);
 
-	paddr_t top = (paddr_t)fdt_load_int_ptr(ci.size_cells, rmem_reg) + base - 1;
+	pm_t top = (pm_t)fdt_load_int_ptr(ci.size_cells, rmem_reg) + base - 1;
 	mark_area_used(base, top);
 }
 
 static void setup_pmem(void *fdt)
 {
-	struct pmem_layout_t pmem = get_memlayout(fdt);
+	struct pm_layout_t pmem = get_memlayout(fdt);
 
-	paddr_t initrd_top = get_initrdtop(fdt);
-	paddr_t kernel_top = get_kerneltop();
-	paddr_t fdt_top = get_fdttop(fdt);
+	pm_t initrd_top = get_initrdtop(fdt);
+	pm_t kernel_top = get_kerneltop();
+	pm_t fdt_top = get_fdttop(fdt);
 
-	paddr_t top = MAX3(kernel_top, initrd_top, fdt_top);
+	pm_t top = MAX3(kernel_top, initrd_top, fdt_top);
 	dbg("initrd_top:\t%#lx\n", initrd_top);
 	dbg("kernel_top:\t%#lx\n", kernel_top);
 	dbg("fdt_top:\t%#lx\n", fdt_top);
@@ -143,7 +143,7 @@ static void setup_pmem(void *fdt)
 	size_t probe_size = probe_pmap(pmem.base, pmem.top - pmem.base);
 	/* riscv handles two byte boundaries better than one byte, so align
 	 * upwards */
-	paddr_t pmap_base = align_up(top + 1, 2);
+	pm_t pmap_base = align_up(top + 1, 2);
 	size_t actual_size = populate_pmap(pmem.base, pmem.top - pmem.base,
 			pmap_base);
 
@@ -171,10 +171,10 @@ static void setup_pmem(void *fdt)
 	mark_reserved_mem(fdt);
 }
 
-paddr_t move_kernel()
+pm_t move_kernel()
 {
 	extern char __init_end, __kernel_size;
-	paddr_t dst = alloc_page(MM_MPAGE, 0);
+	pm_t dst = alloc_page(MM_MPAGE, 0);
 	memmove((void *)dst, &__init_end, (size_t)&__kernel_size);
 
 	return dst;
@@ -182,7 +182,7 @@ paddr_t move_kernel()
 
 struct vm_branch_t *prepare_vmem()
 {
-	paddr_t kernel_dst = move_kernel();
+	pm_t kernel_dst = move_kernel();
 
 	/* TODO: check if this actually works */
 	struct vm_branch_t *branch = (struct vm_branch_t *)alloc_page(MM_KPAGE, 0);
@@ -209,7 +209,7 @@ void start_vmem(struct vm_branch_t *branch)
 	/* TODO: get ASID from CPU id
 	 * TODO: more cores lol
 	 */
-	csr_write(CSR_SATP, SATP_MODE_48 | (((paddr_t)(branch)) >> 12));
+	csr_write(CSR_SATP, SATP_MODE_48 | (((pm_t)(branch)) >> 12));
 }
 
 struct init_data_t populate_initdata(void *fdt, struct vm_branch_t *branch)
@@ -217,8 +217,8 @@ struct init_data_t populate_initdata(void *fdt, struct vm_branch_t *branch)
 	extern char __init_start, __init_end;
 
 	struct init_data_t d = {0};
-	d.init_base = (paddr_t)&__init_start;
-	d.init_top = (paddr_t)&__init_end;
+	d.init_base = (pm_t)&__init_start;
+	d.init_top = (pm_t)&__init_end;
 
 	d.initrd_base = get_initrdbase(fdt);
 	d.initrd_top = get_initrdtop(fdt);
diff --git a/common/debug.c b/common/debug.c
index 523ae7b..73b6894 100644
--- a/common/debug.c
+++ b/common/debug.c
@@ -83,7 +83,7 @@ struct dbg_info_t dbg_from_fdt(void *fdt)
 	struct cell_info_t ci = get_reginfo(fdt, stdout);
 	void *reg_ptr = (void *)fdt_getprop(fdt, stdout_offset, "reg", NULL);
 
-	void *dbg_ptr = (void *)(paddr_t)fdt_load_int_ptr(ci.addr_cells, reg_ptr);
+	void *dbg_ptr = (void *)(pm_t)fdt_load_int_ptr(ci.addr_cells, reg_ptr);
 
 	return (struct dbg_info_t){dbg_ptr, dev};
 }
diff --git a/common/pmem.c b/common/pmem.c
index dcbe921..4546e00 100644
--- a/common/pmem.c
+++ b/common/pmem.c
@@ -39,7 +39,7 @@ struct mm_branch_t {
 };
 
 struct mm_omap_t {
-	paddr_t base;
+	pm_t base;
 	mm_node_t **orders;
 	enum mm_order_t order;
 };
@@ -69,7 +69,7 @@ static void __mark_free(mm_node_t * op, pnum_t pnum, enum mm_order_t tgt,
 	__clear_nbit(o->full[__o_container(idx)], __o_bit(idx));
 }
 
-void free_page(enum mm_order_t order, paddr_t paddr)
+void free_page(enum mm_order_t order, pm_t paddr)
 {
 	for (ssize_t i = MM_O0; i <= MAX_ORDER; ++i) {
 		if (!pmap->omap[i])
@@ -81,7 +81,7 @@ void free_page(enum mm_order_t order, paddr_t paddr)
 
 		for (size_t j = 0; j < omap->order; ++j)
 			__mark_free(omap->orders[j],
-				paddr_to_pnum(paddr - omap->base),
+				pm_to_pnum(paddr - omap->base),
 				order, omap->order, j);
 
 		return;
@@ -123,7 +123,7 @@ static bool __mark_used(mm_node_t * op, pnum_t pnum, enum mm_order_t tgt,
 	return false;
 }
 
-void mark_used(enum mm_order_t order, paddr_t paddr)
+void mark_used(enum mm_order_t order, pm_t paddr)
 {
 	for (ssize_t i = MM_O0; i <= MAX_ORDER; ++i) {
 		if (!pmap->omap[i])
@@ -135,7 +135,7 @@ void mark_used(enum mm_order_t order, paddr_t paddr)
 
 		for (size_t j = 0; j <= omap->order; ++j)
 			__mark_used(omap->orders[j],
-				paddr_to_pnum(paddr - omap->base),
+				pm_to_pnum(paddr - omap->base),
 				order, omap->order, j);
 
 		return;
@@ -173,13 +173,13 @@ static pnum_t __enum_order(mm_node_t * op, pnum_t offset,
 	return -1;
 }
 
-paddr_t alloc_page(enum mm_order_t order, paddr_t offset)
+pm_t alloc_page(enum mm_order_t order, pm_t offset)
 {
 	if (order > MAX_ORDER)
 		return 0;
 
 	pnum_t pnum = -1;
-	paddr_t base = 0;
+	pm_t base = 0;
 	struct mm_omap_t *omap;
 	for (size_t i = order; i <= MAX_ORDER; ++i) {
 		if (!pmap->omap[i])
@@ -190,7 +190,7 @@ paddr_t alloc_page(enum mm_order_t order, paddr_t offset)
 			base = offset - omap->base;
 
 		pnum = __enum_order(omap->orders[order],
-			paddr_to_pnum(base), omap->order, order);
+			pm_to_pnum(base), omap->order, order);
 
 		if (!(pnum < 0))
 			break;
@@ -199,14 +199,14 @@ paddr_t alloc_page(enum mm_order_t order, paddr_t offset)
 	if (pnum < 0)
 		return 0;
 
-	paddr_t paddr = pnum_to_paddr(pnum) + omap->base;
+	pm_t paddr = pnum_to_paddr(pnum) + omap->base;
 	mark_used(order, paddr);
 	return paddr;
 }
 
 
 
-static void __update_order(mm_node_t * op, paddr_t base, paddr_t offset,
+static void __update_order(mm_node_t * op, pm_t base, pm_t offset,
 	enum mm_order_t src, enum mm_order_t dst)
 {
 	if (src == dst) {
@@ -226,7 +226,7 @@ static void __update_order(mm_node_t * op, paddr_t base, paddr_t offset,
 	o->next = (mm_node_t **) move_paddr(o->next, base, offset);
 }
 
-static void __update_omap(struct mm_omap_t *omap, paddr_t base, paddr_t offset)
+static void __update_omap(struct mm_omap_t *omap, pm_t base, pm_t offset)
 {
 	for (size_t i = MM_O0; i <= omap->order; ++i) {
 		__update_order(omap->orders[i], base, offset, omap->order, i);
@@ -237,9 +237,9 @@ static void __update_omap(struct mm_omap_t *omap, paddr_t base, paddr_t offset)
 	omap->orders = (mm_node_t **) move_paddr(omap->orders, base, offset);
 }
 
-void update_pmap(paddr_t offset)
+void update_pmap(pm_t offset)
 {
-	paddr_t base = (paddr_t) pmap;
+	pm_t base = (pm_t) pmap;
 	for (size_t i = 0; i <= MAX_ORDER; ++i) {
 		if (!pmap->omap[i])
 			continue;
@@ -253,7 +253,7 @@ void update_pmap(paddr_t offset)
 }
 
 /* unfortunate that populating the mm info is so complicated */
-static paddr_t __populate_order(mm_node_t ** op, paddr_t cont,
+static pm_t __populate_order(mm_node_t ** op, pm_t cont,
 	enum mm_order_t src, enum mm_order_t dst, size_t num)
 {
 	if (src == dst) {
@@ -286,7 +286,7 @@ static paddr_t __populate_order(mm_node_t ** op, paddr_t cont,
 	return cont;
 }
 
-static paddr_t __probe_order(paddr_t cont, enum mm_order_t src, enum mm_order_t dst,
+static pm_t __probe_order(pm_t cont, enum mm_order_t src, enum mm_order_t dst,
 		size_t num)
 {
 	if(src == dst){
@@ -305,8 +305,8 @@ static paddr_t __probe_order(paddr_t cont, enum mm_order_t src, enum mm_order_t
 	return cont;
 }
 
-static paddr_t __populate_omap(struct mm_omap_t **omap, paddr_t cont,
-	paddr_t base, size_t entries, enum mm_order_t order)
+static pm_t __populate_omap(struct mm_omap_t **omap, pm_t cont,
+	pm_t base, size_t entries, enum mm_order_t order)
 {
 	struct mm_omap_t *lomap = (struct mm_omap_t *)
 		move_forward(cont, sizeof(struct mm_omap_t));
@@ -327,7 +327,7 @@ static paddr_t __populate_omap(struct mm_omap_t **omap, paddr_t cont,
 	return cont;
 }
 
-static paddr_t __probe_omap(paddr_t cont, size_t entries, enum mm_order_t order)
+static pm_t __probe_omap(pm_t cont, size_t entries, enum mm_order_t order)
 {
 	cont += sizeof(struct mm_omap_t);
 	cont += (order + 1) * sizeof(mm_node_t **);
@@ -339,13 +339,13 @@ static paddr_t __probe_omap(paddr_t cont, size_t entries, enum mm_order_t order)
 }
 
 /* only call from init */
-paddr_t populate_pmap(paddr_t ram_base, size_t ram_size, paddr_t cont)
+pm_t populate_pmap(pm_t ram_base, size_t ram_size, pm_t cont)
 {
-	paddr_t start = cont;
+	pm_t start = cont;
 	pmap = (struct mm_pmap_t *)move_forward(cont, sizeof(struct mm_pmap_t));
 	memset(pmap, 0, sizeof(struct mm_pmap_t));
 
-	paddr_t ram_region = ram_base;
+	pm_t ram_region = ram_base;
 	size_t ram_left = ram_size;
 	for (ssize_t i = MAX_ORDER; i >= MM_O0; --i) {
 		size_t entries = ram_left / mm_sizes[i];
@@ -366,13 +366,13 @@ paddr_t populate_pmap(paddr_t ram_base, size_t ram_size, paddr_t cont)
  * easy way to cause weird bugs. Should always at least check that probe_pmap
  * returns the same value as populate_pmap, or possibly even add in some method
  * to combine the two? */
-paddr_t probe_pmap(paddr_t ram_base, size_t ram_size)
+pm_t probe_pmap(pm_t ram_base, size_t ram_size)
 {
-	paddr_t cont = 0;
+	pm_t cont = 0;
 
 	cont += sizeof(struct mm_pmap_t);
 
-	paddr_t ram_region = ram_base;
+	pm_t ram_region = ram_base;
 	size_t ram_left = ram_size;
 	for(ssize_t i = MAX_ORDER; i >= MM_O0; --i){
 		size_t entries = ram_left / mm_sizes[i];
diff --git a/include/apos/init.h b/include/apos/init.h
index 1d687cb..05e24ba 100644
--- a/include/apos/init.h
+++ b/include/apos/init.h
@@ -4,24 +4,24 @@
 #include <apos/pmem.h>
 
 struct init_data_t {
-	paddr_t init_base;
-	paddr_t init_top;
+	pm_t init_base;
+	pm_t init_top;
 
-	paddr_t initrd_base;
-	paddr_t initrd_top;
+	pm_t initrd_base;
+	pm_t initrd_top;
 
-	paddr_t fdt_base;
-	paddr_t fdt_top;
+	pm_t fdt_base;
+	pm_t fdt_top;
 
-	paddr_t stack_base;
-	paddr_t stack_top;
+	pm_t stack_base;
+	pm_t stack_top;
 
 	struct vm_branch_t *kernel_vm_base;
 
 	/*
 	   TODO: is this necessary?
-	   paddr_t pmap_base;
-	   paddr_t pmap_top;
+	   pm_t pmap_base;
+	   pm_t pmap_top;
 	*/
 };
 
diff --git a/include/apos/mem.h b/include/apos/mem.h
index 4846f5e..5e33e28 100644
--- a/include/apos/mem.h
+++ b/include/apos/mem.h
@@ -107,13 +107,13 @@
 #define MM_OINFO_WIDTH (sizeof(mm_info_t) * 8)
 
 #define pnum_to_index(pnum, order) (((pnum) >> __o_offset(order)) & (__o_width(order) - 1))
-#define paddr_to_index(paddr, order) (pnum_to_index(paddr_to_pnum(paddr), (order)))
-#define paddr_to_pnum(paddr) ((paddr) >> PAGE_SHIFT)
+#define pm_to_index(paddr, order) (pnum_to_index(pm_to_pnum(paddr), (order)))
+#define pm_to_pnum(paddr) ((paddr) >> PAGE_SHIFT)
 #define pnum_to_paddr(pnum) ((pnum) << PAGE_SHIFT)
 
 #define move_forward(var, num) (((var) += (num)) - (num))
 
-#define move_paddr(paddr, base, offset) ((((paddr_t)(paddr)) - (base)) + (offset))
+#define move_paddr(paddr, base, offset) ((((pm_t)(paddr)) - (base)) + (offset))
 #define num_elems(num) (((num) + MM_OINFO_WIDTH - 1) / MM_OINFO_WIDTH)
 #define num_indexes(num) ((num) / MM_OINFO_WIDTH)
 #define index_elems(num) ((num) / MM_OINFO_WIDTH)
diff --git a/include/apos/pmem.h b/include/apos/pmem.h
index 884cf5c..38dd670 100644
--- a/include/apos/pmem.h
+++ b/include/apos/pmem.h
@@ -17,17 +17,17 @@ enum mm_order_t {
 	MM_O9,
 };
 
-typedef size_t paddr_t;
+typedef size_t pm_t;
 typedef ssize_t pnum_t;
 
-void update_pmap(paddr_t offset);
-void free_page(enum mm_order_t order, paddr_t paddr);
-void mark_used(enum mm_order_t order, paddr_t paddr);
-paddr_t alloc_page(enum mm_order_t order, paddr_t offset);
+void update_pmap(pm_t offset);
+void free_page(enum mm_order_t order, pm_t paddr);
+void mark_used(enum mm_order_t order, pm_t paddr);
+pm_t alloc_page(enum mm_order_t order, pm_t offset);
 
 #if defined(INIT)
-paddr_t populate_pmap(paddr_t ram_base, size_t ram_size, paddr_t cont);
-paddr_t probe_pmap(paddr_t ram_base, size_t ram_size);
+pm_t populate_pmap(pm_t ram_base, size_t ram_size, pm_t cont);
+pm_t probe_pmap(pm_t ram_base, size_t ram_size);
 #endif
 
 #if defined(KERNEL)