From d890eb5fb2da6e2c1bae544a046faee59570754c Mon Sep 17 00:00:00 2001 From: Matheus Date: Wed, 1 Jul 2026 12:22:11 -0300 Subject: [PATCH] mm: vmmcache -> mm_cache --- kernel-src/arch/x86-64/syscalllog.c | 6 ++--- kernel-src/fs/devfs.c | 6 ++--- kernel-src/fs/ext2.c | 10 ++++---- kernel-src/fs/fat/fatfs.c | 14 +++++------ kernel-src/fs/tmpfs.c | 8 +++---- kernel-src/fs/vfs.c | 22 ++++++++--------- kernel-src/include/kernel/mm.h | 19 +++++++++++++++ kernel-src/include/kernel/vmm.h | 1 - kernel-src/include/kernel/vmmcache.h | 19 --------------- kernel-src/mm/{vmmcache.c => cache.c} | 34 +++++++++++++-------------- kernel-src/mm/page.c | 4 ++-- kernel-src/mm/vmm.c | 12 +++++----- kernel-src/sys/syscalls/sync.c | 4 ++-- kernel-src/sys/syscalls/sysinfo.c | 4 ++-- 14 files changed, 81 insertions(+), 82 deletions(-) create mode 100644 kernel-src/include/kernel/mm.h delete mode 100644 kernel-src/include/kernel/vmmcache.h rename kernel-src/mm/{vmmcache.c => cache.c} (93%) diff --git a/kernel-src/arch/x86-64/syscalllog.c b/kernel-src/arch/x86-64/syscalllog.c index dabeb236..3a20ba7c 100644 --- a/kernel-src/arch/x86-64/syscalllog.c +++ b/kernel-src/arch/x86-64/syscalllog.c @@ -1,7 +1,7 @@ #include #include #include -#include +#include #include #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); diff --git a/kernel-src/fs/devfs.c b/kernel-src/fs/devfs.c index 7d13a72f..e71dd3f3 100644 --- a/kernel-src/fs/devfs.c +++ b/kernel-src/fs/devfs.c @@ -7,7 +7,7 @@ #include #include #include -#include +#include #include #include @@ -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) { - return vmmcache_sync(vnode); +static int devfs_sync(vnode_t *) { + return mm_cache_sync(); } // most locking is handled by the devices. diff --git a/kernel-src/fs/ext2.c b/kernel-src/fs/ext2.c index 27f61441..e275a2df 100644 --- a/kernel-src/fs/ext2.c +++ b/kernel-src/fs/ext2.c @@ -9,7 +9,7 @@ #include #include #include -#include +#include #include #include #include @@ -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); diff --git a/kernel-src/fs/fat/fatfs.c b/kernel-src/fs/fat/fatfs.c index 7b59d353..d772ed05 100644 --- a/kernel-src/fs/fat/fatfs.c +++ b/kernel-src/fs/fat/fatfs.c @@ -7,7 +7,7 @@ #include #include #include -#include +#include 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); } diff --git a/kernel-src/fs/tmpfs.c b/kernel-src/fs/tmpfs.c index b87e8da2..4b7941c7 100644 --- a/kernel-src/fs/tmpfs.c +++ b/kernel-src/fs/tmpfs.c @@ -12,7 +12,7 @@ #include #include #include -#include +#include #include #include #include @@ -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); diff --git a/kernel-src/fs/vfs.c b/kernel-src/fs/vfs.c index 657b9a2d..4f994de4 100644 --- a/kernel-src/fs/vfs.c +++ b/kernel-src/fs/vfs.c @@ -7,7 +7,7 @@ #include #include #include -#include +#include #include #include #include @@ -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)); } diff --git a/kernel-src/include/kernel/mm.h b/kernel-src/include/kernel/mm.h new file mode 100644 index 00000000..051dff7d --- /dev/null +++ b/kernel-src/include/kernel/mm.h @@ -0,0 +1,19 @@ +#ifndef _MM_H +#define _MM_H + +#include +#include + +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 diff --git a/kernel-src/include/kernel/vmm.h b/kernel-src/include/kernel/vmm.h index c9e8bec7..2fb3e312 100644 --- a/kernel-src/include/kernel/vmm.h +++ b/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; diff --git a/kernel-src/include/kernel/vmmcache.h b/kernel-src/include/kernel/vmmcache.h deleted file mode 100644 index f2f6903c..00000000 --- a/kernel-src/include/kernel/vmmcache.h +++ /dev/null @@ -1,19 +0,0 @@ -#ifndef _VMMCACHE_H -#define _VMMCACHE_H - -#include -#include - -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 diff --git a/kernel-src/mm/vmmcache.c b/kernel-src/mm/cache.c similarity index 93% rename from kernel-src/mm/vmmcache.c rename to kernel-src/mm/cache.c index 0ff15f93..d55edd0f 100644 --- a/kernel-src/mm/vmmcache.c +++ b/kernel-src/mm/cache.c @@ -1,4 +1,4 @@ -#include +#include #include #include #include @@ -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); diff --git a/kernel-src/mm/page.c b/kernel-src/mm/page.c index 15d031e4..1b034e4e 100644 --- a/kernel-src/mm/page.c +++ b/kernel-src/mm/page.c @@ -5,7 +5,7 @@ #include #include #include -#include +#include #include 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; diff --git a/kernel-src/mm/vmm.c b/kernel-src/mm/vmm.c index d94b2ada..c8a46f7c 100644 --- a/kernel-src/mm/vmm.c +++ b/kernel-src/mm/vmm.c @@ -6,7 +6,7 @@ #include #include #include -#include +#include #include #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); } diff --git a/kernel-src/sys/syscalls/sync.c b/kernel-src/sys/syscalls/sync.c index 877af7f5..1c2fda32 100644 --- a/kernel-src/sys/syscalls/sync.c +++ b/kernel-src/sys/syscalls/sync.c @@ -1,9 +1,9 @@ #include -#include +#include syscallret_t syscall_sync(context_t *) { syscallret_t ret = {0}; - vmmcache_sync(); + mm_cache_sync(); return ret; } diff --git a/kernel-src/sys/syscalls/sysinfo.c b/kernel-src/sys/syscalls/sysinfo.c index 9d42bfd3..db42a075 100644 --- a/kernel-src/sys/syscalls/sysinfo.c +++ b/kernel-src/sys/syscalls/sysinfo.c @@ -1,7 +1,7 @@ #include #include #include -#include +#include #include 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(),