Changeset 26250

Timestamp:

07/04/08 12:35:50 (5 months ago)

Author:

bonefish

Message:

* Renamed VMCache::virtual_size to virtual_end to avoid confusion.
* Added cache type argument to VMCache::Init(). The type is no longer

set by the one creating the cache.

* VMCache::Commit() is passed the actual size to be committed, now, not

virtual_end.

* Added VMCache::Delete(), moved the cleanup code from the destructor

there, and used it in all places instead of the destructor.

* Added VMCache::MergeStore(). It is called when a cache is merged with

its only consumer.

* Implemented VMAnonymousCache::MergeStore(). The remaining cache takes

over the memory commitment of its source that is going to be deleted.
This does at least improve the situation, that after fork() + exec*()
the parent's RAM areas caches don't have any memory commitment
anymore. We definitely need a more consistent commitment strategy,
particularly for CoW.

* vm_resize_area(): when growing the area, resize the cache first, since

that can fail. Resize the cache back on error.

Location:

haiku/branches/developer/bonefish/vm

Files:

• headers/private/kernel/vm_types.h (modified) (3 diffs)
• src/system/kernel/cache/file_cache.cpp (modified) (6 diffs)
• src/system/kernel/cache/vnode_store.cpp (modified) (1 diff)
• src/system/kernel/fs/vfs.cpp (modified) (1 diff)
• src/system/kernel/vm/vm.cpp (modified) (16 diffs)
• src/system/kernel/vm/vm_cache.cpp (modified) (13 diffs)
• src/system/kernel/vm/vm_page.cpp (modified) (1 diff)
• src/system/kernel/vm/vm_store_anonymous_noswap.cpp (modified) (3 diffs)
• src/system/kernel/vm/vm_store_anonymous_noswap.h (modified) (1 diff)
• src/system/kernel/vm/vm_store_device.cpp (modified) (1 diff)
• src/system/kernel/vm/vm_store_null.cpp (modified) (1 diff)
• src/system/kernel/vm/vm_store_null.h (modified) (1 diff)

haiku/branches/developer/bonefish/vm/headers/private/kernel/vm_types.h

@@ -172 +172 @@
         virtual ~VMCache();
 
-        status_t Init();
+        status_t Init(uint32 cacheType);
+
+        virtual void            Delete();
 
         // backing store operations
@@ -184 +186 @@
 
         virtual status_t        Fault(struct vm_address_space *aspace, off_t offset);
+
+        virtual void            MergeStore(VMCache* source);
 
         virtual status_t        AcquireUnreferencedStoreRef();
@@ -199 +203 @@
         VMCache                         *source;
         off_t                           virtual_base;
-        off_t                           virtual_size;
-                // the size is absolute, and independent from virtual_base
+        off_t                           virtual_end;
         off_t                           committed_size;
                 // TODO: Remove!

haiku/branches/developer/bonefish/vm/src/system/kernel/cache/file_cache.cpp

@@ -374 +374 @@
                         + vecs[vecCount - 1].iov_len - B_PAGE_SIZE;
 
-                if (offset + pageOffset + bufferSize == ref->cache->virtual_size) {
+                if (offset + pageOffset + bufferSize == ref->cache->virtual_end) {
                         // the space in the page after this write action needs to be cleaned
                         memset((void *)(last + lastPageOffset), 0,
@@ -552 +552 @@
         file_cache_ref *ref = (file_cache_ref *)_cacheRef;
         vm_cache *cache = ref->cache;
-        off_t fileSize = cache->virtual_size;
+        off_t fileSize = cache->virtual_end;
         bool useBuffer = buffer != 0;
 
@@ -768 +768 @@
         file_cache_ref *ref = (struct file_cache_ref *)
                 ((vnode_store *)cache->store)->file_cache_ref;
-        off_t fileSize = cache->virtual_size;
+        off_t fileSize = cache->virtual_end;
 
         if (size > fileSize)
@@ -860 +860 @@
                 file_cache_ref *ref = ((VMVnodeCache*)cache)->FileCacheRef();
                 if (ref != NULL)
-                        size = cache->virtual_size;
+                        size = cache->virtual_end;
         }
 
@@ -950 +950 @@
                 goto err1;
 
-        ref->cache->virtual_size = size;
+        ref->cache->virtual_end = size;
         ((VMVnodeCache*)ref->cache)->SetFileCacheRef(ref);
         return ref;
@@ -987 +987 @@
         MutexLocker _(ref->cache->lock);
 
-        off_t offset = ref->cache->virtual_size;
+        off_t offset = ref->cache->virtual_end;
         off_t size = newSize;
         if (offset > newSize) {

haiku/branches/developer/bonefish/vm/src/system/kernel/cache/vnode_store.cpp

@@ -17 +17 @@
 VMVnodeCache::Init(struct vnode *vnode)
 {
-        status_t error = VMCache::Init();
+        status_t error = VMCache::Init(CACHE_TYPE_VNODE);
         if (error != B_OK)
                 return error;

haiku/branches/developer/bonefish/vm/src/system/kernel/fs/vfs.cpp

@@ -2795 +2795 @@
 
                 kprintf("%p%4ld%10Ld %p %8Ld%8ld\n", vnode, vnode->device, vnode->id,
-                        vnode->cache, (vnode->cache->virtual_size + B_PAGE_SIZE - 1)
+                        vnode->cache, (vnode->cache->virtual_end + B_PAGE_SIZE - 1)
                                 / B_PAGE_SIZE, vnode->cache->page_count);
         }

haiku/branches/developer/bonefish/vm/src/system/kernel/vm/vm.cpp

@@ -1395 +1395 @@
 
                 mutex_lock(&newCache->lock);
-                newCache->type = CACHE_TYPE_RAM;
                 newCache->temporary = 1;
                 newCache->scan_skip = cache->scan_skip;
                 newCache->virtual_base = offset;
-                newCache->virtual_size = offset + size;
+                newCache->virtual_end = offset + size;
 
                 vm_cache_add_consumer_locked(cache, newCache);
@@ -1406 +1405 @@
         }
 
-        status = vm_cache_set_minimal_commitment_locked(cache, offset + size);
+        status = vm_cache_set_minimal_commitment_locked(cache, size);
         if (status != B_OK)
                 goto err2;
@@ -1629 +1628 @@
 
         cache->temporary = 1;
-        cache->type = CACHE_TYPE_RAM;
-        cache->virtual_size = size;
+        cache->virtual_end = size;
 
         switch (wiring) {
@@ -1845 +1843 @@
         // tell the page scanner to skip over this area, it's pages are special
         cache->scan_skip = 1;
-        cache->type = CACHE_TYPE_DEVICE;
-        cache->virtual_size = size;
+        cache->virtual_end = size;
 
         mutex_lock(&cache->lock);
@@ -1919 +1916 @@
         // tell the page scanner to skip over this area, no pages will be mapped here
         cache->scan_skip = 1;
-        cache->type = CACHE_TYPE_NULL;
-        cache->virtual_size = size;
+        cache->virtual_end = size;
 
         mutex_lock(&cache->lock);
@@ -1944 +1940 @@
 */
 status_t
-vm_create_vnode_cache(struct vnode *vnode, struct VMCache **_cache)
-{
-        // create a vnode cache
-        vm_cache* cache;
-        status_t status = VMCacheFactory::CreateVnodeCache(cache, vnode);
-        if (status != B_OK)
-                return status;
-
-        cache->type = CACHE_TYPE_VNODE;
-
-        *_cache = cache;
-        return B_OK;
+vm_create_vnode_cache(struct vnode *vnode, struct VMCache **cache)
+{
+        return VMCacheFactory::CreateVnodeCache(*cache, vnode);
 }
 
@@ -2300 +2287 @@
         mutex_lock(&upperCache->lock);
 
-        upperCache->type = CACHE_TYPE_RAM;
         upperCache->temporary = 1;
         upperCache->scan_skip = lowerCache->scan_skip;
         upperCache->virtual_base = lowerCache->virtual_base;
-        upperCache->virtual_size = lowerCache->virtual_size;
+        upperCache->virtual_end = lowerCache->virtual_end;
 
         // transfer the lower cache areas to the upper cache
@@ -2475 +2461 @@
                                 // into account that really are in this cache.
 
-                                status = cache->Commit(
-                                        cache->virtual_base + cache->page_count * B_PAGE_SIZE);
+                                status = cache->Commit(cache->page_count * B_PAGE_SIZE);
 
                                 // ToDo: we may be able to join with our source cache, if count == 0
@@ -2494 +2479 @@
                         if (cache->source != NULL && cache->temporary) {
                                 // the cache's commitment must contain all possible pages
-                                status = cache->Commit(cache->virtual_size);
+                                status = cache->Commit(cache->virtual_end
+                                        - cache->virtual_base);
                         }
 
@@ -3110 +3096 @@
         kprintf("%p: type: %s, base: %lld, size: %lld, pages: %lu", cache,
                 cache_type_to_string(cache->type), cache->virtual_base,
-                cache->virtual_size, cache->page_count);
+                cache->virtual_end, cache->page_count);
 
         if (level == 0)
@@ -3239 +3225 @@
         kprintf("  type:         %s\n", cache_type_to_string(cache->type));
         kprintf("  virtual_base: 0x%Lx\n", cache->virtual_base);
-        kprintf("  virtual_size: 0x%Lx\n", cache->virtual_size);
+        kprintf("  virtual_end:  0x%Lx\n", cache->virtual_end);
         kprintf("  temporary:    %ld\n", cache->temporary);
         kprintf("  scan_skip:    %ld\n", cache->scan_skip);
@@ -4833 +4819 @@
                 for (vm_area* current = cache->areas; current != NULL;
                                 current = current->cache_next) {
-                        if (current->address_space_next
-                                && current->address_space_next->base <= (current->base
-                                        + newSize)) {
+                        vm_area *next = current->address_space_next;
+                        if (next != NULL && next->base <= (current->base + newSize)) {
                                 // If the area was created inside a reserved area, it can
                                 // also be resized in that area
                                 // ToDo: if there is free space after the reserved area, it could be used as well...
-                                vm_area *next = current->address_space_next;
                                 if (next->id == RESERVED_AREA_ID
                                         && next->cache_offset <= current->base
@@ -4852 +4836 @@
         // Okay, looks good so far, so let's do it
 
+        if (oldSize < newSize) {
+                // Growing the cache can fail, so we do it first.
+                status = vm_cache_resize(cache, newSize);
+                if (status != B_OK)
+                        return status;
+        }
+
         for (vm_area* current = cache->areas; current != NULL;
                         current = current->cache_next) {
-                if (current->address_space_next
-                        && current->address_space_next->base <= (current->base + newSize)) {
-                        vm_area *next = current->address_space_next;
+                vm_area *next = current->address_space_next;
+                if (next != NULL && next->base <= (current->base + newSize)) {
                         if (next->id == RESERVED_AREA_ID
                                 && next->cache_offset <= current->base
@@ -4870 +4860 @@
                                 }
                         } else {
+                                panic("resize situation for area %p has changed although we "
+                                        "should have the address space lock", current);
                                 status = B_ERROR;
                                 break;
@@ -4884 +4876 @@
         }
 
-        if (status == B_OK)
+        // shrinking the cache can't fail, so we do it now
+        if (status == B_OK && newSize < oldSize)
                 status = vm_cache_resize(cache, newSize);
 
@@ -4893 +4886 @@
                         current->size = oldSize;
                 }
+
+                vm_cache_resize(cache, oldSize);
         }
 

haiku/branches/developer/bonefish/vm/src/system/kernel/vm/vm_cache.cpp

@@ -127 +127 @@
                         :
                         VMCacheTraceEntry(cache),
-                        fOldSize(cache->virtual_size),
+                        fOldSize(cache->virtual_end),
                         fSize(size)
                 {
@@ -437 +437 @@
         }
 
+        // merge the backing store
+        consumer->MergeStore(cache);
+
         // The remaining consumer has got a new source.
         if (cache->source != NULL) {
@@ -536 +539 @@
         // delete this cache
 
-        delete cache;
+        cache->Delete();
 }
 
@@ -685 +688 @@
 {
         TRACE(("vm_cache_resize(cache %p, newSize %Ld) old size %Ld\n",
-                cache, newSize, cache->virtual_size));
+                cache, newSize, cache->virtual_end));
         ASSERT_LOCKED_MUTEX(&cache->lock);
 
         T(Resize(cache, newSize));
 
-        status_t status = cache->Commit(newSize);
+        status_t status = cache->Commit(newSize - cache->virtual_base);
         if (status != B_OK)
                 return status;
 
-        uint32 oldPageCount = (uint32)((cache->virtual_size + B_PAGE_SIZE - 1)
+        uint32 oldPageCount = (uint32)((cache->virtual_end + B_PAGE_SIZE - 1)
                 >> PAGE_SHIFT);
         uint32 newPageCount = (uint32)((newSize + B_PAGE_SIZE - 1) >> PAGE_SHIFT);
@@ -732 +735 @@
         }
 
-        cache->virtual_size = newSize;
+        cache->virtual_end = newSize;
         return B_OK;
 }
@@ -848 +851 @@
 
 VMCache::~VMCache()
+{
+        mutex_destroy(&lock);
+}
+
+
+status_t
+VMCache::Init(uint32 cacheType)
+{
+        mutex_init(&lock, "vm_cache");
+        list_init_etc(&consumers, offsetof(VMCache, consumer_link));
+        areas = NULL;
+        ref_count = 1;
+        source = NULL;
+        virtual_base = 0;
+        virtual_end = 0;
+        committed_size = 0;
+        temporary = 0;
+        scan_skip = 0;
+        page_count = 0;
+        busy = false;
+        type = cacheType;
+
+#if DEBUG_CACHE_LIST
+        mutex_lock(&sCacheListLock);
+
+        if (gDebugCacheList)
+                gDebugCacheList->debug_previous = this;
+        debug_previous = NULL;
+        debug_next = gDebugCacheList;
+        gDebugCacheList = this;
+
+        mutex_unlock(&sCacheListLock);
+#endif
+
+        return B_OK;
+}
+
+
+void
+VMCache::Delete()
 {
         if (areas != NULL)
@@ -893 +936 @@
         mutex_unlock(&sCacheListLock);
 
-        mutex_destroy(&lock);
-}
-
-
-status_t
-VMCache::Init()
-{
-        mutex_init(&lock, "vm_cache");
-        list_init_etc(&consumers, offsetof(VMCache, consumer_link));
-        areas = NULL;
-        ref_count = 1;
-        source = NULL;
-        virtual_base = 0;
-        virtual_size = 0;
-        committed_size = 0;
-        temporary = 0;
-        scan_skip = 0;
-        page_count = 0;
-        busy = false;
-
-#if DEBUG_CACHE_LIST
-        mutex_lock(&sCacheListLock);
-
-        if (gDebugCacheList)
-                gDebugCacheList->debug_previous = this;
-        debug_previous = NULL;
-        debug_next = gDebugCacheList;
-        gDebugCacheList = this;
-
-        mutex_unlock(&sCacheListLock);
-#endif
-
-        return B_OK;
+        delete this;
 }
 
@@ -940 +951 @@
 VMCache::HasPage(off_t offset)
 {
-        return offset >= virtual_base && offset <= virtual_size;
+        return offset >= virtual_base && offset <= virtual_end;
 }
 
@@ -964 +975 @@
 {
         return B_BAD_ADDRESS;
+}
+
+
+void
+VMCache::MergeStore(VMCache* source)
+{
 }
 
@@ -1009 +1026 @@
                 numGuardPages);
         if (error != B_OK) {
-                delete cache;
+                cache->Delete();
                 return error;
         }
@@ -1027 +1044 @@
         status_t error = cache->Init(vnode);
         if (error != B_OK) {
-                delete cache;
+                cache->Delete();
                 return error;
         }
@@ -1045 +1062 @@
         status_t error = cache->Init(baseAddress);
         if (error != B_OK) {
-                delete cache;
+                cache->Delete();
                 return error;
         }
@@ -1063 +1080 @@
         status_t error = cache->Init();
         if (error != B_OK) {
-                delete cache;
+                cache->Delete();
                 return error;
         }

haiku/branches/developer/bonefish/vm/src/system/kernel/vm/vm_page.cpp

@@ -1398 +1398 @@
 {
         return vm_page_write_modified_page_range(cache, 0,
-                (cache->virtual_size + B_PAGE_SIZE - 1) >> PAGE_SHIFT, fsReenter);
+                (cache->virtual_end + B_PAGE_SIZE - 1) >> PAGE_SHIFT, fsReenter);
 }
 

haiku/branches/developer/bonefish/vm/src/system/kernel/vm/vm_store_anonymous_noswap.cpp

@@ -44 +44 @@
                 "at %p\n", canOvercommit ? "yes" : "no", numGuardPages, store));
 
-        status_t error = VMCache::Init();
+        status_t error = VMCache::Init(CACHE_TYPE_RAM);
         if (error != B_OK)
                 return error;
@@ -60 +60 @@
 VMAnonymousCache::Commit(off_t size)
 {
-        size -= virtual_base;
-                // anonymous stores don't need to span over their whole source
-
         // if we can overcommit, we don't commit here, but in anonymous_fault()
         if (fCanOvercommit) {
@@ -151 +148 @@
         return B_BAD_HANDLER;
 }
+
+
+void
+VMAnonymousCache::MergeStore(VMCache* source)
+{
+        if (source->type != CACHE_TYPE_RAM) {
+                panic("VMAnonymousCache::MergeStore(): merge with non-RAM cache "
+                        "requested", source);
+                return;
+        }
+
+        // take over the source' committed size
+        committed_size += source->committed_size;
+        source->committed_size = 0;
+
+        off_t actualSize = virtual_end - virtual_base;
+        if (committed_size > actualSize) {
+                vm_unreserve_memory(committed_size - actualSize);
+                committed_size = actualSize;
+        }
+}

haiku/branches/developer/bonefish/vm/src/system/kernel/vm/vm_store_anonymous_noswap.h

@@ -30 +30 @@
         virtual status_t        Fault(struct vm_address_space *aspace, off_t offset);
 
+        virtual void            MergeStore(VMCache* source);
+
 private:
         bool    fCanOvercommit;

haiku/branches/developer/bonefish/vm/src/system/kernel/vm/vm_store_device.cpp

@@ -14 +14 @@
 {
         fBaseAddress = baseAddress;
-        return VMCache::Init();
+        return VMCache::Init(CACHE_TYPE_DEVICE);
 }
 

haiku/branches/developer/bonefish/vm/src/system/kernel/vm/vm_store_null.cpp

@@ -6 +6 @@
 #include "vm_store_null.h"
 
-// TODO: Remove!
+
+status_t
+VMNullCache::Init()
+{
+        return VMCache::Init(CACHE_TYPE_NULL);
+}

haiku/branches/developer/bonefish/vm/src/system/kernel/vm/vm_store_null.h

@@ -14 +14 @@