diff --git a/headers/private/kernel/file_cache.h b/headers/private/kernel/file_cache.h index ae6a99fb58..f24ad2cb7a 100644 --- a/headers/private/kernel/file_cache.h +++ b/headers/private/kernel/file_cache.h @@ -37,9 +37,9 @@ struct cache_module_info { extern "C" { #endif -extern void cache_node_opened(struct vnode *vnode, int32 fdType, vm_cache *cache, +extern void cache_node_opened(struct vnode *vnode, int32 fdType, VMCache *cache, dev_t mountID, ino_t parentID, ino_t vnodeID, const char *name); -extern void cache_node_closed(struct vnode *vnode, int32 fdType, vm_cache *cache, +extern void cache_node_closed(struct vnode *vnode, int32 fdType, VMCache *cache, dev_t mountID, ino_t vnodeID); extern void cache_node_launched(size_t argCount, char * const *args); extern void cache_prefetch_vnode(struct vnode *vnode, off_t offset, size_t size); diff --git a/headers/private/kernel/vm_types.h b/headers/private/kernel/vm_types.h index ce1bd002c8..25e60d51f8 100644 --- a/headers/private/kernel/vm_types.h +++ b/headers/private/kernel/vm_types.h @@ -267,12 +267,9 @@ private: mutex fLock; }; -typedef VMCache vm_cache; - // TODO: Remove! - #if DEBUG_CACHE_LIST -extern vm_cache* gDebugCacheList; +extern VMCache* gDebugCacheList; #endif diff --git a/src/system/kernel/cache/file_cache.cpp b/src/system/kernel/cache/file_cache.cpp index e4aa327f98..ab9f91811b 100644 --- a/src/system/kernel/cache/file_cache.cpp +++ b/src/system/kernel/cache/file_cache.cpp @@ -43,7 +43,7 @@ #define LAST_ACCESSES 3 struct file_cache_ref { - vm_cache *cache; + VMCache *cache; struct vnode *vnode; off_t last_access[LAST_ACCESSES]; // TODO: it would probably be enough to only store the least @@ -286,7 +286,7 @@ static void reserve_pages(file_cache_ref* ref, size_t reservePages, bool isWrite) { if (low_resource_state(B_KERNEL_RESOURCE_PAGES) != B_NO_LOW_RESOURCE) { - vm_cache* cache = ref->cache; + VMCache* cache = ref->cache; cache->Lock(); if (list_is_empty(&cache->consumers) && cache->areas == NULL @@ -374,7 +374,7 @@ read_into_cache(file_cache_ref* ref, void* cookie, off_t offset, TRACE(("read_into_cache(offset = %Ld, pageOffset = %ld, buffer = %#lx, " "bufferSize = %lu\n", offset, pageOffset, buffer, bufferSize)); - vm_cache* cache = ref->cache; + VMCache* cache = ref->cache; // TODO: We're using way too much stack! Rather allocate a sufficiently // large chunk on the heap. @@ -720,7 +720,7 @@ cache_io(void* _cacheRef, void* cookie, off_t offset, addr_t buffer, panic("cache_io() called with NULL ref!\n"); file_cache_ref* ref = (file_cache_ref*)_cacheRef; - vm_cache* cache = ref->cache; + VMCache* cache = ref->cache; off_t fileSize = cache->virtual_end; bool useBuffer = buffer != 0; @@ -945,7 +945,7 @@ cache_prefetch_vnode(struct vnode* vnode, off_t offset, size_t size) if (size == 0) return; - vm_cache* cache; + VMCache* cache; if (vfs_get_vnode_cache(vnode, &cache, false) != B_OK) return; @@ -1036,7 +1036,7 @@ cache_prefetch(dev_t mountID, ino_t vnodeID, off_t offset, size_t size) extern "C" void -cache_node_opened(struct vnode* vnode, int32 fdType, vm_cache* cache, +cache_node_opened(struct vnode* vnode, int32 fdType, VMCache* cache, dev_t mountID, ino_t parentID, ino_t vnodeID, const char* name) { if (sCacheModule == NULL || sCacheModule->node_opened == NULL) @@ -1055,7 +1055,7 @@ cache_node_opened(struct vnode* vnode, int32 fdType, vm_cache* cache, extern "C" void -cache_node_closed(struct vnode* vnode, int32 fdType, vm_cache* cache, +cache_node_closed(struct vnode* vnode, int32 fdType, VMCache* cache, dev_t mountID, ino_t vnodeID) { if (sCacheModule == NULL || sCacheModule->node_closed == NULL) @@ -1118,7 +1118,7 @@ file_cache_create(dev_t mountID, ino_t vnodeID, off_t size) ref->last_access_index = 0; ref->disabled_count = 0; - // TODO: delay vm_cache creation until data is + // TODO: delay VMCache creation until data is // requested/written for the first time? Listing lots of // files in Tracker (and elsewhere) could be slowed down. // Since the file_cache_ref itself doesn't have a lock, diff --git a/src/system/kernel/fs/vfs.cpp b/src/system/kernel/fs/vfs.cpp index 38ffdc4cc5..2da1c37c7c 100644 --- a/src/system/kernel/fs/vfs.cpp +++ b/src/system/kernel/fs/vfs.cpp @@ -269,7 +269,7 @@ private: struct vnode : fs_vnode, DoublyLinkedListLinkImpl { struct vnode* next; - vm_cache* cache; + VMCache* cache; dev_t device; list_link unused_link; ino_t id; @@ -1111,7 +1111,7 @@ free_vnode(struct vnode* vnode, bool reenter) hash_remove(sVnodeTable, vnode); mutex_unlock(&sVnodeMutex); - // if we have a vm_cache attached, remove it + // if we have a VMCache attached, remove it if (vnode->cache) vnode->cache->ReleaseRef(); @@ -4459,13 +4459,13 @@ vfs_write_pages(struct vnode* vnode, void* cookie, off_t pos, const iovec* vecs, } -/*! Gets the vnode's vm_cache object. If it didn't have one, it will be +/*! Gets the vnode's VMCache object. If it didn't have one, it will be created if \a allocate is \c true. In case it's successful, it will also grab a reference to the cache it returns. */ extern "C" status_t -vfs_get_vnode_cache(struct vnode* vnode, vm_cache** _cache, bool allocate) +vfs_get_vnode_cache(struct vnode* vnode, VMCache** _cache, bool allocate) { if (vnode->cache != NULL) { vnode->cache->AcquireRef(); diff --git a/src/system/kernel/vm/vm.cpp b/src/system/kernel/vm/vm.cpp index d0f89d1fb8..3359820585 100644 --- a/src/system/kernel/vm/vm.cpp +++ b/src/system/kernel/vm/vm.cpp @@ -128,7 +128,7 @@ public: VMAddressSpace** _space = NULL); status_t AddAreaCacheAndLock(area_id areaID, bool writeLockThisOne, - bool writeLockOthers, VMArea*& _area, vm_cache** _cache = NULL); + bool writeLockOthers, VMArea*& _area, VMCache** _cache = NULL); status_t Lock(); void Unlock(); @@ -158,33 +158,33 @@ private: class AreaCacheLocking { public: - inline bool Lock(vm_cache* lockable) + inline bool Lock(VMCache* lockable) { return false; } - inline void Unlock(vm_cache* lockable) + inline void Unlock(VMCache* lockable) { vm_area_put_locked_cache(lockable); } }; -class AreaCacheLocker : public AutoLocker { +class AreaCacheLocker : public AutoLocker { public: - inline AreaCacheLocker(vm_cache* cache = NULL) - : AutoLocker(cache, true) + inline AreaCacheLocker(VMCache* cache = NULL) + : AutoLocker(cache, true) { } inline AreaCacheLocker(VMArea* area) - : AutoLocker() + : AutoLocker() { SetTo(area); } inline void SetTo(VMArea* area) { - return AutoLocker::SetTo( + return AutoLocker::SetTo( area != NULL ? vm_area_get_locked_cache(area) : NULL, true, true); } }; @@ -205,7 +205,7 @@ static uint32 sPageFaults; #if DEBUG_CACHE_LIST struct cache_info { - vm_cache* cache; + VMCache* cache; addr_t page_count; addr_t committed; }; @@ -222,7 +222,7 @@ static VMAddressSpace* get_address_space_by_area_id(area_id id); static status_t vm_soft_fault(VMAddressSpace* addressSpace, addr_t address, bool isWrite, bool isUser); static status_t map_backing_store(VMAddressSpace* addressSpace, - vm_cache* cache, void** _virtualAddress, off_t offset, addr_t size, + VMCache* cache, void** _virtualAddress, off_t offset, addr_t size, uint32 addressSpec, int wiring, int protection, int mapping, VMArea** _area, const char* areaName, bool unmapAddressRange, bool kernel); @@ -673,7 +673,7 @@ MultiAddressSpaceLocker::Unlock() status_t MultiAddressSpaceLocker::AddAreaCacheAndLock(area_id areaID, bool writeLockThisOne, bool writeLockOthers, VMArea*& _area, - vm_cache** _cache) + VMCache** _cache) { // remember the original state int originalCount = fCount; @@ -687,7 +687,7 @@ MultiAddressSpaceLocker::AddAreaCacheAndLock(area_id areaID, ArrayDeleter _(originalItems); // get the cache - vm_cache* cache; + VMCache* cache; VMArea* area; status_t error; { @@ -732,7 +732,7 @@ MultiAddressSpaceLocker::AddAreaCacheAndLock(area_id areaID, } // lock the cache - vm_cache* oldCache = cache; + VMCache* oldCache = cache; cache = vm_area_get_locked_cache(area); // If neither the area's cache has changed nor its area list we're @@ -1451,7 +1451,7 @@ cut_area(VMAddressSpace* addressSpace, VMArea* area, addr_t address, } AreaCacheLocker cacheLocker(area); - vm_cache* cache = area->cache; + VMCache* cache = area->cache; // Cut the end only? if (areaLast <= lastAddress) { @@ -1614,7 +1614,7 @@ unmap_address_range(VMAddressSpace* addressSpace, addr_t address, addr_t size, Note, that in case of error your cache will be temporarily unlocked. */ static status_t -map_backing_store(VMAddressSpace* addressSpace, vm_cache* cache, +map_backing_store(VMAddressSpace* addressSpace, VMCache* cache, void** _virtualAddress, off_t offset, addr_t size, uint32 addressSpec, int wiring, int protection, int mapping, VMArea** _area, const char* areaName, bool unmapAddressRange, bool kernel) @@ -1634,9 +1634,9 @@ map_backing_store(VMAddressSpace* addressSpace, vm_cache* cache, // if this is a private map, we need to create a new cache // to handle the private copies of pages as they are written to - vm_cache* sourceCache = cache; + VMCache* sourceCache = cache; if (mapping == REGION_PRIVATE_MAP) { - vm_cache* newCache; + VMCache* newCache; // create an anonymous cache status = VMCacheFactory::CreateAnonymousCache(newCache, @@ -1739,7 +1739,7 @@ vm_block_address_range(const char* name, void* address, addr_t size) VMAddressSpace* addressSpace = locker.AddressSpace(); // create an anonymous cache - vm_cache* cache; + VMCache* cache; status = VMCacheFactory::CreateAnonymousCache(cache, false, 0, 0, false); if (status != B_OK) return status; @@ -1853,7 +1853,7 @@ vm_create_anonymous_area(team_id team, const char* name, void** address, addr_t physicalAddress, uint32 flags, bool kernel) { VMArea* area; - vm_cache* cache; + VMCache* cache; vm_page* page = NULL; bool isStack = (protection & B_STACK_AREA) != 0; page_num_t guardPages; @@ -2182,7 +2182,7 @@ vm_map_physical_memory(team_id team, const char* name, void** _address, uint32 addressSpec, addr_t size, uint32 protection, addr_t physicalAddress) { VMArea* area; - vm_cache* cache; + VMCache* cache; addr_t mapOffset; TRACE(("vm_map_physical_memory(aspace = %ld, \"%s\", virtual = %p, " @@ -2295,7 +2295,7 @@ vm_map_physical_memory_vecs(team_id team, const char* name, void** _address, } // create a device cache - vm_cache* cache; + VMCache* cache; status_t result = VMCacheFactory::CreateDeviceCache(cache, (addr_t)vecs[0].iov_base); if (result != B_OK) @@ -2360,7 +2360,7 @@ vm_create_null_area(team_id team, const char* name, void** address, uint32 addressSpec, addr_t size) { VMArea* area; - vm_cache* cache; + VMCache* cache; status_t status; AddressSpaceWriteLocker locker(team); @@ -2523,7 +2523,7 @@ _vm_map_file(team_id team, const char* name, void** _address, return B_BAD_TEAM_ID; // TODO: this only works for file systems that use the file cache - vm_cache* cache; + VMCache* cache; status = vfs_get_vnode_cache(vnode, &cache, false); if (status < B_OK) return status; @@ -2573,13 +2573,13 @@ vm_map_file(team_id aid, const char* name, void** address, uint32 addressSpec, } -vm_cache* +VMCache* vm_area_get_locked_cache(VMArea* area) { mutex_lock(&sAreaCacheLock); while (true) { - vm_cache* cache = area->cache; + VMCache* cache = area->cache; if (!cache->SwitchLock(&sAreaCacheLock)) { // cache has been deleted @@ -2602,7 +2602,7 @@ vm_area_get_locked_cache(VMArea* area) void -vm_area_put_locked_cache(vm_cache* cache) +vm_area_put_locked_cache(VMCache* cache) { cache->ReleaseRefAndUnlock(); } @@ -2655,7 +2655,7 @@ vm_clone_area(team_id team, const char* name, void** address, if (!kernel && (sourceArea->protection & B_KERNEL_AREA) != 0) return B_NOT_ALLOWED; - vm_cache* cache = vm_area_get_locked_cache(sourceArea); + VMCache* cache = vm_area_get_locked_cache(sourceArea); // TODO: for now, B_USER_CLONEABLE is disabled, until all drivers // have been adapted. Maybe it should be part of the kernel settings, @@ -2830,9 +2830,9 @@ vm_delete_area(team_id team, area_id id, bool kernel) - All of the cache's areas' address spaces must be read locked. */ static status_t -vm_copy_on_write_area(vm_cache* lowerCache) +vm_copy_on_write_area(VMCache* lowerCache) { - vm_cache* upperCache; + VMCache* upperCache; TRACE(("vm_copy_on_write_area(cache = %p)\n", lowerCache)); @@ -2909,7 +2909,7 @@ vm_copy_area(team_id team, const char* name, void** _address, // the source cache, and the cache itself. MultiAddressSpaceLocker locker; VMAddressSpace* targetAddressSpace; - vm_cache* cache; + VMCache* cache; VMArea* source; status_t status = locker.AddTeam(team, true, &targetAddressSpace); if (status == B_OK) { @@ -2962,7 +2962,7 @@ vm_copy_area(team_id team, const char* name, void** _address, //! You need to hold the cache lock when calling this function static int32 -count_writable_areas(vm_cache* cache, VMArea* ignoreArea) +count_writable_areas(VMCache* cache, VMArea* ignoreArea) { struct VMArea* area = cache->areas; uint32 count = 0; @@ -2989,7 +2989,7 @@ vm_set_area_protection(team_id team, area_id areaID, uint32 newProtection, // lock address spaces and cache MultiAddressSpaceLocker locker; - vm_cache* cache; + VMCache* cache; VMArea* area; status_t status = locker.AddAreaCacheAndLock(areaID, true, false, area, &cache); @@ -3620,8 +3620,8 @@ display_mem(int argc, char** argv) static void -dump_cache_tree_recursively(vm_cache* cache, int level, - vm_cache* highlightCache) +dump_cache_tree_recursively(VMCache* cache, int level, + VMCache* highlightCache) { // print this cache for (int i = 0; i < level; i++) @@ -3632,8 +3632,8 @@ dump_cache_tree_recursively(vm_cache* cache, int level, kprintf("%p\n", cache); // recursively print its consumers - vm_cache* consumer = NULL; - while ((consumer = (vm_cache*)list_get_next_item(&cache->consumers, + VMCache* consumer = NULL; + while ((consumer = (VMCache*)list_get_next_item(&cache->consumers, consumer)) != NULL) { dump_cache_tree_recursively(consumer, level + 1, highlightCache); } @@ -3652,8 +3652,8 @@ dump_cache_tree(int argc, char** argv) if (address == 0) return 0; - vm_cache* cache = (vm_cache*)address; - vm_cache* root = cache; + VMCache* cache = (VMCache*)address; + VMCache* root = cache; // find the root cache (the transitive source) while (root->source != NULL) @@ -3687,15 +3687,15 @@ cache_type_to_string(int32 type) #if DEBUG_CACHE_LIST static void -update_cache_info_recursively(vm_cache* cache, cache_info& info) +update_cache_info_recursively(VMCache* cache, cache_info& info) { info.page_count += cache->page_count; if (cache->type == CACHE_TYPE_RAM) info.committed += cache->committed_size; // recurse - vm_cache* consumer = NULL; - while ((consumer = (vm_cache*)list_get_next_item(&cache->consumers, + VMCache* consumer = NULL; + while ((consumer = (VMCache*)list_get_next_item(&cache->consumers, consumer)) != NULL) { update_cache_info_recursively(consumer, info); } @@ -3725,7 +3725,7 @@ cache_info_compare_committed(const void* _a, const void* _b) static void -dump_caches_recursively(vm_cache* cache, cache_info& info, int level) +dump_caches_recursively(VMCache* cache, cache_info& info, int level) { for (int i = 0; i < level; i++) kprintf(" "); @@ -3759,8 +3759,8 @@ dump_caches_recursively(vm_cache* cache, cache_info& info, int level) kputs("\n"); // recurse - vm_cache* consumer = NULL; - while ((consumer = (vm_cache*)list_get_next_item(&cache->consumers, + VMCache* consumer = NULL; + while ((consumer = (VMCache*)list_get_next_item(&cache->consumers, consumer)) != NULL) { dump_caches_recursively(consumer, info, level + 1); } @@ -3791,7 +3791,7 @@ dump_caches(int argc, char** argv) off_t totalCommitted = 0; page_num_t totalPages = 0; - vm_cache* cache = gDebugCacheList; + VMCache* cache = gDebugCacheList; while (cache) { totalCount++; if (cache->source == NULL) { @@ -3840,7 +3840,7 @@ dump_caches(int argc, char** argv) static int dump_cache(int argc, char** argv) { - vm_cache* cache; + VMCache* cache; bool showPages = false; int i = 1; @@ -3868,7 +3868,7 @@ dump_cache(int argc, char** argv) if (address == 0) return 0; - cache = (vm_cache*)address; + cache = (VMCache*)address; kprintf("CACHE %p:\n", cache); kprintf(" ref_count: %ld\n", cache->RefCount()); @@ -3892,8 +3892,8 @@ dump_cache(int argc, char** argv) } kprintf(" consumers:\n"); - vm_cache* consumer = NULL; - while ((consumer = (vm_cache*)list_get_next_item(&cache->consumers, + VMCache* consumer = NULL; + while ((consumer = (VMCache*)list_get_next_item(&cache->consumers, consumer)) != NULL) { kprintf("\t%p\n", consumer); } @@ -4545,11 +4545,11 @@ vm_init(kernel_args* args) add_debugger_command("areas", &dump_area_list, "Dump a list of all areas"); add_debugger_command("area", &dump_area, "Dump info about a particular area"); - add_debugger_command("cache", &dump_cache, "Dump vm_cache"); - add_debugger_command("cache_tree", &dump_cache_tree, "Dump vm_cache tree"); + add_debugger_command("cache", &dump_cache, "Dump VMCache"); + add_debugger_command("cache_tree", &dump_cache_tree, "Dump VMCache tree"); #if DEBUG_CACHE_LIST add_debugger_command_etc("caches", &dump_caches, - "List all vm_cache trees", + "List all VMCache trees", "[ \"-c\" ]\n" "All cache trees are listed sorted in decreasing order by number of\n" "used pages or, if \"-c\" is specified, by size of committed memory.\n", @@ -4845,7 +4845,7 @@ struct PageFaultContext { VMCacheChainLocker cacheChainLocker; vm_translation_map* map; - vm_cache* topCache; + VMCache* topCache; off_t cacheOffset; bool isWrite; @@ -4901,8 +4901,8 @@ struct PageFaultContext { static inline status_t fault_get_page(PageFaultContext& context) { - vm_cache* cache = context.topCache; - vm_cache* lastCache = NULL; + VMCache* cache = context.topCache; + VMCache* lastCache = NULL; vm_page* page = NULL; while (cache != NULL) { @@ -5387,7 +5387,7 @@ fill_area_info(struct VMArea* area, area_info* info, size_t size) info->out_count = 0; // TODO: retrieve real values here! - vm_cache* cache = vm_area_get_locked_cache(area); + VMCache* cache = vm_area_get_locked_cache(area); // Note, this is a simplification; the cache could be larger than this area info->ram_size = cache->page_count * B_PAGE_SIZE; @@ -5434,7 +5434,7 @@ vm_resize_area(area_id areaID, size_t newSize, bool kernel) // lock all affected address spaces and the cache VMArea* area; - vm_cache* cache; + VMCache* cache; MultiAddressSpaceLocker locker; status_t status = locker.AddAreaCacheAndLock(areaID, true, true, area, @@ -6633,7 +6633,7 @@ _user_sync_memory(void* _address, size_t size, int flags) AreaCacheLocker cacheLocker(area); if (!cacheLocker) return B_BAD_VALUE; - vm_cache* cache = area->cache; + VMCache* cache = area->cache; locker.Unlock(); diff --git a/src/system/kernel/vm/vm_cache.cpp b/src/system/kernel/vm/vm_cache.cpp index f90d070f01..60d9b17888 100644 --- a/src/system/kernel/vm/vm_cache.cpp +++ b/src/system/kernel/vm/vm_cache.cpp @@ -40,7 +40,7 @@ #if DEBUG_CACHE_LIST VMCache* gDebugCacheList; #endif -static mutex sCacheListLock = MUTEX_INITIALIZER("global vm_cache list"); +static mutex sCacheListLock = MUTEX_INITIALIZER("global VMCache list"); // The lock is also needed when the debug feature is disabled. @@ -323,7 +323,7 @@ vm_cache_acquire_locked_page_cache(vm_page* page, bool dontWait) mutex_lock(&sCacheListLock); while (dontWait) { - vm_cache* cache = page->cache; + VMCache* cache = page->cache; if (cache == NULL || !cache->TryLock()) { mutex_unlock(&sCacheListLock); return NULL; @@ -340,7 +340,7 @@ vm_cache_acquire_locked_page_cache(vm_page* page, bool dontWait) } while (true) { - vm_cache* cache = page->cache; + VMCache* cache = page->cache; if (cache == NULL) { mutex_unlock(&sCacheListLock); return NULL; @@ -392,7 +392,7 @@ VMCache::~VMCache() status_t VMCache::Init(uint32 cacheType) { - mutex_init(&fLock, "vm_cache"); + mutex_init(&fLock, "VMCache"); VMCache dummyCache; list_init_etc(&consumers, offset_of_member(dummyCache, consumer_link)); areas = NULL; diff --git a/src/system/kernel/vm/vm_daemons.cpp b/src/system/kernel/vm/vm_daemons.cpp index a640821f25..cff212ea8b 100644 --- a/src/system/kernel/vm/vm_daemons.cpp +++ b/src/system/kernel/vm/vm_daemons.cpp @@ -81,7 +81,7 @@ PageCacheLocker::Lock(vm_page* page, bool dontWait) return false; // Grab a reference to this cache. - vm_cache* cache = vm_cache_acquire_locked_page_cache(page, dontWait); + VMCache* cache = vm_cache_acquire_locked_page_cache(page, dontWait); if (cache == NULL) return false; diff --git a/src/system/kernel/vm/vm_page.cpp b/src/system/kernel/vm/vm_page.cpp index b70b7a94ba..0542705ee2 100644 --- a/src/system/kernel/vm/vm_page.cpp +++ b/src/system/kernel/vm/vm_page.cpp @@ -1437,7 +1437,7 @@ page_writer(void* /*unused*/) if (!cacheLocker.IsLocked()) continue; - vm_cache *cache = page->cache; + VMCache *cache = page->cache; // Don't write back wired (locked) pages and don't write RAM pages // until we're low on pages. Also avoid writing temporary pages that @@ -1696,7 +1696,7 @@ steal_pages(vm_page **pages, size_t count, bool reserve) /*! Writes a range of modified pages of a cache to disk. - You need to hold the vm_cache lock when calling this function. + You need to hold the VMCache lock when calling this function. Note that the cache lock is released in this function. \param cache The cache. \param firstPage Offset (in page size units) of the first page in the range. @@ -1810,11 +1810,11 @@ vm_page_write_modified_page_range(struct VMCache* cache, uint32 firstPage, } -/*! You need to hold the vm_cache lock when calling this function. +/*! You need to hold the VMCache lock when calling this function. Note that the cache lock is released in this function. */ status_t -vm_page_write_modified_pages(vm_cache *cache) +vm_page_write_modified_pages(VMCache *cache) { return vm_page_write_modified_page_range(cache, 0, (cache->virtual_end + B_PAGE_SIZE - 1) >> PAGE_SHIFT); @@ -2364,7 +2364,7 @@ vm_lookup_page(addr_t pageNumber) if the page does not equal PAGE_STATE_MODIFIED. */ void -vm_page_free(vm_cache *cache, vm_page *page) +vm_page_free(VMCache *cache, vm_page *page) { MutexLocker _(sPageLock);