mm: refactor pmm -> page

kernel-src/arch/x86-64/acpi.c

@@ -1,5 +1,5 @@
 #include <limine.h>
-#include <kernel/pmm.h>
+#include <kernel/page.h>
 #include <stdint.h>
 
 #include <uacpi/kernel_api.h>

kernel-src/arch/x86-64/kvmclock.c

@@ -4,7 +4,7 @@
 #include <cpuid.h>
 #include <logging.h>
 #include <arch/cpuid.h>
-#include <kernel/pmm.h>
+#include <kernel/page.h>
 #include <arch/tsc.h>
 #include <kernel/kernel_args.h>
 

kernel-src/arch/x86-64/mmu.c

@@ -1,6 +1,6 @@
 #include <arch/mmu.h>
 #include <limine.h>
-#include <kernel/pmm.h>
+#include <kernel/page.h>
 #include <string.h>
 #include <logging.h>
 #include <kernel/interrupt.h>
@@ -71,7 +71,7 @@ static bool add_page(pagetableptr_t top, void *vaddr, uint64_t entry, int depth)
 
 	uint64_t *pdpt = next(pml4[pml4offset]);
 	if (pdpt == NULL) {
-		pdpt = pmm_allocpage(PMM_SECTION_DEFAULT);
+		pdpt = mm_alloc_page(MEMORY_SECTION_DEFAULT);
 		if (pdpt == NULL)
 			return false;
 		pml4[pml4offset] = (uint64_t)pdpt | INTERMEDIATE_FLAGS;
@@ -86,7 +86,7 @@ static bool add_page(pagetableptr_t top, void *vaddr, uint64_t entry, int depth)
 	
 	uint64_t *pd = next(pdpt[pdptoffset]);
 	if (pd == NULL) {
-		pd = pmm_allocpage(PMM_SECTION_DEFAULT);
+		pd = mm_alloc_page(MEMORY_SECTION_DEFAULT);
 		if (pd == NULL)
 			return false;
 		pdpt[pdptoffset] = (uint64_t)pd | INTERMEDIATE_FLAGS;
@@ -101,7 +101,7 @@ static bool add_page(pagetableptr_t top, void *vaddr, uint64_t entry, int depth)
 	
 	uint64_t *pt = next(pd[pdoffset]);
 	if (pt == NULL) {
-		pt = pmm_allocpage(PMM_SECTION_DEFAULT);
+		pt = mm_alloc_page(MEMORY_SECTION_DEFAULT);
 		if (pt == NULL)
 			return false;
 		pd[pdoffset] = (uint64_t)pt | INTERMEDIATE_FLAGS;
@@ -123,13 +123,13 @@ static void destroy(uint64_t *table, int depth) {
 		if (depth > 0)
 			destroy(MAKE_HHDM(addr), depth - 1);
 
-		pmm_release(addr);
+		mm_release_page(addr);
 	}
 }
 
 void arch_mmu_destroytable(pagetableptr_t table) {
 	destroy(MAKE_HHDM(table), 3);
-	pmm_release(table);
+	mm_release_page(table);
 }
 
 bool arch_mmu_map(pagetableptr_t table, void *paddr, void *vaddr, mmuflags_t flags) {
@@ -212,7 +212,7 @@ void x86_64_mmu_disable_global_pages(void) {
 static pagetableptr_t template;
 
 pagetableptr_t arch_mmu_newtable() {
-	pagetableptr_t table = pmm_allocpage(PMM_SECTION_DEFAULT);
+	pagetableptr_t table = mm_alloc_page(MEMORY_SECTION_DEFAULT);
 	if (table == NULL)
 		return NULL;
 	memcpy(MAKE_HHDM(table), template, PAGE_SIZE);
@@ -312,7 +312,7 @@ static mmuflags_t kernelflags[3] = {
 	ARCH_MMU_FLAGS_READ | ARCH_MMU_FLAGS_NOEXEC | ARCH_MMU_FLAGS_GLOBAL
 };
 
-extern volatile struct limine_memmap_request pmm_liminemap;
+extern volatile struct limine_memmap_request mm_page_limine_map;
 
 static volatile struct limine_executable_address_request kaddrreq = {
 	.id = LIMINE_EXECUTABLE_ADDRESS_REQUEST_ID,
@@ -388,13 +388,13 @@ static void gpfisr(isr_t *self, context_t *ctx) {
 }
 
 void arch_mmu_init() {
-	template = pmm_allocpage(PMM_SECTION_DEFAULT);
+	template = mm_alloc_page(MEMORY_SECTION_DEFAULT);
 	__assert(template);
 	template = MAKE_HHDM(template);
 	memset(template, 0, PAGE_SIZE);
 
 	for (int i = 256; i < 512; ++i) {
-		uint64_t *entry = pmm_allocpage(PMM_SECTION_DEFAULT);
+		uint64_t *entry = mm_alloc_page(MEMORY_SECTION_DEFAULT);
 		__assert(entry);
 		memset(MAKE_HHDM(entry), 0, PAGE_SIZE);
 		template[i] = (uint64_t)entry | INTERMEDIATE_FLAGS;
@@ -403,8 +403,8 @@ void arch_mmu_init() {
 	// TODO use 2mb pages
 	// populate hhdm
 
-	for (size_t i = 0; i < pmm_liminemap.response->entry_count; ++i) {
-		struct limine_memmap_entry *e = pmm_liminemap.response->entries[i];
+	for (size_t i = 0; i < mm_page_limine_map.response->entry_count; ++i) {
+		struct limine_memmap_entry *e = mm_page_limine_map.response->entries[i];
 		if (e->type != LIMINE_MEMMAP_USABLE && e->type != LIMINE_MEMMAP_BOOTLOADER_RECLAIMABLE && e->type != LIMINE_MEMMAP_EXECUTABLE_AND_MODULES && e->type != LIMINE_MEMMAP_FRAMEBUFFER)
 			continue;
 
@@ -434,7 +434,7 @@ void arch_mmu_init() {
 	arch_mmu_apswitch();
 }
 
-INIT_ROUTINE_DEFINE(mmu, INIT_ROUTINE_FLAGS_NONE, arch_mmu_init, pmm);
+INIT_ROUTINE_DEFINE(mmu, INIT_ROUTINE_FLAGS_NONE, arch_mmu_init, mm_page);
 
 void arch_mmu_apswitch() {
 	arch_mmu_switch(FROM_HHDM(template));

kernel-src/arch/x86-64/smp.c

@@ -1,6 +1,6 @@
 #include <limine.h>
 #include <logging.h>
-#include <kernel/pmm.h>
+#include <kernel/page.h>
 #include <arch/cpu.h>
 #include <arch/gdt.h>
 #include <arch/idt.h>
@@ -96,7 +96,7 @@ void arch_smp_wakeup(void) {
 
 	// use physical pages so the other cpus have it on the hhdm
 	size_t cpu_size = ROUND_UP(sizeof(cpu_t) * response->cpu_count, PAGE_SIZE);
-	cpu_t *cpus = pmm_alloc(cpu_size / PAGE_SIZE, PMM_SECTION_DEFAULT);
+	cpu_t *cpus = mm_alloc_pages(cpu_size / PAGE_SIZE, MEMORY_SECTION_DEFAULT);
 	__assert(cpus);
 	cpus = MAKE_HHDM(cpus);
 	memset(cpus, 0, cpu_size);

kernel-src/fs/devfs.c

@@ -6,7 +6,7 @@
 #include <errno.h>
 #include <kernel/alloc.h>
 #include <kernel/timekeeper.h>
-#include <kernel/pmm.h>
+#include <kernel/page.h>
 #include <kernel/vmmcache.h>
 #include <kernel/auth.h>
 #include <kernel/init.h>
@@ -391,7 +391,7 @@ static int devfs_getpage(vnode_t *node, uintmax_t offset, struct page_t *page) {
 	// only block devices will have this called
 	__assert(node->type == V_TYPE_BLKDEV);
 	iovec_t iovec = {
-		.addr = MAKE_HHDM(pmm_getpageaddress(page)),
+		.addr = MAKE_HHDM(mm_get_page_address(page)),
 		.len = PAGE_SIZE
 	};
 
@@ -410,7 +410,7 @@ static int devfs_putpage(vnode_t *node, uintmax_t offset, struct page_t *page) {
 	// only block devices will have this called
 	__assert(node->type == V_TYPE_BLKDEV);
 	iovec_t iovec = {
-		.addr = MAKE_HHDM(pmm_getpageaddress(page)),
+		.addr = MAKE_HHDM(mm_get_page_address(page)),
 		.len = PAGE_SIZE
 	};
 

kernel-src/fs/ext2.c

@@ -4,7 +4,7 @@
 #include <kernel/slab.h>
 #include <kernel/vmm.h>
 #include <arch/cpu.h>
-#include <kernel/pmm.h>
+#include <kernel/page.h>
 #include <hashtable.h>
 #include <mutex.h>
 #include <logging.h>
@@ -1761,7 +1761,7 @@ static int ext2_getpage(vnode_t *node, uintmax_t offset, struct page_t *page) {
 	// only regular files get cached
 	__assert(node->type == V_TYPE_REGULAR);
 	size_t readc = PAGE_SIZE;
-	void *addr = MAKE_HHDM(pmm_getpageaddress(page));
+	void *addr = MAKE_HHDM(mm_get_page_address(page));
 
 	iovec_t iovec = {
 		.addr = addr,
@@ -1784,7 +1784,7 @@ static int ext2_putpage(vnode_t *node, uintmax_t offset, struct page_t *page) {
 	__assert(node->type == V_TYPE_REGULAR);
 	size_t writec;
 	iovec_t iovec = {
-		.addr = MAKE_HHDM(pmm_getpageaddress(page)),
+		.addr = MAKE_HHDM(mm_get_page_address(page)),
 		.len = PAGE_SIZE
 	};
 

kernel-src/fs/fat/fatfs.c

@@ -6,7 +6,7 @@
 #include <kernel/init.h>
 #include <kernel/slab.h>
 #include <kernel/auth.h>
-#include <kernel/pmm.h>
+#include <kernel/page.h>
 #include <kernel/vmmcache.h>
 
 typedef struct {
@@ -383,7 +383,7 @@ static int fatfs_putpage(vnode_t *node, uintmax_t offset, struct page_t *page) {
 	__assert(node->type == V_TYPE_REGULAR);
 	size_t write_count;
 	iovec_t iovec = {
-		.addr = MAKE_HHDM(pmm_getpageaddress(page)),
+		.addr = MAKE_HHDM(mm_get_page_address(page)),
 		.len = PAGE_SIZE
 	};
 
@@ -410,7 +410,7 @@ static int fatfs_getpage(vnode_t *node, uintmax_t offset, struct page_t *page) {
 	// only regular files get cached
 	__assert(node->type == V_TYPE_REGULAR);
 	size_t read_count = PAGE_SIZE;
-	void *addr = MAKE_HHDM(pmm_getpageaddress(page));
+	void *addr = MAKE_HHDM(mm_get_page_address(page));
 
 	iovec_t iovec = {
 		.addr = addr,

kernel-src/fs/initrd.c

@@ -4,7 +4,7 @@
 #include <logging.h>
 #include <util.h>
 #include <kernel/vmm.h>
-#include <kernel/pmm.h>
+#include <kernel/page.h>
 #include <kernel/abi.h>
 #include <time.h>
 #include <kernel/vfs.h>
@@ -128,7 +128,7 @@ void initrd_unpack() {
 	for (;;) {
 		if (cleanupbytespassed >= PAGE_SIZE) {
 			size_t pagec = cleanupbytespassed / PAGE_SIZE;
-			pmm_makefree(FROM_HHDM(cleanupptr), pagec);
+			mm_force_free_page(FROM_HHDM(cleanupptr), pagec);
 			cleanupptr = (void *)((uintptr_t)cleanupptr + ROUND_DOWN(cleanupbytespassed, PAGE_SIZE));
 			cleanupbytespassed %= PAGE_SIZE;
 		}
@@ -181,5 +181,5 @@ void initrd_unpack() {
 	}
 
 	// free remaining pages to be freed
-	pmm_makefree(FROM_HHDM(cleanupptr), ROUND_UP(cleanupbytespassed, PAGE_SIZE) / PAGE_SIZE);
+	mm_force_free_page(FROM_HHDM(cleanupptr), ROUND_UP(cleanupbytespassed, PAGE_SIZE) / PAGE_SIZE);
 }

kernel-src/fs/tmpfs.c

@@ -8,7 +8,7 @@
 #include <util.h>
 #include <kernel/abi.h>
 #include <kernel/devfs.h>
-#include <kernel/pmm.h>
+#include <kernel/page.h>
 #include <kernel/vmm.h>
 #include <arch/cpu.h>
 #include <string.h>
@@ -528,10 +528,10 @@ static int tmpfs_getpage(vnode_t *node, uintmax_t offset, struct page_t *page) {
 
 	// since tmpfs files now store their data on the vmmcache,
 	// all getpage will do will be set the page to 0 and pin it in memory
-	void *phy = pmm_getpageaddress(page);
+	void *phy = mm_get_page_address(page);
 	void *phyhhdm = MAKE_HHDM(phy);
 
-	pmm_hold(phy);
+	mm_hold_page(phy);
 	page->flags |= PAGE_FLAGS_PINNED;
 	memset(phyhhdm, 0, PAGE_SIZE);
 	return 0;
@@ -565,7 +565,7 @@ static int tmpfs_statfs(vfs_t *vfs, fsattr_t *fsattr) {
 	tmpfs_t *tmpfs = (tmpfs_t *)vfs;
 
 	size_t total_pages, free_pages;
-	pmm_getinfo(&total_pages, &free_pages);
+	mm_get_page_statistics(&total_pages, &free_pages);
 
 	fsattr->io_size = PAGE_SIZE;
 	fsattr->block_size = PAGE_SIZE;

kernel-src/fs/vfs.c

@@ -454,11 +454,11 @@ int vfs_write_iovec(vnode_t *node, iovec_iterator_t *iovec_iterator, size_t size
 				goto leave;
 
 			size_t writesize = min(PAGE_SIZE - startoffset, size);
-			void *address = MAKE_HHDM(pmm_getpageaddress(page));
+			void *address = MAKE_HHDM(mm_get_page_address(page));
 
 			err = iovec_iterator_copy_to_buffer(iovec_iterator, (void *)((uintptr_t)address + startoffset), writesize);
 			if (err) {
-				pmm_release(FROM_HHDM(address));
+				mm_release_page(FROM_HHDM(address));
 				goto leave;
 			}
 
@@ -471,7 +471,7 @@ int vfs_write_iovec(vnode_t *node, iovec_iterator_t *iovec_iterator, size_t size
 			pageoffset += 1;
 			pagecount -= 1;
 
-			pmm_release(FROM_HHDM(address));
+			mm_release_page(FROM_HHDM(address));
 			if (err)
 				goto leave;
 		}
@@ -483,11 +483,11 @@ int vfs_write_iovec(vnode_t *node, iovec_iterator_t *iovec_iterator, size_t size
 				goto leave;
 
 			size_t writesize = min(PAGE_SIZE, size - *written);
-			void *address = MAKE_HHDM(pmm_getpageaddress(page));
+			void *address = MAKE_HHDM(mm_get_page_address(page));
 
 			err = iovec_iterator_copy_to_buffer(iovec_iterator, address, writesize);
 			if (err) {
-				pmm_release(FROM_HHDM(address));
+				mm_release_page(FROM_HHDM(address));
 				goto leave;
 			}
 
@@ -497,7 +497,7 @@ int vfs_write_iovec(vnode_t *node, iovec_iterator_t *iovec_iterator, size_t size
 			if (flags & V_FFLAGS_NOCACHE)
 				err = writenocache(node, page, pageoffset * PAGE_SIZE + offset);
 
-			pmm_release(FROM_HHDM(address));
+			mm_release_page(FROM_HHDM(address));
 
 			if (err)
 				goto leave;
@@ -567,11 +567,11 @@ int vfs_read_iovec(vnode_t *node, iovec_iterator_t *iovec_iterator, size_t size,
 				goto leave;
 
 			size_t readsize = min(PAGE_SIZE - startoffset, size);
-			void *address = MAKE_HHDM(pmm_getpageaddress(page));
+			void *address = MAKE_HHDM(mm_get_page_address(page));
 
 			err = iovec_iterator_copy_from_buffer(iovec_iterator, (void *)((uintptr_t)address + startoffset), readsize);
 			if (err) {
-				pmm_release(FROM_HHDM(address));
+				mm_release_page(FROM_HHDM(address));
 				goto leave;
 			}
 
@@ -585,7 +585,7 @@ int vfs_read_iovec(vnode_t *node, iovec_iterator_t *iovec_iterator, size_t size,
 			pageoffset += 1;
 			pagecount -= 1;
 
-			pmm_release(FROM_HHDM(address));
+			mm_release_page(FROM_HHDM(address));
 		}
 
 		for (uintmax_t offset = 0; offset < pagecount * PAGE_SIZE; offset += PAGE_SIZE) {
@@ -595,11 +595,11 @@ int vfs_read_iovec(vnode_t *node, iovec_iterator_t *iovec_iterator, size_t size,
 				goto leave;
 
 			size_t readsize = min(PAGE_SIZE, size - *bytesread);
-			void *address = MAKE_HHDM(pmm_getpageaddress(page));
+			void *address = MAKE_HHDM(mm_get_page_address(page));
 
 			err = iovec_iterator_copy_from_buffer(iovec_iterator, address, readsize);
 			if (err) {
-				pmm_release(FROM_HHDM(address));
+				mm_release_page(FROM_HHDM(address));
 				goto leave;
 			}
 
@@ -608,7 +608,7 @@ int vfs_read_iovec(vnode_t *node, iovec_iterator_t *iovec_iterator, size_t size,
 				// try to turn it into anonymous memory
 				vmmcache_evict(page);
 			}
-			pmm_release(FROM_HHDM(address));
+			mm_release_page(FROM_HHDM(address));
 		}
 		leave:
 		MUTEX_RELEASE(&node->size_lock);

kernel-src/include/kernel/page.h

@@ -1,13 +1,13 @@
-#ifndef _PMM_H
-#define _PMM_H
+#ifndef _PAGE_H
+#define _PAGE_H
 
 #include <stddef.h>
 #include <stdint.h>
 
-#define PMM_SECTION_COUNT 3
-#define PMM_SECTION_1MB 0
-#define PMM_SECTION_4GB 1
-#define PMM_SECTION_DEFAULT 2
+#define MEMORY_SECTION_COUNT 3
+#define MEMORY_SECTION_1MB 0
+#define MEMORY_SECTION_4GB 1
+#define MEMORY_SECTION_DEFAULT 2
 
 #define PAGE_FLAGS_FREE 1
 #define PAGE_FLAGS_TRUNCATED 2
@@ -38,16 +38,16 @@ typedef struct page_t {
 	int flags;
 } page_t;
 
-void *pmm_allocpage(int section);
-page_t *pmm_getpage(void *addr);
-void *pmm_getpageaddress(page_t *);
-void pmm_hold(void *addr);
-void pmm_release(void *addr);
-void pmm_makefree(void *address, size_t count);
-void *pmm_alloc(size_t size, int section);
-void pmm_free(void *addr, size_t size);
-void pmm_init();
-void pmm_getinfo(size_t *total_pages, size_t *free_pages);
+void *mm_alloc_page(int section);
+page_t *mm_get_page(void *addr);
+void *mm_get_page_address(page_t *);
+void mm_hold_page(void *addr);
+void mm_release_page(void *addr);
+void mm_force_free_page(void *address, size_t count);
+void *mm_alloc_pages(size_t size, int section);
+void mm_release_range(void *addr, size_t size);
+void mm_page_init();
+void mm_get_page_statistics(size_t *total_pages, size_t *free_pages);
 
 extern uintptr_t hhdmbase;
 

kernel-src/include/kernel/vmmcache.h

@@ -1,7 +1,7 @@
 #ifndef _VMMCACHE_H
 #define _VMMCACHE_H
 
-#include <kernel/pmm.h>
+#include <kernel/page.h>
 #include <kernel/vfs.h>
 
 extern size_t vmmcache_cachedpages;

kernel-src/include/x86-64/arch/pci.h

@@ -6,7 +6,7 @@
 #include <stdint.h>
 #include <stddef.h>
 #include <arch/io.h>
-#include <kernel/pmm.h>
+#include <kernel/page.h>
 #include <kernel/alloc.h>
 #include <arch/cpu.h>
 

kernel-src/io/acpi/glue.c

@@ -4,7 +4,7 @@
 #include <kernel/interrupt.h>
 #include <kernel/scheduler.h>
 #include <kernel/alloc.h>
-#include <kernel/pmm.h>
+#include <kernel/page.h>
 #include <kernel/pci.h>
 #include <kernel/timekeeper.h>
 #include <arch/cpu.h>

kernel-src/io/audio/hda.c

@@ -2,7 +2,7 @@
 #include <logging.h>
 #include <kernel/hda.h>
 #include <kernel/init.h>
-#include <kernel/pmm.h>
+#include <kernel/page.h>
 #include <list.h>
 #include <semaphore.h>
 #include <kernel/alloc.h>
@@ -376,12 +376,12 @@ static hda_stream_t *hda_allocate_output_stream(hda_t *hda) {
 	hda->streams[stream_n] = stream;
 	hda->regs->intctl |= (1 << stream_n);
 
-	stream->bdl_phys = pmm_allocpage(PMM_SECTION_DEFAULT);
+	stream->bdl_phys = mm_alloc_page(MEMORY_SECTION_DEFAULT);
 	__assert(stream->bdl_phys);
 	hda_bdl_entry_t *bdl = MAKE_HHDM(stream->bdl_phys);
 
 	for (int i = 0; i < HDA_BUFFER_PAGE_COUNT; ++i) {
-		void *phys_page = pmm_allocpage(PMM_SECTION_DEFAULT);
+		void *phys_page = mm_alloc_page(MEMORY_SECTION_DEFAULT);
 		__assert(phys_page);
 		memset(MAKE_HHDM(phys_page), 0, PAGE_SIZE);
 
@@ -907,7 +907,7 @@ static void initcontroller(pcienum_t *e) {
 	sched_sleep_us(1000);
 
 	// we can fit all of corb/rirb in a single page
-	void *corb_phys = pmm_allocpage(PMM_SECTION_DEFAULT);
+	void *corb_phys = mm_alloc_page(MEMORY_SECTION_DEFAULT);
 	__assert(corb_phys);
 	void *corb = MAKE_HHDM(corb_phys);
 	memset(corb, 0, PAGE_SIZE);

kernel-src/io/block/ahci.c

@@ -1,7 +1,7 @@
 #include <kernel/init.h>
 #include <kernel/pci.h>
 #include <kernel/alloc.h>
-#include <kernel/pmm.h>
+#include <kernel/page.h>
 #include <kernel/block.h>
 #include <logging.h>
 
@@ -282,7 +282,7 @@ static int cmd_identify(ahci_t *ahci, int port, identify_t *results_phys) {
 		.prdtl = 1,
 	};
 
-	command_table_t *command_table_phys = pmm_allocpage(PMM_SECTION_DEFAULT);
+	command_table_t *command_table_phys = mm_alloc_page(MEMORY_SECTION_DEFAULT);
 	if (command_table_phys == NULL)
 		return ENOMEM;
 
@@ -300,7 +300,7 @@ static int cmd_identify(ahci_t *ahci, int port, identify_t *results_phys) {
 
 	int error = dispatch_command_and_wait(ahci, port, &command_header);
 
-	pmm_release(command_table_phys);
+	mm_release_page(command_table_phys);
 
 	return error;
 }
@@ -308,7 +308,7 @@ static int cmd_identify(ahci_t *ahci, int port, identify_t *results_phys) {
 static void release_prdt(command_table_t *command_table, uint16_t prdtl) {
 	for (int i = 0; i < prdtl; ++i) {
 		void *address = (void *)((uint64_t)command_table->prdt[i].base_low | ((uint64_t)command_table->prdt[i].base_high << 32));
-		pmm_release(address);
+		mm_release_page(address);
 	}
 }
 
@@ -328,7 +328,7 @@ static int setup_prdt(iovec_iterator_t *iterator, command_table_t *command_table
 		__assert(page);
 		// not block aligned
 		if (page_remaining % 512) {
-			pmm_release(page);
+			mm_release_page(page);
 			err = EINVAL;
 			goto cleanup;
 		}
@@ -367,7 +367,7 @@ static int rw(port_data_t *port_data, iovec_iterator_t *iterator, uintmax_t lba,
 		.flags = (sizeof(fis_h2d_t) / 4) | (write ? CMDHDR_WRITE : 0),
 	};
 
-	command_table_t *command_table_phys = pmm_allocpage(PMM_SECTION_DEFAULT);
+	command_table_t *command_table_phys = mm_alloc_page(MEMORY_SECTION_DEFAULT);
 	if (command_table_phys == NULL)
 		return ENOMEM;
 
@@ -412,7 +412,7 @@ static int rw(port_data_t *port_data, iovec_iterator_t *iterator, uintmax_t lba,
 		done += do_count;
 	}
 
-	pmm_release(command_table_phys);
+	mm_release_page(command_table_phys);
 
 	return error;
 }
@@ -427,13 +427,13 @@ static int read(void *private, iovec_iterator_t *buffer, uintmax_t lba, size_t c
 
 static void init_port(ahci_t *ahci, int port) {
 	// send identify command
-	identify_t *identify_phys = pmm_allocpage(PMM_SECTION_DEFAULT);
+	identify_t *identify_phys = mm_alloc_page(MEMORY_SECTION_DEFAULT);
 	__assert(identify_phys);
 	identify_t *identify = MAKE_HHDM(identify_phys);
 	memset(identify, 0, 512);
 
 	if (cmd_identify(ahci, port, identify_phys)) {
-		pmm_release(identify_phys);
+		mm_release_page(identify_phys);
 		return;
 	}
 
@@ -446,13 +446,13 @@ static void init_port(ahci_t *ahci, int port) {
 
 	if (logical_sector_size != 512) {
 		printf("ahci%dp%d: unsupported logical sector size %lu\n", ahci->id, port, logical_sector_size);
-		pmm_release(identify_phys);
+		mm_release_page(identify_phys);
 		return;
 	}
 
 	ahci->port_data[port]->sector_count = (uint64_t)identify->lba48_size[0] | ((uint64_t)identify->lba48_size[1] << 16) |
 				((uint64_t)identify->lba48_size[2] << 32) | ((uint64_t)identify->lba48_size[3] << 48);
-	pmm_release(identify_phys);
+	mm_release_page(identify_phys);
 
 	printf("ahci%dp%d: ATA drive with %lu sectors\n", ahci->id, port, ahci->port_data[port]->sector_count);
 
@@ -553,11 +553,11 @@ static void init_controller(pcienum_t *pci_enum) {
 	ahci->ghc->ghc &= ~GHC_IE;
 
 	// initialize ports
-	void *command_slot_mem = pmm_allocpage(PMM_SECTION_DEFAULT);
+	void *command_slot_mem = mm_alloc_page(MEMORY_SECTION_DEFAULT);
 	__assert(command_slot_mem);
 	size_t command_slot_offset = 0;
 
-	void *fis_base_mem = pmm_allocpage(PMM_SECTION_DEFAULT);
+	void *fis_base_mem = mm_alloc_page(MEMORY_SECTION_DEFAULT);
 	__assert(fis_base_mem);
 	size_t fis_base_offset = 0;
 	FOR_EACH_PORT(ahci) {
@@ -597,7 +597,7 @@ static void init_controller(pcienum_t *pci_enum) {
 		command_slot_offset += 1024;
 		if (command_slot_offset >= PAGE_SIZE) {
 			// used up the page, allocate another
-			command_slot_mem = pmm_allocpage(PMM_SECTION_DEFAULT);
+			command_slot_mem = mm_alloc_page(MEMORY_SECTION_DEFAULT);
 			__assert(command_slot_mem);
 			command_slot_offset = 0;
 		}
@@ -612,7 +612,7 @@ static void init_controller(pcienum_t *pci_enum) {
 		fis_base_offset += 256;
 		if (fis_base_offset >= PAGE_SIZE) {
 			// used up the page, allocate another
-			fis_base_mem = pmm_allocpage(PMM_SECTION_DEFAULT);
+			fis_base_mem = mm_alloc_page(MEMORY_SECTION_DEFAULT);
 			__assert(fis_base_mem);
 			fis_base_offset = 0;
 		}
@@ -653,9 +653,9 @@ static void init_controller(pcienum_t *pci_enum) {
 	}
 
 	if (command_slot_offset == 0)
-		pmm_release(command_slot_mem);
+		mm_release_page(command_slot_mem);
 	if (fis_base_offset == 0)
-		pmm_release(fis_base_mem);
+		mm_release_page(fis_base_mem);
 
 	// clear global interrupt status
 	ahci->ghc->is = 0xffffffff;

kernel-src/io/block/nvme.c

@@ -2,7 +2,7 @@
 #include <logging.h>
 #include <kernel/vmm.h>
 #include <util.h>
-#include <kernel/pmm.h>
+#include <kernel/page.h>
 #include <kernel/alloc.h>
 #include <kernel/interrupt.h>
 #include <kernel/dpc.h>
@@ -342,7 +342,7 @@ static int identify(nvmecontroller_t *controller, void *buffer, int what, int na
 	entrypair_t pair = {0};
 	PAIR_INIT(&pair, SUB_DW0_OPCODE_IDENTIFY, SUB_DW0_UNFUSED, SUB_DW0_PRP, namespace);
 
-	pair.sub.datapointer[0] = (uint64_t)pmm_allocpage(PMM_SECTION_DEFAULT);
+	pair.sub.datapointer[0] = (uint64_t)mm_alloc_page(MEMORY_SECTION_DEFAULT);
 	if (pair.sub.datapointer[0] == 0)
 		return ENOMEM;
 
@@ -351,7 +351,7 @@ static int identify(nvmecontroller_t *controller, void *buffer, int what, int na
 	enqueueandwait(&controller->adminqueue, &pair);
 
 	memcpy(buffer, MAKE_HHDM(pair.sub.datapointer[0]), IDENTIFY_SIZE);
-	pmm_release((void *)pair.sub.datapointer[0]);
+	mm_release_page((void *)pair.sub.datapointer[0]);
 	return COMP_CMDINFO_STATUS(pair.comp.cmdinfo) ? EIO : 0;
 }
 
@@ -401,7 +401,7 @@ static int createiocompqueue(nvmecontroller_t *controller, queuedesc_t *desc, si
 	size_t size = entrycount * sizeof(compentry_t);
 	size_t pagesize = ROUND_UP(size, PAGE_SIZE) / PAGE_SIZE;
 
-	void *queuepages = pmm_alloc(pagesize, PMM_SECTION_DEFAULT);
+	void *queuepages = mm_alloc_pages(pagesize, MEMORY_SECTION_DEFAULT);
 	if (queuepages == NULL)
 		return ENOMEM;
 
@@ -415,7 +415,7 @@ static int createiocompqueue(nvmecontroller_t *controller, queuedesc_t *desc, si
 	enqueueandwait(&controller->adminqueue, &pair);
 
 	if (COMP_CMDINFO_STATUS(pair.comp.cmdinfo)) {
-		pmm_free(queuepages, pagesize);
+		mm_release_range(queuepages, pagesize);
 		return EIO;
 	}
 
@@ -433,7 +433,7 @@ static int createiosubqueue(nvmecontroller_t *controller, queuedesc_t *desc, siz
 	size_t size = entrycount * sizeof(subentry_t);
 	size_t pagesize = ROUND_UP(size, PAGE_SIZE) / PAGE_SIZE;
 
-	void *queuepages = pmm_alloc(pagesize, PMM_SECTION_DEFAULT);
+	void *queuepages = mm_alloc_pages(pagesize, MEMORY_SECTION_DEFAULT);
 	if (queuepages == NULL)
 		return ENOMEM;
 
@@ -447,7 +447,7 @@ static int createiosubqueue(nvmecontroller_t *controller, queuedesc_t *desc, siz
 	enqueueandwait(&controller->adminqueue, &pair);
 
 	if (COMP_CMDINFO_STATUS(pair.comp.cmdinfo)) {
-		pmm_free(queuepages, pagesize);
+		mm_release_range(queuepages, pagesize);
 		return EIO;
 	}
 
@@ -510,15 +510,15 @@ static int iowrite(nvmenamespace_t *namespace, uint64_t prp[2], uint64_t lba, ui
 #define PAGES_IN_PRP_PAGE (PAGE_SIZE / sizeof(uint64_t))
 
 static void free_prps(uint64_t prp[2], bool has_list) {
-	pmm_release((void *)ROUND_DOWN(prp[0], PAGE_SIZE));
+	mm_release_page((void *)ROUND_DOWN(prp[0], PAGE_SIZE));
 	if (has_list) {
 		uint64_t *prp_list = MAKE_HHDM((uint64_t *)prp[1]);
 		for (int i = 0; prp_list[i] && i < PAGES_IN_PRP_PAGE; ++i)
-			pmm_release((void *)prp_list[i]);
+			mm_release_page((void *)prp_list[i]);
 	}
 
 	if (prp[1])
-		pmm_release((void *)prp[1]);
+		mm_release_page((void *)prp[1]);
 }
 
 // sets up prps based on an iovec iterator.
@@ -576,7 +576,7 @@ static int setup_prps(nvmenamespace_t *namespace, iovec_iterator_t *iovec_iterat
 	}
 
 	// we have to allocate a proper prp list now
-	uint64_t *prp_list_phys = pmm_allocpage(PMM_SECTION_DEFAULT);
+	uint64_t *prp_list_phys = mm_alloc_page(MEMORY_SECTION_DEFAULT);
 	if (prp_list_phys == NULL) {
 		// out of memory, we'll have to make do with 2 pages
 		*has_list = false;
@@ -603,7 +603,7 @@ static int setup_prps(nvmenamespace_t *namespace, iovec_iterator_t *iovec_iterat
 		if (page_offset || page_remaining % namespace->blocksize) {
 			prp_list[i] = 0;
 			free_prps(prp, true);
-			pmm_release(page);
+			mm_release_page(page);
 			return EINVAL;
 		}
 
@@ -777,7 +777,7 @@ static void initcontroller(pcienum_t *e) {
 
 	bar0->aqattr = aqattr;
 
-	void *acq = pmm_alloc(2, PMM_SECTION_DEFAULT);
+	void *acq = mm_alloc_pages(2, MEMORY_SECTION_DEFAULT);
 	__assert(acq);
 	memset(MAKE_HHDM(acq), 0, PAGE_SIZE * 2);
 	void *asq = (void *)((uintptr_t)acq + PAGE_SIZE);
@@ -793,7 +793,7 @@ static void initcontroller(pcienum_t *e) {
 
 	if (STATUS_FATAL(bar0->status)) {
 		printf("nvme: controller returned fatal while initializing\n");
-		pmm_free(acq, 2);
+		mm_release_range(acq, 2);
 		return;
 	}
 
@@ -835,7 +835,7 @@ static void initcontroller(pcienum_t *e) {
 	if (controllerid->type != 0 && controllerid->type != CONTROLLER_TYPE_IO) {
 		printf("nvme: controller type not supported\n");
 		// FIXME free ISRs
-		pmm_free(acq, 2);
+		mm_release_range(acq, 2);
 		free(controllerid);
 		free(controller);
 		return;

kernel-src/io/block/vioblk.c

@@ -5,7 +5,7 @@
 #include <kernel/slab.h>
 #include <semaphore.h>
 #include <kernel/block.h>
-#include <kernel/pmm.h>
+#include <kernel/page.h>
 #include <string.h>
 
 #define QUEUE_MAX_SIZE 144
@@ -100,7 +100,7 @@ static void vioblk_enqueue(vioblkdev_t *blkdev, requestheader_t *headerphys, voi
 }
 
 static int vioblk_rw(vioblkdev_t *blkdev, iovec_iterator_t *iovec_iterator, uintmax_t lba, size_t count, bool write) {
-	void *physpage = pmm_allocpage(PMM_SECTION_DEFAULT);
+	void *physpage = mm_alloc_page(MEMORY_SECTION_DEFAULT);
 	if (physpage == NULL)
 		return ENOMEM;
 
@@ -133,7 +133,7 @@ static int vioblk_rw(vioblkdev_t *blkdev, iovec_iterator_t *iovec_iterator, uint
 
 		vioblk_enqueue(blkdev, header, (void *)((uintptr_t)page + page_offset), PAGE_SIZE, status, write);
 
-		pmm_release(page);
+		mm_release_page(page);
 
 		// if we didnt use the whole space in the page, set the iterator back a bit
 		size_t diff_between_available_and_used = page_remaining - docount * 512;
@@ -150,7 +150,7 @@ static int vioblk_rw(vioblkdev_t *blkdev, iovec_iterator_t *iovec_iterator, uint
 		done += docount;
 	}
 
-	pmm_release(physpage);
+	mm_release_page(physpage);
 	return err;
 }
 

kernel-src/io/fb.c

@@ -5,7 +5,7 @@
 #include <kernel/alloc.h>
 #include <kernel/devfs.h>
 #include <arch/cpu.h>
-#include <kernel/pmm.h>
+#include <kernel/page.h>
 #include <kernel/usercopy.h>
 #include <kernel/term.h>
 #include <kernel/init.h>
@@ -147,14 +147,14 @@ static int mmap(int minor, void *addr, uintmax_t offset, int flags) {
 		return arch_mmu_map(current_vmm_context()->pagetable, FROM_HHDM((void *)((uintptr_t)fbs[minor]->address + offset)), addr, vnodeflagstommuflags(flags)) ? 0 : ENOMEM;
 	} else {
 		size_t size = offset + PAGE_SIZE < end ? PAGE_SIZE : end - offset;
-		paddr = pmm_allocpage(PMM_SECTION_DEFAULT);
+		paddr = mm_alloc_page(MEMORY_SECTION_DEFAULT);
 		if (paddr == NULL)
 			return ENOMEM;
 
 		memcpy(MAKE_HHDM(paddr), (void *)((uintptr_t)fbs[minor]->address + offset), size);
 
 		if (arch_mmu_map(current_vmm_context()->pagetable, paddr, addr, vnodeflagstommuflags(flags) | ARCH_MMU_FLAGS_WC) == false) {
-			pmm_release(paddr);
+			mm_release_page(paddr);
 			return ENOMEM;
 		}
 
@@ -168,7 +168,7 @@ static int munmap(int minor, void *addr, uintmax_t offset, int flags) {
 	arch_mmu_unmap(current_vmm_context()->pagetable, addr);
 	arch_mmu_invalidate_range(addr, PAGE_SIZE);
 	if (release)
-		pmm_release(phys);
+		mm_release_page(phys);
 
 	return 0;
 }

kernel-src/io/net/loopback.c

@@ -1,6 +1,6 @@
 #include <kernel/virtio.h>
 #include <logging.h>
-#include <kernel/pmm.h>
+#include <kernel/page.h>
 #include <kernel/eth.h>
 #include <kernel/net.h>
 #include <hashtable.h>

kernel-src/io/net/rtl8169.c

@@ -4,7 +4,7 @@
 #include <arch/io.h>
 #include <kernel/net.h>
 #include <kernel/scheduler.h>
-#include <kernel/pmm.h>
+#include <kernel/page.h>
 #include <kernel/eth.h>
 #include <kernel/interrupt.h>
 
@@ -198,7 +198,7 @@ static int rtl8169_sendpacket(netdev_t *internal, netdesc_t desc, mac_t target,
 static int rtl8169_allocdesc(netdev_t *netdev, size_t requested_size, netdesc_t *desc) {
 	__assert(requested_size <= netdev->mtu);
 	size_t true_size = sizeof(ethframe_t) + requested_size;
-	void *physical = pmm_allocpage(PMM_SECTION_DEFAULT);
+	void *physical = mm_alloc_page(MEMORY_SECTION_DEFAULT);
 	if (physical == NULL)
 		return ENOMEM;
 
@@ -209,7 +209,7 @@ static int rtl8169_allocdesc(netdev_t *netdev, size_t requested_size, netdesc_t
 }
 
 static int rtl8169_freedesc(netdev_t *netdev, netdesc_t *desc) {
-	pmm_release(FROM_HHDM(desc->address));
+	mm_release_page(FROM_HHDM(desc->address));
 	return 0;
 }
 
@@ -275,9 +275,9 @@ static void init_controller(pcienum_t *pci_enum) {
 	printf("rtl8169.%d: %x:%x:%x:%x:%x:%x\n", id, mac.address[0], mac.address[1], mac.address[2], mac.address[3], mac.address[4], mac.address[5]);
 
 	// set up descriptor rings
-	descriptor_t *tx_ring_phys = pmm_alloc(ROUND_UP(sizeof(descriptor_t) * TX_DESCRIPTOR_COUNT, PAGE_SIZE) / PAGE_SIZE, PMM_SECTION_DEFAULT);
+	descriptor_t *tx_ring_phys = mm_alloc_pages(ROUND_UP(sizeof(descriptor_t) * TX_DESCRIPTOR_COUNT, PAGE_SIZE) / PAGE_SIZE, MEMORY_SECTION_DEFAULT);
 	__assert(tx_ring_phys);
-	descriptor_t *rx_ring_phys = pmm_alloc(ROUND_UP(sizeof(descriptor_t) * RX_DESCRIPTOR_COUNT, PAGE_SIZE) / PAGE_SIZE, PMM_SECTION_DEFAULT);
+	descriptor_t *rx_ring_phys = mm_alloc_pages(ROUND_UP(sizeof(descriptor_t) * RX_DESCRIPTOR_COUNT, PAGE_SIZE) / PAGE_SIZE, MEMORY_SECTION_DEFAULT);
 	__assert(rx_ring_phys);
 
 	descriptor_t *tx_ring = MAKE_HHDM(tx_ring_phys);
@@ -288,7 +288,7 @@ static void init_controller(pcienum_t *pci_enum) {
 
 	// fill rx descriptors
 	// XXX figure out a better way of doing this
-	void *rx_buffer = pmm_alloc(ROUND_UP((RX_DESCRIPTOR_COUNT * RX_BUFFER_SIZE), PAGE_SIZE) / PAGE_SIZE, PMM_SECTION_DEFAULT);
+	void *rx_buffer = mm_alloc_pages(ROUND_UP((RX_DESCRIPTOR_COUNT * RX_BUFFER_SIZE), PAGE_SIZE) / PAGE_SIZE, MEMORY_SECTION_DEFAULT);
 	__assert(rx_buffer);
 
 	for (int i = 0; i < RX_DESCRIPTOR_COUNT; ++i) {

kernel-src/io/net/udp.c

@@ -285,7 +285,7 @@ static int udp_recv(socket_t *socket, sockdesc_t *sockdesc) {
 
 	__assert(sockdesc->donecount == copycount);
 
-	// remove the message if not asked to peek
+	// remove the message if not asked to peek TODO: if sonecount != header.length, add truncate flag. also do the same to localsocket
 	if ((flags & SOCKET_RECV_FLAGS_PEEK) == 0)
 		ringbuffer_truncate(&udpsocket->ringbuffer, sizeof(header) + header.length);
 

kernel-src/io/net/vionet.c

@@ -1,6 +1,6 @@
 #include <kernel/virtio.h>
 #include <logging.h>
-#include <kernel/pmm.h>
+#include <kernel/page.h>
 #include <kernel/eth.h>
 #include <kernel/net.h>
 #include <hashtable.h>
@@ -84,7 +84,7 @@ static void tx_irq(isr_t *isr, context_t *context) {
 static int vionet_allocdesc(netdev_t *netdev, size_t requestedsize, netdesc_t *desc) {
 	__assert(requestedsize <= netdev->mtu);
 	size_t truesize = PREFIX_SIZE + requestedsize;
-	void *phys = pmm_allocpage(PMM_SECTION_DEFAULT);
+	void *phys = mm_alloc_page(MEMORY_SECTION_DEFAULT);
 	if (phys == NULL)
 		return ENOMEM;
 
@@ -95,7 +95,7 @@ static int vionet_allocdesc(netdev_t *netdev, size_t requestedsize, netdesc_t *d
 }
 
 static int vionet_freedesc(netdev_t *netdev, netdesc_t *desc) {
-	pmm_release(FROM_HHDM(desc->address));
+	mm_release_page(FROM_HHDM(desc->address));
 	return 0;
 }
 
@@ -210,7 +210,7 @@ int vionet_newdevice(viodevice_t *viodevice) {
 	// XXX is the memory saving of allocating hundreds of KiBs of contiguous physical memory really worth it?
 	// the system literally might not have enough (contiguous) physical memory for this, especially considering
 	// this device is initialised deeper into the boot process.
-	void *receivebuffer = pmm_alloc(ROUND_UP((rxsize * BUFFER_SIZE), PAGE_SIZE) / PAGE_SIZE, PMM_SECTION_DEFAULT);
+	void *receivebuffer = mm_alloc_pages(ROUND_UP((rxsize * BUFFER_SIZE), PAGE_SIZE) / PAGE_SIZE, MEMORY_SECTION_DEFAULT);
 	__assert(receivebuffer);
 
 	for (int i = 0; i < rxsize; ++i) {

kernel-src/io/term.c

@@ -6,7 +6,7 @@
 #include <printf.h>
 #include <logging.h>
 #include <string.h>
-#include <kernel/pmm.h>
+#include <kernel/page.h>
 #include <arch/mmu.h>
 #include <kernel/init.h>
 #include <logging.h>
@@ -31,7 +31,7 @@ static void *internalalloc(size_t n) {
 #else
 // TODO make more efficient. works for now
 static void *internalalloc(size_t n) {
-	void *addr = pmm_alloc(n / PAGE_SIZE + 1, PMM_SECTION_DEFAULT);
+	void *addr = mm_alloc_pages(n / PAGE_SIZE + 1, MEMORY_SECTION_DEFAULT);
 	__assert(addr);
 	return MAKE_HHDM(addr);
 }

kernel-src/io/usb/core/usb.c

@@ -1,5 +1,5 @@
 #include <kernel/alloc.h>
-#include <kernel/pmm.h>
+#include <kernel/page.h>
 #include <kernel/usb.h>
 #include <logging.h>
 

kernel-src/io/usb/ctrl/xhci.c

@@ -4,7 +4,7 @@
 #include <kernel/init.h>
 #include <kernel/interrupt.h>
 #include <kernel/pci.h>
-#include <kernel/pmm.h>
+#include <kernel/page.h>
 #include <kernel/usb.h>
 #include <kernel/vmm.h>
 #include <list.h>
@@ -28,7 +28,7 @@ static void xhci_release_submission_page(xhci_submission_t *submission) {
 	uint32_t cmd_type = xhci_trb_type(&submission->cmd_trb);
 
 	if ((cmd_type == TRB_NORMAL || cmd_type == TRB_DATA_STAGE) && submission->cmd_trb.parameters != 0)
-		pmm_release((void *)(submission->cmd_trb.parameters & ~(PAGE_SIZE - 1)));
+		mm_release_page((void *)(submission->cmd_trb.parameters & ~(PAGE_SIZE - 1)));
 }
 
 static bool xhci_reclaim_submission_slot(xhci_submission_t *slot, xhci_submission_t *submission) {
@@ -614,7 +614,7 @@ static int xhci_ctrl_start(usb_ctrl_t *ctrl) {
 	xhci->opregs->config = max_slots;
 
 	// Set up the Device Context Base Address Array.
-	void *dcbaa_phys = pmm_allocpage(PMM_SECTION_DEFAULT);
+	void *dcbaa_phys = mm_alloc_page(MEMORY_SECTION_DEFAULT);
 	__assert(dcbaa_phys);
 
 	uint64_t *dcbaa_virt = MAKE_HHDM(dcbaa_phys);
@@ -629,12 +629,12 @@ static int xhci_ctrl_start(usb_ctrl_t *ctrl) {
 		printf("xhci: setting up %u scratchpad buffers\n", max_scratchpads);
 		__assert(max_scratchpads < PAGE_SIZE / sizeof(uint64_t));
 
-		void *scratchpad_array_phys = pmm_allocpage(PMM_SECTION_DEFAULT);
+		void *scratchpad_array_phys = mm_alloc_page(MEMORY_SECTION_DEFAULT);
 		__assert(scratchpad_array_phys);
 		uint64_t *scratchpad_array_virt = MAKE_HHDM(scratchpad_array_phys);
 
 		for (uint32_t i = 0; i < max_scratchpads; i++) {
-			void *scratchpad_phys = pmm_allocpage(PMM_SECTION_DEFAULT);
+			void *scratchpad_phys = mm_alloc_page(MEMORY_SECTION_DEFAULT);
 			__assert(scratchpad_phys);
 			memset(MAKE_HHDM(scratchpad_phys), 0, PAGE_SIZE);
 			scratchpad_array_virt[i] = (uint64_t)scratchpad_phys;
@@ -650,7 +650,7 @@ static int xhci_ctrl_start(usb_ctrl_t *ctrl) {
 	xhci->opregs->crcr = (uint64_t)xhci->command_ring.ring_phys | XHCI_CRCR_RCS;
 
 	// Set up Event Ring Segment Table.
-	void *erst_phys = pmm_allocpage(PMM_SECTION_DEFAULT);
+	void *erst_phys = mm_alloc_page(MEMORY_SECTION_DEFAULT);
 	__assert(erst_phys);
 
 	xhci_erst_entry_t *erst_virt = MAKE_HHDM(erst_phys);

kernel-src/io/usb/ctrl/xhci_ctrl.c

@@ -1,7 +1,7 @@
 #include <kernel/xhci.h>
 #include <kernel/alloc.h>
 #include <errno.h>
-#include <kernel/pmm.h>
+#include <kernel/page.h>
 #include <logging.h>
 #include <util.h>
 
@@ -132,9 +132,9 @@ static void xhci_release_device_resources(xhci_ctrl_t *xhci, xhci_device_t *dev)
 	}
 
 	if (dev->input_ctx_phys)
-		pmm_release(dev->input_ctx_phys);
+		mm_release_page(dev->input_ctx_phys);
 	if (dev->device_ctx_phys)
-		pmm_release(dev->device_ctx_phys);
+		mm_release_page(dev->device_ctx_phys);
 
 	free(dev);
 }
@@ -394,22 +394,22 @@ static int xhci_ctrl_address_device(usb_ctrl_t *ctrl, usb_hub_t *hub, uint8_t po
 	if (xhci_dev == NULL)
 		return ENOMEM;
 
-	void *device_ctx_phys = pmm_allocpage(PMM_SECTION_DEFAULT);
+	void *device_ctx_phys = mm_alloc_page(MEMORY_SECTION_DEFAULT);
 	if (device_ctx_phys == NULL) {
 		free(xhci_dev);
 		return ENOMEM;
 	}
 
-	void *input_ctx_phys = pmm_allocpage(PMM_SECTION_DEFAULT);
+	void *input_ctx_phys = mm_alloc_page(MEMORY_SECTION_DEFAULT);
 	if (input_ctx_phys == NULL) {
-		pmm_release(device_ctx_phys);
+		mm_release_page(device_ctx_phys);
 		free(xhci_dev);
 		return ENOMEM;
 	}
 
 	if (xhci_alloc_ring(xhci, &xhci_dev->ep_rings[0], false)) {
-		pmm_release(input_ctx_phys);
-		pmm_release(device_ctx_phys);
+		mm_release_page(input_ctx_phys);
+		mm_release_page(device_ctx_phys);
 		free(xhci_dev);
 		return ENOMEM;
 	}

kernel-src/io/usb/ctrl/xhci_ring.c

@@ -1,11 +1,11 @@
 #include <kernel/xhci.h>
 #include <kernel/alloc.h>
-#include <kernel/pmm.h>
+#include <kernel/page.h>
 #include <errno.h>
 #include <logging.h>
 
 int xhci_alloc_ring(xhci_ctrl_t *ctrl, xhci_ring_t *r, bool event_ring) {
-	void *ring_phys = pmm_allocpage(PMM_SECTION_DEFAULT);
+	void *ring_phys = mm_alloc_page(MEMORY_SECTION_DEFAULT);
 	if (ring_phys == NULL)
 		return ENOMEM;
 
@@ -24,7 +24,7 @@ int xhci_alloc_ring(xhci_ctrl_t *ctrl, xhci_ring_t *r, bool event_ring) {
 	} else {
 		r->submissions = alloc(sizeof(xhci_submission_t) * r->size);
 		if (r->submissions == NULL) {
-			pmm_release(ring_phys);
+			mm_release_page(ring_phys);
 			return ENOMEM;
 		}
 
@@ -37,7 +37,7 @@ int xhci_alloc_ring(xhci_ctrl_t *ctrl, xhci_ring_t *r, bool event_ring) {
 }
 
 void xhci_free_ring(xhci_ring_t *ring) {
-	pmm_release(ring->ring_phys);
+	mm_release_page(ring->ring_phys);
 	free(ring->submissions);
 }
 

kernel-src/io/usb/ctrl/xhci_xfer.c

@@ -2,7 +2,7 @@
 #include <errno.h>
 #include <kernel/alloc.h>
 #include <kernel/vmm.h>
-#include <kernel/pmm.h>
+#include <kernel/page.h>
 #include <logging.h>
 
 typedef struct {
@@ -27,7 +27,7 @@ static int xhci_count_sg_trbs(iovec_iterator_t *iov, size_t total_size, size_t *
 		if (page == NULL)
 			return EFAULT;
 
-		pmm_release(page);
+		mm_release_page(page);
 
 		done += min(page_remaining, total_size - done);
 		count++;
@@ -64,7 +64,7 @@ int xhci_data_xfer(xhci_ctrl_t *xhci, xhci_device_t *dev, usb_xfer_t *xfer, xhci
 
 		xhci_trb_t trb = {0};
 		if (xfer->flags & USB_XFER_FLAG_BUFFER_PHYSICAL) {
-			pmm_hold(xfer->data - page_offset);
+			mm_hold_page(xfer->data - page_offset);
 			trb.parameters = (uint64_t)xfer->data;
 		} else {
 			// This should never be called with user pages. Doing so is a bug. For user-fronting code, use
@@ -187,7 +187,7 @@ int xhci_sg_data_xfer(xhci_ctrl_t *xhci, xhci_ring_t *ring, xhci_device_t *dev,
 
 	fail:
 	for (size_t i = 0; i < prepared_count; ++i)
-		pmm_release(prepared[i].page);
+		mm_release_page(prepared[i].page);
 	free(prepared);
 	xhci_ring_unreserve(ring, trb_count);
 	return err;
@@ -239,7 +239,7 @@ int xhci_control_xfer(xhci_ctrl_t *xhci, xhci_device_t *dev, usb_xfer_t *xfer, x
 
 		if (xfer->data_length) {
 			if (xfer->flags & USB_XFER_FLAG_BUFFER_PHYSICAL) {
-				pmm_hold(xfer->data - page_offset);
+				mm_hold_page(xfer->data - page_offset);
 				data_trb.parameters = (uint64_t)xfer->data;
 			} else {
 				void *page = vmm_getphysical(xfer->data - page_offset, VMM_GET_PHYSICAL_FLAGS_HOLD);

kernel-src/io/virtio.c

@@ -2,7 +2,7 @@
 #include <kernel/pci.h>
 #include <logging.h>
 #include <kernel/alloc.h>
-#include <kernel/pmm.h>
+#include <kernel/page.h>
 #include <kernel/init.h>
 
 #define VIRTIO_VENDOR 0x1af4
@@ -63,7 +63,7 @@ void *virtio_createqueue(viodevice_t *viodevice, vioqueue_t *vioqueue, int queue
 	size_t bytesize = VIO_QUEUE_BYTESIZE(size);
 	size_t pagesize = ROUND_UP(bytesize, PAGE_SIZE) / PAGE_SIZE;
 
-	void *queuephys = pmm_alloc(pagesize, PMM_SECTION_DEFAULT);
+	void *queuephys = mm_alloc_pages(pagesize, MEMORY_SECTION_DEFAULT);
 	__assert(queuephys);
 	memset(MAKE_HHDM(queuephys), 0, bytesize);
 

kernel-src/mm/page.c

@@ -1,4 +1,4 @@
-#include <kernel/pmm.h>
+#include <kernel/page.h>
 #include <limine.h>
 #include <logging.h>
 #include <string.h>
@@ -14,10 +14,10 @@ static size_t pagecount;
 size_t freepagecount;
 
 static mutex_t freelistmutex;
-static page_t *freelists[PMM_SECTION_COUNT];
-static page_t *freetails[PMM_SECTION_COUNT];
-static page_t *standbylists[PMM_SECTION_COUNT];
-static page_t *standbytails[PMM_SECTION_COUNT];
+static page_t *freelists[MEMORY_SECTION_COUNT];
+static page_t *freetails[MEMORY_SECTION_COUNT];
+static page_t *standbylists[MEMORY_SECTION_COUNT];
+static page_t *standbytails[MEMORY_SECTION_COUNT];
 
 typedef struct {
 	uintmax_t baseid;
@@ -28,7 +28,7 @@ typedef struct {
 #define TOP_1MB (0x100000 / PAGE_SIZE)
 #define TOP_4GB ((uint64_t)0x100000000 / PAGE_SIZE)
 
-static section_t sections[PMM_SECTION_COUNT] = {
+static section_t sections[MEMORY_SECTION_COUNT] = {
 	{0, TOP_1MB, 0},
 	{TOP_1MB, TOP_4GB, TOP_1MB},
 	{TOP_4GB, 0xffffffffffffffffl, TOP_4GB}
@@ -39,7 +39,7 @@ static volatile struct limine_hhdm_request hhdmreq = {
 	.revision = 0
 };
 
-volatile struct limine_memmap_request pmm_liminemap = {
+volatile struct limine_memmap_request mm_page_limine_map = {
 	.id = LIMINE_MEMMAP_REQUEST_ID,
 	.revision = 0
 };
@@ -59,11 +59,11 @@ static void insertinfreelist(page_t *page) {
 	int section;
 
 	if (pageid < TOP_1MB)
-		section = PMM_SECTION_1MB;
+		section = MEMORY_SECTION_1MB;
 	else if (pageid < TOP_4GB)
-		section = PMM_SECTION_4GB;
+		section = MEMORY_SECTION_4GB;
 	else
-		section = PMM_SECTION_DEFAULT;
+		section = MEMORY_SECTION_DEFAULT;
 
 	list = page->backing ? &standbylists[section] : &freelists[section];
 	tail = page->backing ? &standbytails[section] : &freetails[section];
@@ -91,11 +91,11 @@ static void removefromfreelist(page_t *page) {
 	int section;
 
 	if (pageid < TOP_1MB)
-		section = PMM_SECTION_1MB;
+		section = MEMORY_SECTION_1MB;
 	else if (pageid < TOP_4GB)
-		section = PMM_SECTION_4GB;
+		section = MEMORY_SECTION_4GB;
 	else
-		section = PMM_SECTION_DEFAULT;
+		section = MEMORY_SECTION_DEFAULT;
 
 	list = page->backing ? &standbylists[section] : &freelists[section];
 	tail = page->backing ? &standbytails[section] : &freetails[section];
@@ -124,15 +124,15 @@ static void internalhold(page_t *page) {
 	}
 }
 
-page_t *pmm_getpage(void *address) {
+page_t *mm_get_page(void *address) {
 	return &pages[((uintptr_t)address / PAGE_SIZE)];
 }
 
-void *pmm_getpageaddress(page_t *page) {
+void *mm_get_page_address(page_t *page) {
 	return (void *)(PAGE_GETID(page) * PAGE_SIZE);
 }
 
-void pmm_hold(void *addr) {
+void mm_hold_page(void *addr) {
 	page_t *page = &pages[((uintptr_t)addr / PAGE_SIZE)];
 
 	MUTEX_ACQUIRE(&freelistmutex);
@@ -140,7 +140,7 @@ void pmm_hold(void *addr) {
 	MUTEX_RELEASE(&freelistmutex);
 }
 
-void pmm_release(void *addr) {
+void mm_release_page(void *addr) {
 	page_t *page = &pages[(uintptr_t)addr / PAGE_SIZE];
 
 	MUTEX_ACQUIRE(&freelistmutex);
@@ -160,7 +160,7 @@ static void doalloc(page_t *page) {
 	page->refcount = 1;
 }
 
-void *pmm_allocpage(int section) {
+void *mm_alloc_page(int section) {
 	retry:
 	MUTEX_ACQUIRE(&freelistmutex);
 	page_t *page = NULL;
@@ -193,7 +193,7 @@ void *pmm_allocpage(int section) {
 
 	if (cachepage && vmmcache_takepage(page) == EAGAIN) {
 		// someone already got the page from the cache between us holding it and taking it
-		pmm_release(pmm_getpageaddress(page));
+		mm_release_page(mm_get_page_address(page));
 		page = NULL;
 		// retry it from the start, as an anonymous page could have been released while the lock was not held
 		goto retry;
@@ -212,7 +212,7 @@ void *pmm_allocpage(int section) {
 	return address;
 }
 
-void pmm_makefree(void *address, size_t count) {
+void mm_force_free_page(void *address, size_t count) {
 	MUTEX_ACQUIRE(&freelistmutex);
 	memorysize += PAGE_SIZE * count;
 	__assert(((uintptr_t)address % PAGE_SIZE) == 0);
@@ -227,18 +227,18 @@ void pmm_makefree(void *address, size_t count) {
 	MUTEX_RELEASE(&freelistmutex);
 }
 
-void pmm_init() {
+void mm_page_init() {
 	__assert(hhdmreq.response);
 	hhdmbase = hhdmreq.response->offset;
-	__assert(pmm_liminemap.response);
+	__assert(mm_page_limine_map.response);
 
 	// get size of memory, top of usable memory, biggest section and print memory map
 	size_t top = 0;
 	struct limine_memmap_entry *biggest = NULL;
-	printf("pmm: ranges:\n");
-	for (size_t i = 0; i < pmm_liminemap.response->entry_count; ++i) {
-		struct limine_memmap_entry *e = pmm_liminemap.response->entries[i];
-		printf("pmm: %016p -> %016p: %d\n", e->base, e->base + e->length, e->type);
+	printf("mm: ranges:\n");
+	for (size_t i = 0; i < mm_page_limine_map.response->entry_count; ++i) {
+		struct limine_memmap_entry *e = mm_page_limine_map.response->entries[i];
+		printf("mm: %016p -> %016p: %d\n", e->base, e->base + e->length, e->type);
 		if (e->type == LIMINE_MEMMAP_USABLE || e->type == LIMINE_MEMMAP_BOOTLOADER_RECLAIMABLE || e->type == LIMINE_MEMMAP_EXECUTABLE_AND_MODULES) {
 			size_t sectiontop = e->base + e->length;
 			if (sectiontop > top)
@@ -254,11 +254,11 @@ void pmm_init() {
 	pages = MAKE_HHDM((page_t *)biggest->base);
 	pagecount = ROUND_UP(top, PAGE_SIZE) / PAGE_SIZE;
 	memset(pages, 0, pagecount * sizeof(page_t));
-	printf("pmm: %d pages used for page list\n", ROUND_UP(pagecount * sizeof(page_t), PAGE_SIZE) / PAGE_SIZE);
+	printf("mm: %d pages used for page list\n", ROUND_UP(pagecount * sizeof(page_t), PAGE_SIZE) / PAGE_SIZE);
 
 	// initialize usable memory
-	for (size_t i = 0; i < pmm_liminemap.response->entry_count; ++i) {
-		struct limine_memmap_entry *e = pmm_liminemap.response->entries[i];
+	for (size_t i = 0; i < mm_page_limine_map.response->entry_count; ++i) {
+		struct limine_memmap_entry *e = mm_page_limine_map.response->entries[i];
 		if (e->type == LIMINE_MEMMAP_USABLE) {
 			int firstusablepage = e == biggest ? ROUND_UP(e->base + pagecount * sizeof(page_t), PAGE_SIZE) / PAGE_SIZE : e->base / PAGE_SIZE;
 			for (int i = firstusablepage; i < (e->base + e->length) / PAGE_SIZE; ++i) {
@@ -276,15 +276,15 @@ void pmm_init() {
 	MUTEX_INIT(&freelistmutex);
 }
 
-INIT_ROUTINE_DEFINE(pmm, INIT_ROUTINE_FLAGS_NONE, pmm_init, arch_early);
+INIT_ROUTINE_DEFINE(mm_page, INIT_ROUTINE_FLAGS_NONE, mm_page_init, arch_early);
 
-// XXX pmm_alloc won't be able to take pages from the page cache when the allocation size is over 1 page
+// XXX mm_alloc_pages won't be able to take pages from the page cache when the allocation size is over 1 page
 
-void *pmm_alloc(size_t size, int section) {
+void *mm_alloc_pages(size_t size, int section) {
 	__assert(size);
-	// pmm_allocpage is more suited for single page allocations, so use that instead
+	// mm_alloc_page is more suited for single page allocations, so use that instead
 	if (size == 1)
-		return pmm_allocpage(section);
+		return mm_alloc_page(section);
 
 	MUTEX_ACQUIRE(&freelistmutex);
 
@@ -322,15 +322,15 @@ void *pmm_alloc(size_t size, int section) {
 	return addr;
 }
 
-void pmm_free(void *addr, size_t size) {
+void mm_release_range(void *addr, size_t size) {
 	__assert(size);
 	// release multiple pages at once
 	__assert(((uintptr_t)addr % PAGE_SIZE) == 0);
 	for (int i = 0; i < size; ++i)
-		pmm_release((void *)((uintptr_t)addr + PAGE_SIZE * i));
+		mm_release_page((void *)((uintptr_t)addr + PAGE_SIZE * i));
 }
 
-void pmm_getinfo(size_t *total_pages, size_t *free_pages) {
+void mm_get_page_statistics(size_t *total_pages, size_t *free_pages) {
 	*total_pages = memorysize / PAGE_SIZE;
 	*free_pages = freepagecount;
 }

kernel-src/mm/slab.c

@@ -1,6 +1,6 @@
 #include <kernel/slab.h>
 #include <kernel/vmm.h>
-#include <kernel/pmm.h>
+#include <kernel/page.h>
 #include <logging.h>
 #include <util.h>
 #include <arch/smp.h>
@@ -28,7 +28,7 @@ static inline bool grow_cache(scache_t *cache) {
 	slab_t *slab;
 
 	if (cache->size < SLAB_INDIRECT_CUTOFF) {
-		void *slab_hhdm = pmm_allocpage(PMM_SECTION_DEFAULT);
+		void *slab_hhdm = mm_alloc_page(MEMORY_SECTION_DEFAULT);
 		if (unlikely(slab_hhdm == NULL))
 			return false;
 
@@ -465,7 +465,7 @@ static scache_t *create_new_from_vmm(size_t size, size_t alignment, bool (*ctor)
 scache_t *slab_create_new_cache_from_pmm(size_t size, size_t alignment, bool (*ctor)(scache_t *, void *), void (*dtor)(scache_t *, void *)) {
 	__assert(size < SLAB_INDIRECT_CUTOFF);
 	size_t cache_size = sizeof(scache_t) + sizeof(cache_per_cpu_t) * arch_smp_get_cpu_count();
-	scache_t *cache = pmm_alloc(ROUND_UP(cache_size, PAGE_SIZE) / PAGE_SIZE, PMM_SECTION_DEFAULT);
+	scache_t *cache = mm_alloc_pages(ROUND_UP(cache_size, PAGE_SIZE) / PAGE_SIZE, MEMORY_SECTION_DEFAULT);
 	__assert(cache);
 	cache = MAKE_HHDM(cache);
 	__assert(slab_initialize(cache, size, alignment, ctor, dtor));
@@ -490,4 +490,4 @@ void slab_init(void) {
 }
 
 INIT_ROUTINE_DEFINE(slab, INIT_ROUTINE_FLAGS_NONE, slab_init, vmm);
-INIT_ROUTINE_DEFINE(slab_early, INIT_ROUTINE_FLAGS_NONE, slab_early_init, pmm);
+INIT_ROUTINE_DEFINE(slab_early, INIT_ROUTINE_FLAGS_NONE, slab_early_init, mm_page);

kernel-src/mm/vmm.c

@@ -1,6 +1,6 @@
 #include <kernel/vmm.h>
 #include <logging.h>
-#include <kernel/pmm.h>
+#include <kernel/page.h>
 #include <util.h>
 #include <arch/cpu.h>
 #include <limine.h>
@@ -175,19 +175,19 @@ static void destroyrange(vmmrange_t *range, uintmax_t _offset, size_t size, int
 				// dirty page cache mapping
 				arch_mmu_unmap(current_vmm_context()->pagetable, vaddr);
 				VOP_LOCK(range->vnode);
-				vmmcache_makedirty(pmm_getpage(physical));
+				vmmcache_makedirty(mm_get_page(physical));
 				VOP_UNLOCK(range->vnode);
-				pmm_release(physical);
+				mm_release_page(physical);
 			} else {
 				// non dirty page mapping
 				arch_mmu_unmap(current_vmm_context()->pagetable, vaddr);
-				pmm_release(physical);
+				mm_release_page(physical);
 			}
 		} else {
 			// anonymous, physical or private non character device mapping
 			arch_mmu_unmap(current_vmm_context()->pagetable, vaddr);
 			if ((range->flags & VMM_FLAGS_PHYSICAL) == 0)
-				pmm_release(physical);
+				mm_release_page(physical);
 		}
 	}
 
@@ -220,7 +220,7 @@ static void changemmurange(vmmrange_t *range, void *base, size_t size, mmuflags_
 		if ((range->flags & VMM_FLAGS_FILE) && (range->flags & VMM_FLAGS_SHARED) && (mask & ARCH_MMU_FLAGS_WRITE) && vfs_iscacheable(range->vnode)) {
 			// removing write permissions from a writeable dirty shared mapped page, mark it as dirty, as
 			// it won't be marked dirty upon a vmm_unmap after this
-			page_t *page = pmm_getpage(physical);
+			page_t *page = mm_get_page(physical);
 			VOP_LOCK(range->vnode);
 			vmmcache_makedirty(page);
 			VOP_UNLOCK(range->vnode);
@@ -566,10 +566,10 @@ bool vmm_pagefault(void *addr, bool user, int actions) {
 					printf("vmm: error on vmmcache_getpage(): %d\n", error);
 					status = false;
 				} else {
-					status = arch_mmu_map(current_vmm_context()->pagetable, pmm_getpageaddress(res), addr, range->mmuflags & ~ARCH_MMU_FLAGS_WRITE);
+					status = arch_mmu_map(current_vmm_context()->pagetable, mm_get_page_address(res), addr, range->mmuflags & ~ARCH_MMU_FLAGS_WRITE);
 					if (!status) {
 						printf("vmm: out of memory to map file into address space (sending SIGBUS)\n");
-						pmm_release(pmm_getpageaddress(res));
+						mm_release_page(mm_get_page_address(res));
 						signal_signalthread(current_thread(), SIGBUS, true);
 						status = true;
 					}
@@ -580,7 +580,7 @@ bool vmm_pagefault(void *addr, bool user, int actions) {
 			// anonymous memory.
 			if (range->mmuflags & ARCH_MMU_FLAGS_WRITE) {
 				// writeable range: allocate a new page, zero it and map it
-				void *new_page = pmm_allocpage(PMM_SECTION_DEFAULT);
+				void *new_page = mm_alloc_page(MEMORY_SECTION_DEFAULT);
 				if (new_page == NULL) {
 					printf("vmm: out of memory to allocate page to satisfy anonymous page-in (sending SIGBUS)\n");
 					signal_signalthread(current_thread(), SIGBUS, true);
@@ -592,7 +592,7 @@ bool vmm_pagefault(void *addr, bool user, int actions) {
 				if (!arch_mmu_map(current_vmm_context()->pagetable, new_page, addr, range->mmuflags)) {
 					printf("vmm: out of memory to map page (sending SIGBUS)\n");
 					signal_signalthread(current_thread(), SIGBUS, true);
-					pmm_release(new_page);
+					mm_release_page(new_page);
 				}
 			} else {
 				// read-only range: map a shared zero page
@@ -600,14 +600,14 @@ bool vmm_pagefault(void *addr, bool user, int actions) {
 					printf("vmm: out of memory to map zero page into address space (sending SIGBUS)\n");
 					signal_signalthread(current_thread(), SIGBUS, true);
 				} else {
-					pmm_hold(zeropage);
+					mm_hold_page(zeropage);
 				}
 			}
 		}
 	} else if (arch_mmu_iswritable(current_vmm_context()->pagetable, addr) == false) {
 		// page present but not writeable in the page tables
 		void *oldphys = arch_mmu_getphysical(current_vmm_context()->pagetable, addr);
-		page_t *oldpage = pmm_getpage(oldphys);
+		page_t *oldpage = mm_get_page(oldphys);
 
 		if (    ((range->flags & VMM_FLAGS_FILE) && (range->flags & VMM_FLAGS_SHARED)) ||
 			((range->flags & VMM_FLAGS_FILE) == 0 && oldpage->refcount == 1)) {
@@ -617,14 +617,14 @@ bool vmm_pagefault(void *addr, bool user, int actions) {
 			if ((range->flags & VMM_FLAGS_FILE) && vfs_iscacheable(range->vnode)) {
 				// and if its a cache page, mark it as dirty
 				VOP_LOCK(range->vnode);
-				vmmcache_makedirty(pmm_getpage(oldphys));
+				vmmcache_makedirty(mm_get_page(oldphys));
 				VOP_UNLOCK(range->vnode);
 			}
 
 			status = true;
 		} else {
 			// do copy on write
-			void *newphys = pmm_allocpage(PMM_SECTION_DEFAULT);
+			void *newphys = mm_alloc_page(MEMORY_SECTION_DEFAULT);
 			if (newphys == NULL) {
 				printf("vmm: out of memory to do copy on write on address space (sending SIGBUS)\n");
 				signal_signalthread(current_thread(), SIGBUS, true);
@@ -634,7 +634,7 @@ bool vmm_pagefault(void *addr, bool user, int actions) {
 				arch_mmu_remap(current_vmm_context()->pagetable, newphys, addr, range->mmuflags);
 				arch_mmu_invalidate_range(addr, PAGE_SIZE);
 				if ((range->flags & VMM_FLAGS_FILE) == 0 || vfs_iscacheable(range->vnode))
-					pmm_release(oldphys);
+					mm_release_page(oldphys);
 
 				status = true;
 			}
@@ -667,7 +667,7 @@ static int lock_page(vmmspace_t *space, void *vaddr) {
 	// TODO shared anonymous mappings are not handled properly by the kernel
 	if (present && writable == false && private)) {
 		// CoW cases (private mapping)
-		real_phys = pmm_allocpage(PMM_SECTION_DEFAULT);
+		real_phys = mm_alloc_page(MEMORY_SECTION_DEFAULT);
 		if (real_phys == NULL)
 			return ENOMEM;
 
@@ -676,10 +676,10 @@ static int lock_page(vmmspace_t *space, void *vaddr) {
 		arch_mmu_remap(current_vmm_context()->pagetable, real_phys, vaddr, range->mmuflags);
 		arch_mmu_invalidate_range(vaddr, PAGE_SIZE);
 		if (file_mapping == false || vfs_iscacheable(range->vnode))
-			pmm_release(mapped_address);
+			mm_release_page(mapped_address);
 	} else if (present == false && private) {
 		// not present private mapping case
-		real_phys = pmm_allocpage(PMM_SECTION_DEFAULT);
+		real_phys = mm_alloc_page(MEMORY_SECTION_DEFAULT);
 		if (real_phys == NULL)
 	}
 }
@@ -704,7 +704,7 @@ void *vmm_getphysical(void *addr, int flags) {
 	physical = arch_mmu_getphysical(current_vmm_context()->pagetable, aligned_addr);
 
 	if (flags & VMM_GET_PHYSICAL_FLAGS_HOLD)
-		pmm_hold(physical);
+		mm_hold_page(physical);
 
 	leave:
 	MUTEX_RELEASE(&space->lock);
@@ -791,7 +791,7 @@ void *vmm_map(void *addr, volatile size_t size, int flags, mmuflags_t mmuflags,
 	} else if (flags & VMM_FLAGS_ALLOCATE) {
 		// allocate to virtual memory
 		for (uintmax_t i = 0; i < size; i += PAGE_SIZE) {
-			void *allocated = pmm_allocpage(PMM_SECTION_DEFAULT);
+			void *allocated = mm_alloc_page(MEMORY_SECTION_DEFAULT);
 			if (allocated == NULL) {
 				retaddr = NULL;
 				goto cleanup;
@@ -803,7 +803,7 @@ void *vmm_map(void *addr, volatile size_t size, int flags, mmuflags_t mmuflags,
 						void *physical = arch_mmu_getphysical(current_vmm_context()->pagetable, virt);
 
 						if (physical) {
-							pmm_release(physical);
+							mm_release_page(physical);
 							arch_mmu_unmap(current_vmm_context()->pagetable, virt);
 						}
 				}
@@ -926,7 +926,7 @@ vmmcontext_t *vmm_fork(vmmcontext_t *oldcontext) {
 			if (arch_mmu_map(newcontext->pagetable, phys, vaddr, newrange->mmuflags & ~ARCH_MMU_FLAGS_WRITE) == false)
 				goto error;
 
-			pmm_hold(phys);
+			mm_hold_page(phys);
 
 			arch_mmu_remap(oldcontext->pagetable, phys, vaddr, newrange->mmuflags & ~ARCH_MMU_FLAGS_WRITE);
 		}
@@ -959,7 +959,7 @@ extern void *_text_end;
 extern void *_data_end;
 extern void *_rodata_end;
 
-extern volatile struct limine_memmap_request pmm_liminemap;
+extern volatile struct limine_memmap_request mm_page_limine_map;
 
 void vmm_init() {
 	// set up initial state
@@ -976,8 +976,8 @@ void vmm_init() {
 	vmm_switchcontext(&vmm_kernelctx);
 
 	// map HHDM
-	for (uint64_t i = 0; i < pmm_liminemap.response->entry_count; ++i) {
-		struct limine_memmap_entry *e = pmm_liminemap.response->entries[i];
+	for (uint64_t i = 0; i < mm_page_limine_map.response->entry_count; ++i) {
+		struct limine_memmap_entry *e = mm_page_limine_map.response->entries[i];
 
 		if (e->type != LIMINE_MEMMAP_USABLE && e->type != LIMINE_MEMMAP_BOOTLOADER_RECLAIMABLE && e->type != LIMINE_MEMMAP_EXECUTABLE_AND_MODULES && e->type != LIMINE_MEMMAP_FRAMEBUFFER)
 			continue;
@@ -998,7 +998,7 @@ void vmm_init() {
 	vmm_map(MAKE_HHDM(NULL), PAGE_SIZE, VMM_FLAGS_EXACT, ARCH_MMU_FLAGS_NOEXEC, NULL);
 
 	// zero page
-	zeropage = pmm_allocpage(PMM_SECTION_DEFAULT);
+	zeropage = mm_alloc_page(MEMORY_SECTION_DEFAULT);
 	memset(MAKE_HHDM(zeropage), 0, PAGE_SIZE);
 
 	printspace(&kernelspace);

kernel-src/mm/vmmcache.c

@@ -114,12 +114,12 @@ int vmmcache_getpage(vnode_t *vnode, uintmax_t offset, page_t **res) {
 	retry:
 	if (page) {
 		// page is present in the page cache
-		pmm_hold(pmm_getpageaddress((page_t *)page));
+		mm_hold_page(mm_get_page_address((page_t *)page));
 		RELEASE_LOCK();
 
 		// in the case of a retry, release the allocated page here
 		if (newpage)
-			pmm_release(pmm_getpageaddress(newpage));
+			mm_release_page(mm_get_page_address(newpage));
 
 		eventlistener_t listener;
 		EVENT_INITLISTENER(&listener);
@@ -133,7 +133,7 @@ int vmmcache_getpage(vnode_t *vnode, uintmax_t offset, page_t **res) {
 
 		if (page->flags & PAGE_FLAGS_ERROR) {
 			// the thread handling the page in failed to read it, we should retry it and see whats up
-			pmm_release(pmm_getpageaddress((page_t *)page));
+			mm_release_page(mm_get_page_address((page_t *)page));
 			goto retry_err;
 		}
 
@@ -142,11 +142,11 @@ int vmmcache_getpage(vnode_t *vnode, uintmax_t offset, page_t **res) {
 		// page is not present in the cache, we will have to load it in
 		RELEASE_LOCK();
 
-		void *address = pmm_allocpage(PMM_SECTION_DEFAULT);
+		void *address = mm_alloc_page(MEMORY_SECTION_DEFAULT);
 		if (address == NULL)
 			return ENOMEM;
 
-		newpage = pmm_getpage(address);
+		newpage = mm_get_page(address);
 		
 		HOLD_LOCK();
 
@@ -180,7 +180,7 @@ int vmmcache_getpage(vnode_t *vnode, uintmax_t offset, page_t **res) {
 			newpage->offset = 0;
 
 			RELEASE_LOCK();
-			pmm_release(pmm_getpageaddress(newpage));
+			mm_release_page(mm_get_page_address(newpage));
 			EVENT_SIGNAL(&pagereadyevent);
 			return error;
 		}
@@ -289,7 +289,7 @@ int vmmcache_truncate(vnode_t *vnode, uintmax_t offset) {
 		page_t *page = pagelist;
 		pagelist = pagelist->vnodenext;
 		if (page->flags & PAGE_FLAGS_PINNED)
-			pmm_release(pmm_getpageaddress(page));
+			mm_release_page(mm_get_page_address(page));
 	}
 
 	return 0;
@@ -318,7 +318,7 @@ static int syncpage(page_t *page, bool backinglock) {
 		VOP_RELEASE(page->backing);
 	}
 
-	pmm_release(pmm_getpageaddress((page_t *)page));
+	mm_release_page(mm_get_page_address((page_t *)page));
 	return e;
 }
 
@@ -427,7 +427,7 @@ int vmmcache_makedirty(page_t *page) {
 			dirtylist = page;
 		}
 
-		pmm_hold(pmm_getpageaddress(page));
+		mm_hold_page(mm_get_page_address(page));
 		__assert(page->backing);
 		VOP_HOLD(page->backing);
 	}

kernel-src/sys/syscalls/sysinfo.c

@@ -1,6 +1,6 @@
 #include <kernel/syscalls.h>
 #include <arch/cpu.h>
-#include <kernel/pmm.h>
+#include <kernel/page.h>
 #include <kernel/vmmcache.h>
 #include <kernel/proc.h>
 
@@ -26,7 +26,7 @@ syscallret_t syscall_sysinfo(context_t *, sysinfo_t *usysinfo) {
 	};
 
 	size_t total_pages, free_pages;
-	pmm_getinfo(&total_pages, &free_pages);
+	mm_get_page_statistics(&total_pages, &free_pages);
 
 	sysinfo_t sysinfo = {
 		.uptime = timekeeper_timefromboot().s,