mm: vmmcache -> mm_cache

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

@@ -1,7 +1,7 @@
 #include <logging.h>
 #include <arch/e9.h>
 #include <arch/cpu.h>
-#include <kernel/vmmcache.h>
+#include <kernel/mm.h>
 #include <kernel/kernel_args.h>
 
 #ifdef SYSCALL_LOGGING
@@ -252,7 +252,7 @@ __attribute__((no_caller_saved_registers)) void arch_syscall_log(int syscall, ui
 	arch_cpu_user_access_begin();
 	snprintf(argbuff, 768, syscall < SYSCALL_COUNT ? args[syscall] : "N/A", a1, a2, a3, a4, a5, a6);
 	arch_cpu_user_access_end();
-	snprintf(printbuff, 1024, "\e[92msyscall: pid %d tid %d: %s: %s (%lu cached pages, %lu free pages)\n\e[0m", proc->pid, thread->tid, syscall < SYSCALL_COUNT ? name[syscall] : "invalid syscall", argbuff, vmmcache_cachedpages, mm_free_page_count);
+	snprintf(printbuff, 1024, "\e[92msyscall: pid %d tid %d: %s: %s (%lu cached pages, %lu free pages)\n\e[0m", proc->pid, thread->tid, syscall < SYSCALL_COUNT ? name[syscall] : "invalid syscall", argbuff, mm_cache_cached_pages, mm_free_page_count);
 
 	arch_interrupt_disable();
 	spinlock_acquire(&lock);
@@ -271,7 +271,7 @@ __attribute__((no_caller_saved_registers)) void arch_syscall_log_return(uint64_t
 	if (!(proc->flags & PROC_FLAG_SYSTRACE) && GET_KERNEL_ARGUMENT(global_syscall_logging, bool) == false)
 		return;
 
-	snprintf(printbuff, 1024, "\e[94msyscall return: pid %d tid %d: %lu %s (%lu cached pages, %lu free pages)\n\e[0m", proc->pid, thread->tid, ret, strerror(errno), vmmcache_cachedpages, mm_free_page_count);
+	snprintf(printbuff, 1024, "\e[94msyscall return: pid %d tid %d: %lu %s (%lu cached pages, %lu free pages)\n\e[0m", proc->pid, thread->tid, ret, strerror(errno), mm_cache_cached_pages, mm_free_page_count);
 	arch_interrupt_disable();
 	spinlock_acquire(&lock);
 	LOGSTR(printbuff);

kernel-src/fs/devfs.c

@@ -7,7 +7,7 @@
 #include <kernel/alloc.h>
 #include <kernel/timekeeper.h>
 #include <kernel/page.h>
-#include <kernel/vmmcache.h>
+#include <kernel/mm.h>
 #include <kernel/auth.h>
 #include <kernel/init.h>
 
@@ -424,8 +424,8 @@ static int devfs_putpage(vnode_t *node, uintmax_t offset, struct page_t *page) {
 	return error;
 }
 
-static int devfs_sync(vnode_t *vnode) {
+static int devfs_sync(vnode_t *) {
-	return vmmcache_sync(vnode);
+	return mm_cache_sync();
 }
 
 // most locking is handled by the devices.

kernel-src/fs/ext2.c

@@ -9,7 +9,7 @@
 #include <mutex.h>
 #include <logging.h>
 #include <util.h>
-#include <kernel/vmmcache.h>
+#include <kernel/mm.h>
 #include <kernel/pipefs.h>
 #include <kernel/auth.h>
 #include <kernel/init.h>
@@ -1471,7 +1471,7 @@ int ext2_resize(vnode_t *vnode, size_t newsize, cred_t *cred) {
 	if (size != newsize) {
 		e = resizeinode(fs, node, newsize);
 		if (size > newsize)
-			vmmcache_truncate(vnode, newsize);
+			mm_cache_truncate(vnode, newsize);
 	}
 	return e;
 }
@@ -1918,11 +1918,11 @@ static int ext2_rename(vnode_t *sourcedir, vnode_t *source, char *oldname, vnode
 }
 
 static int ext2_sync(vnode_t *vnode) {
-	int e = vmmcache_syncvnode(vnode, 0, UINT64_MAX);
+	int e = mm_cache_sync_vnode(vnode, 0, UINT64_MAX);
 	ext2fs_t *fs = (ext2fs_t *)vnode->vfs;
 	// TODO don't sync the entire disk but rather only the inodes and blocks
 	VOP_LOCK(fs->backing);
-	int e2 = vmmcache_syncvnode(fs->backing, 0, UINT64_MAX);
+	int e2 = mm_cache_sync_vnode(fs->backing, 0, UINT64_MAX);
 	VOP_UNLOCK(fs->backing);
 	// only the first errors are reported
 	return e ? e : e2;
@@ -1960,7 +1960,7 @@ static int ext2_inactive(vnode_t *vnode) {
 		__assert(hashtable_remove(&fs->inodetable, &node->id, sizeof(node->id)) == 0);
 		MUTEX_RELEASE(&fs->inodetablelock);
 
-		vmmcache_truncate(vnode, 0);
+		mm_cache_truncate(vnode, 0);
 		freeinode(fs, &node->inode, node->id);
 
 		slab_free(nodecache, node);

kernel-src/fs/fat/fatfs.c

@@ -7,7 +7,7 @@
 #include <kernel/slab.h>
 #include <kernel/auth.h>
 #include <kernel/page.h>
-#include <kernel/vmmcache.h>
+#include <kernel/mm.h>
 
 typedef struct {
 	uint8_t drive_num;
@@ -192,7 +192,7 @@ static int fatfs_unmount(vfs_t *vfs) {
 static int fatfs_sync(vfs_t *vfs) {
 	fatfs_t *fatfs = (fatfs_t *)vfs;
 	VOP_LOCK(fatfs->backing);
-	int error = vmmcache_syncvnode(fatfs->backing, 0, UINT64_MAX);
+	int error = mm_cache_sync_vnode(fatfs->backing, 0, UINT64_MAX);
 	VOP_UNLOCK(fatfs->backing);
 	return error;
 }
@@ -255,16 +255,16 @@ static int fatfs_syncvnode(vnode_t *vnode) {
 	fatnode_t *fatnode = (fatnode_t *)vnode;
 
 	// sync file data
-	int e = vmmcache_syncvnode(vnode, 0, UINT64_MAX);
+	int e = mm_cache_sync_vnode(vnode, 0, UINT64_MAX);
 
 	VOP_LOCK(fs->backing);
 	// sync the dent
 	int e2 = 0;
 	if (fatnode->dent_disk_offset)
-		e2 = vmmcache_syncvnode(fs->backing, fatnode->dent_disk_offset, sizeof(fatfs_dent_t));
+		e2 = mm_cache_sync_vnode(fs->backing, fatnode->dent_disk_offset, sizeof(fatfs_dent_t));
 
 	// and sync the fats
-	int e3 = vmmcache_syncvnode(fs->backing, fs->fat_offset, fs->fat_size * fs->fat_count);
+	int e3 = mm_cache_sync_vnode(fs->backing, fs->fat_offset, fs->fat_size * fs->fat_count);
 
 	VOP_UNLOCK(fs->backing);
 
@@ -938,7 +938,7 @@ static int fatfs_resize(vnode_t *vnode, size_t new_size, cred_t *cred) {
 	if (node->size != new_size) {
 		error = fatfs_resize_file(fs, node, new_size);
 		if (node->size > new_size)
-			vmmcache_truncate(vnode, new_size);
+			mm_cache_truncate(vnode, new_size);
 	}
 
 	return error;
@@ -957,7 +957,7 @@ static int fatfs_inactive(vnode_t *vnode) {
 		__assert(!"fatfs VOP_INACTIVE() with hardlink count >0 is currently unimplemented");
 	} else {
 		// unlinked file having resources released when kernel refcount hits zero
-		vmmcache_truncate(vnode, 0);
+		mm_cache_truncate(vnode, 0);
 		fatfs_resize_file(fatfs, fatnode, 0);
 	}
 

kernel-src/fs/tmpfs.c

@@ -12,7 +12,7 @@
 #include <kernel/vmm.h>
 #include <arch/cpu.h>
 #include <string.h>
-#include <kernel/vmmcache.h>
+#include <kernel/mm.h>
 #include <kernel/pipefs.h>
 #include <kernel/auth.h>
 #include <kernel/init.h>
@@ -499,7 +499,7 @@ static int tmpfs_inactive(vnode_t *node) {
 	tmpfsnode_t *tmp_node = (tmpfsnode_t *)node;
 	__assert(tmp_node->attr.nlinks == (node->type == V_TYPE_DIR ? 1 : 0));
 	if (node->type == V_TYPE_REGULAR) {
-		vmmcache_truncate(node, 0);
+		mm_cache_truncate(node, 0);
 	}
 	freenode(tmp_node);
 	return 0;
@@ -509,7 +509,7 @@ static int tmpfs_resize(vnode_t *node, size_t size, cred_t *) {
 	tmpfsnode_t *tmpfsnode = (tmpfsnode_t *)node;
 	if (size != tmpfsnode->attr.size && tmpfsnode->vnode.type == V_TYPE_REGULAR) {
 		if (tmpfsnode->attr.size > size)
-			vmmcache_truncate(node, size);
+			mm_cache_truncate(node, size);
 
 		tmpfsnode->attr.size = size;
 	}
@@ -526,7 +526,7 @@ static int tmpfs_getpage(vnode_t *node, uintmax_t offset, struct page_t *page) {
 	if (error)
 		return error;
 
-	// since tmpfs files now store their data on the vmmcache,
+	// since tmpfs files now store their data on the mm cache,
 	// all getpage will do will be set the page to 0 and pin it in memory
 	void *phy = mm_get_page_address(page);
 	void *phyhhdm = MAKE_HHDM(phy);

kernel-src/fs/vfs.c

@@ -7,7 +7,7 @@
 #include <arch/cpu.h>
 #include <kernel/poll.h>
 #include <kernel/sock.h>
-#include <kernel/vmmcache.h>
+#include <kernel/mm.h>
 #include <kernel/block.h>
 #include <kernel/pipefs.h>
 #include <kernel/auth.h>
@@ -387,11 +387,11 @@ static int writenocache(vnode_t *node, page_t *page, uintmax_t pageoffset) {
 	if (node->type == V_TYPE_REGULAR)
 		e = VOP_SYNC(node);
 	else
-		e = vmmcache_syncvnode(node, pageoffset, PAGE_SIZE);
+		e = mm_cache_sync_vnode(node, pageoffset, PAGE_SIZE);
 	VOP_UNLOCK(node);
 
 	// try to turn it into anonymous memory
-	vmmcache_evict(page);
+	mm_cache_evict(page);
 
 	return e;
 }
@@ -449,7 +449,7 @@ int vfs_write_iovec(vnode_t *node, iovec_iterator_t *iovec_iterator, size_t size
 
 		if (startoffset) {
 			// unaligned first page
-			err = vmmcache_getpage(node, pageoffset * PAGE_SIZE, &page);
+			err = mm_cache_get_page(node, pageoffset * PAGE_SIZE, &page);
 			if (err)
 				goto leave;
 
@@ -462,7 +462,7 @@ int vfs_write_iovec(vnode_t *node, iovec_iterator_t *iovec_iterator, size_t size
 				goto leave;
 			}
 
-			vmmcache_makedirty(page);
+			mm_cache_make_dirty(page);
 			*written += writesize;
 
 			if (flags & V_FFLAGS_NOCACHE)
@@ -478,7 +478,7 @@ int vfs_write_iovec(vnode_t *node, iovec_iterator_t *iovec_iterator, size_t size
 
 		for (uintmax_t offset = 0; offset < pagecount * PAGE_SIZE; offset += PAGE_SIZE) {
 			// the other pages
-			err = vmmcache_getpage(node, pageoffset * PAGE_SIZE + offset, &page);
+			err = mm_cache_get_page(node, pageoffset * PAGE_SIZE + offset, &page);
 			if (err)
 				goto leave;
 
@@ -491,7 +491,7 @@ int vfs_write_iovec(vnode_t *node, iovec_iterator_t *iovec_iterator, size_t size
 				goto leave;
 			}
 
-			vmmcache_makedirty(page);
+			mm_cache_make_dirty(page);
 			*written += writesize;
 
 			if (flags & V_FFLAGS_NOCACHE)
@@ -562,7 +562,7 @@ int vfs_read_iovec(vnode_t *node, iovec_iterator_t *iovec_iterator, size_t size,
 
 		if (startoffset) {
 			// unaligned first page
-			err = vmmcache_getpage(node, pageoffset * PAGE_SIZE, &page);
+			err = mm_cache_get_page(node, pageoffset * PAGE_SIZE, &page);
 			if (err)
 				goto leave;
 
@@ -579,7 +579,7 @@ int vfs_read_iovec(vnode_t *node, iovec_iterator_t *iovec_iterator, size_t size,
 
 			if (flags & V_FFLAGS_NOCACHE) {
 				// try to turn it into anonymous memory
-				vmmcache_evict(page);
+				mm_cache_evict(page);
 			}
 
 			pageoffset += 1;
@@ -590,7 +590,7 @@ int vfs_read_iovec(vnode_t *node, iovec_iterator_t *iovec_iterator, size_t size,
 
 		for (uintmax_t offset = 0; offset < pagecount * PAGE_SIZE; offset += PAGE_SIZE) {
 			// the other pages
-			err = vmmcache_getpage(node, pageoffset * PAGE_SIZE + offset, &page);
+			err = mm_cache_get_page(node, pageoffset * PAGE_SIZE + offset, &page);
 			if (err)
 				goto leave;
 
@@ -606,7 +606,7 @@ int vfs_read_iovec(vnode_t *node, iovec_iterator_t *iovec_iterator, size_t size,
 			*bytesread += readsize;
 			if (flags & V_FFLAGS_NOCACHE) {
 				// try to turn it into anonymous memory
-				vmmcache_evict(page);
+				mm_cache_evict(page);
 			}
 			mm_release_page(FROM_HHDM(address));
 		}

kernel-src/include/kernel/mm.h

@@ -0,0 +1,19 @@
+#ifndef _MM_H
+#define _MM_H
+
+#include <kernel/page.h>
+#include <kernel/vfs.h>
+
+extern size_t mm_cache_cached_pages;
+
+void mm_cache_init(void);
+int mm_cache_get_page(vnode_t *vnode, uintmax_t offset, page_t **res);
+int mm_cache_take_page(page_t *page);
+int mm_cache_make_dirty(page_t *page);
+int mm_cache_truncate(vnode_t *vnode, uintmax_t offset);
+int mm_cache_sync_vnode(vnode_t *vnode, uintmax_t startoffset, size_t size);
+int mm_cache_push_page(vnode_t *vnode, uintmax_t offset, page_t *page);
+int mm_cache_sync(void);
+int mm_cache_evict(page_t *page);
+
+#endif

kernel-src/include/kernel/vmm.h

@@ -26,7 +26,6 @@ typedef struct {
 	uintmax_t offset;
 } vmmfiledesc_t;
 
-struct vmmcache_t;
 typedef struct vmmrange_t{
 	rbtree_t rbtree_node;
 	void *start;

kernel-src/include/kernel/vmmcache.h

@@ -1,19 +0,0 @@
-#ifndef _VMMCACHE_H
-#define _VMMCACHE_H
-
-#include <kernel/page.h>
-#include <kernel/vfs.h>
-
-extern size_t vmmcache_cachedpages;
-
-void vmmcache_init();
-int vmmcache_getpage(vnode_t *vnode, uintmax_t offset, page_t **res);
-int vmmcache_takepage(page_t *page);
-int vmmcache_makedirty(page_t *page);
-int vmmcache_truncate(vnode_t *vnode, uintmax_t offset);
-int vmmcache_syncvnode(vnode_t *vnode, uintmax_t startoffset, size_t size);
-int vmmcache_pushpage(vnode_t *vnode, uintmax_t offset, page_t *page);
-int vmmcache_sync();
-int vmmcache_evict(page_t *page);
-
-#endif

kernel-src/mm/cache.c

@@ -1,4 +1,4 @@
-#include <kernel/vmmcache.h>
+#include <kernel/mm.h>
 #include <kernel/vmm.h>
 #include <util.h>
 #include <logging.h>
@@ -16,7 +16,7 @@ static thread_t *writerthread;
 static semaphore_t sync;
 static eventheader_t syncevent;
 static eventheader_t pagereadyevent;
-size_t vmmcache_cachedpages;
+size_t mm_cache_cached_pages;
 
 #define HOLD_LOCK() \
 	MUTEX_ACQUIRE(&mutex);
@@ -70,7 +70,7 @@ static void putpage(page_t *page) {
 		page->backing->pages->vnode_prev = page;
 
 	page->backing->pages = page;
-	++vmmcache_cachedpages;
+	++mm_cache_cached_pages;
 }
 
 // assumes lock is held
@@ -100,10 +100,10 @@ static void removepage(page_t *page) {
 
 	page->vnode_next = NULL;
 	page->vnode_prev = NULL;
-	--vmmcache_cachedpages;
+	--mm_cache_cached_pages;
 }
 
-int vmmcache_getpage(vnode_t *vnode, uintmax_t offset, page_t **res) {
+int mm_cache_get_page(vnode_t *vnode, uintmax_t offset, page_t **res) {
 	__assert(vnode->type == V_TYPE_REGULAR || vnode->type == V_TYPE_BLKDEV);
 	__assert((offset % PAGE_SIZE) == 0);
 	retry_err:
@@ -197,7 +197,7 @@ int vmmcache_getpage(vnode_t *vnode, uintmax_t offset, page_t **res) {
 }
 
 // adds a page to the cache in a specific offset if its not already there
-int vmmcache_pushpage(vnode_t *vnode, uintmax_t offset, page_t *page) {
+int mm_cache_push_page(vnode_t *vnode, uintmax_t offset, page_t *page) {
 	__assert((offset % PAGE_SIZE) == 0);
 	HOLD_LOCK();
 
@@ -218,7 +218,7 @@ int vmmcache_pushpage(vnode_t *vnode, uintmax_t offset, page_t *page) {
 }
 
 // removes a page from the cache AND turns it into anonymous memory
-int vmmcache_evict(page_t *page) {
+int mm_cache_evict(page_t *page) {
 	HOLD_LOCK();
 	if (page->refcount > 1) {
 		RELEASE_LOCK();
@@ -241,9 +241,9 @@ int vmmcache_evict(page_t *page) {
 }
 
 // removes a page from the cache *but doesn't do anything to it*
-int vmmcache_takepage(page_t *page) {
+int mm_cache_take_page(page_t *page) {
 	HOLD_LOCK();
-	// someone called vmmcache_getpage() and got this page while the lock wasn't held
+	// someone called mm_cache_get_page() and got this page while the lock wasn't held
 	// return an error status to the caller
 	if (page->refcount > 1) {
 		RELEASE_LOCK();
@@ -263,7 +263,7 @@ int vmmcache_takepage(page_t *page) {
 	return 0;
 }
 
-int vmmcache_truncate(vnode_t *vnode, uintmax_t offset) {
+int mm_cache_truncate(vnode_t *vnode, uintmax_t offset) {
 	HOLD_LOCK();
 	page_t *pagelist = NULL;
 	page_t *page = vnode->pages;
@@ -326,7 +326,7 @@ static page_t *dirtylist;
 static page_t *dirtylistend;
 
 // expects vnode to be held
-int vmmcache_syncvnode(vnode_t *vnode, uintmax_t offset, size_t size) {
+int mm_cache_sync_vnode(vnode_t *vnode, uintmax_t offset, size_t size) {
 	offset = ROUND_DOWN(offset, PAGE_SIZE);
 	uintmax_t top = offset + size;
 	// overflow check
@@ -386,7 +386,7 @@ int vmmcache_syncvnode(vnode_t *vnode, uintmax_t offset, size_t size) {
 	return e;
 }
 
-int vmmcache_sync() {
+int mm_cache_sync(void) {
 	eventlistener_t eventlistener;
 	EVENT_INITLISTENER(&eventlistener);
 	HOLD_LOCK();
@@ -407,7 +407,7 @@ int vmmcache_sync() {
 }
 
 // backing expected locked
-int vmmcache_makedirty(page_t *page) {
+int mm_cache_make_dirty(page_t *page) {
 	bool madedirty = false;
 	HOLD_LOCK();
 
@@ -468,12 +468,12 @@ static void writer() {
 			dirtylist = NULL;
 
 		page->write_prev = NULL;
-		// TODO notify error on vmmcache_syncvnode
+		// TODO notify error on mm_cache_sync_vnode
 		syncpage((page_t *)page, true);
 	}
 }
 
-void vmmcache_init() {
+void mm_cache_init(void) {
 	MUTEX_INIT(&mutex);
 	table = vmm_map(NULL, TABLE_SIZE * sizeof(page_t *), VMM_FLAGS_ALLOCATE, ARCH_MMU_FLAGS_READ | ARCH_MMU_FLAGS_WRITE | ARCH_MMU_FLAGS_NOEXEC, NULL);
 	__assert(table);
@@ -483,9 +483,9 @@ void vmmcache_init() {
 	writerthread = sched_newthread(writer, PAGE_SIZE * 16, 1, NULL, NULL);
 	__assert(writerthread);
 	sched_queue(writerthread);
-	vmmcache_sync();
+	mm_cache_sync();
 	EVENT_INITHEADER(&syncevent);
 	EVENT_INITHEADER(&pagereadyevent);
 }
 
-INIT_ROUTINE_DEFINE(vmm_cache, INIT_ROUTINE_FLAGS_NONE, vmmcache_init, scheduler);
+INIT_ROUTINE_DEFINE(mm_cache, INIT_ROUTINE_FLAGS_NONE, mm_cache_init, scheduler);

kernel-src/mm/page.c

@@ -5,7 +5,7 @@
 #include <arch/mmu.h>
 #include <mutex.h>
 #include <util.h>
-#include <kernel/vmmcache.h>
+#include <kernel/mm.h>
 #include <kernel/init.h>
 
 uintptr_t hhdm_base;
@@ -191,7 +191,7 @@ void *mm_alloc_page(int section) {
 
 	MUTEX_RELEASE(&free_list_mutex);
 
-	if (cache_page && vmmcache_takepage(page) == EAGAIN) {
+	if (cache_page && mm_cache_take_page(page) == EAGAIN) {
 		// someone already got the page from the cache between us holding it and taking it
 		mm_release_page(mm_get_page_address(page));
 		page = NULL;

kernel-src/mm/vmm.c

@@ -6,7 +6,7 @@
 #include <limine.h>
 #include <string.h>
 #include <kernel/slab.h>
-#include <kernel/vmmcache.h>
+#include <kernel/mm.h>
 #include <kernel/init.h>
 
 #define RANGE_TOP(x) (void *)((uintptr_t)x->start + x->size)
@@ -175,7 +175,7 @@ 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(mm_get_page(physical));
+				mm_cache_make_dirty(mm_get_page(physical));
 				VOP_UNLOCK(range->vnode);
 				mm_release_page(physical);
 			} else {
@@ -222,7 +222,7 @@ static void changemmurange(vmmrange_t *range, void *base, size_t size, mmuflags_
 			// it won't be marked dirty upon a vmm_unmap after this
 			page_t *page = mm_get_page(physical);
 			VOP_LOCK(range->vnode);
-			vmmcache_makedirty(page);
+			mm_cache_make_dirty(page);
 			VOP_UNLOCK(range->vnode);
 		}
 
@@ -554,7 +554,7 @@ bool vmm_pagefault(void *addr, bool user, int actions) {
 			} else {
 				// cacheable vnode
 				page_t *res = NULL;
-				int error = vmmcache_getpage(range->vnode, range->offset + mapoffset, &res);
+				int error = mm_cache_get_page(range->vnode, range->offset + mapoffset, &res);
 
 				if (error == ENXIO || error == ENOMEM)  {
 					if (error == ENOMEM)
@@ -563,7 +563,7 @@ bool vmm_pagefault(void *addr, bool user, int actions) {
 					signal_signalthread(current_thread(), SIGBUS, true);
 					status = true;
 				} else if (error) {
-					printf("vmm: error on vmmcache_getpage(): %d\n", error);
+					printf("vmm: error on mm_cache_get_page(): %d\n", error);
 					status = false;
 				} else {
 					status = arch_mmu_map(current_vmm_context()->pagetable, mm_get_page_address(res), addr, range->mmuflags & ~ARCH_MMU_FLAGS_WRITE);
@@ -617,7 +617,7 @@ 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(mm_get_page(oldphys));
+				mm_cache_make_dirty(mm_get_page(oldphys));
 				VOP_UNLOCK(range->vnode);
 			}
 

kernel-src/sys/syscalls/sync.c

@@ -1,9 +1,9 @@
 #include <kernel/syscalls.h>
-#include <kernel/vmmcache.h>
+#include <kernel/mm.h>
 
 syscallret_t syscall_sync(context_t *) {
 	syscallret_t ret = {0};
-	vmmcache_sync();
+	mm_cache_sync();
 	return ret;
 }
 

kernel-src/sys/syscalls/sysinfo.c

@@ -1,7 +1,7 @@
 #include <kernel/syscalls.h>
 #include <arch/cpu.h>
 #include <kernel/page.h>
-#include <kernel/vmmcache.h>
+#include <kernel/mm.h>
 #include <kernel/proc.h>
 
 typedef struct {
@@ -33,7 +33,7 @@ syscallret_t syscall_sysinfo(context_t *, sysinfo_t *usysinfo) {
 		.totalram = total_pages,
 		.freeram = free_pages,
 		.sharedram = 0,
-		.bufferram = vmmcache_cachedpages,
+		.bufferram = mm_cache_cached_pages,
 		.totalswap = 0,
 		.freeswap = 0,
 		.procs = proc_get_count(),