mirrors/Astral
1
0
Fork 0
mirror of https://github.com/Mathewnd/Astral.git synced 2026-10-27 12:48:22 +00:00
Code Issues Packages Projects Releases Wiki Activity

mm: vmmcache -> mm_cache

Browse Source
This commit is contained in:
Matheus
2026-07-01 12:22:11 -03:00
parent 4d1caa6ede
commit d890eb5fb2
14 changed files with 81 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files
kernel-src/arch/x86-64/syscalllog.c
+3 -3
View File
@@ -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
+3 -3
View File
@@ -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) {
return vmmcache_sync(vnode);
static int devfs_sync(vnode_t *) {
return mm_cache_sync();
}
// most locking is handled by the devices.
kernel-src/fs/ext2.c
+5 -5
View File
@@ -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
View File
@@ -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
+4 -4
View File
@@ -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
+11 -11
View File
@@ -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
+19
View File
@@ -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
-1
View File
@@ -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
-19
View File
@@ -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/vmmcache.c → kernel-src/mm/cache.c
+17 -17
View File
@@ -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
+2 -2
View File
@@ -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 -6
View File
@@ -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
+2 -2
View File
@@ -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
+2 -2
View File
@@ -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(),