foo

core/mem/vmo.c

@@ -5,6 +5,15 @@
 #include <zinnia/vmo.h>
 #include <zinnia/string.h>
 
+void vmo_ref(struct vmo* obj) {
+    refcount_inc(&obj->rc);
+}
+
+void vmo_unref(struct vmo* obj) {
+    if (refcount_dec(&obj->rc))
+        obj->destroy(obj);
+}
+
 errno_t vmo_read(struct vmo* obj, uintptr_t offset, void* buf, size_t len, size_t* actual_read) {
     const size_t page_size = arch_mem_page_size();
     size_t progress = 0;
@@ -104,14 +113,17 @@ static errno_t paged_get_page(struct vmo* vmo, uintptr_t offset_idx, struct page
 
     // Try to find the requested page in the cache.
     struct page_list* iter;
+    spin_lock(&paged->lock);
     list_foreach(iter, &paged->cache, next) {
         if (iter->offset != offset_idx)
             continue;
 
         // We found a cached page!
         *out = iter->value;
+        spin_unlock(&paged->lock);
         return 0;
     }
+    spin_unlock(&paged->lock);
 
     // Get page from out pager if we don't have one already.
     struct page* new_page;
@@ -120,26 +132,57 @@ static errno_t paged_get_page(struct vmo* vmo, uintptr_t offset_idx, struct page
         return status;
 
     struct page_list* entry = mem_alloc(sizeof(struct page_list), 0);
-    if (!entry)
+    if (!entry) {
+        paged->source.put_page(&paged->source, offset_idx, new_page);
         return ENOMEM;
+    }
 
     entry->offset = offset_idx;
     entry->value = new_page;
 
+    spin_lock(&paged->lock);
+    list_foreach(iter, &paged->cache, next) {
+        if (iter->offset != offset_idx)
+            continue;
+
+        *out = iter->value;
+        spin_unlock(&paged->lock);
+        mem_free(entry);
+        paged->source.put_page(&paged->source, offset_idx, new_page);
+        return 0;
+    }
+
     // Add page to the object cache.
     list_insert_head(&paged->cache, entry, next);
+    spin_unlock(&paged->lock);
 
     *out = new_page;
     return 0;
 }
 
+static void paged_destroy(struct vmo* vmo) {
+    struct paged_vmo* paged = containerof(vmo, struct paged_vmo, object);
+
+    struct page_list* iter = list_first(&paged->cache);
+    while (iter) {
+        struct page_list* next = list_next(iter, next);
+        paged->source.put_page(&paged->source, iter->offset, iter->value);
+        mem_free(iter);
+        iter = next;
+    }
+
+    mem_free(paged);
+}
+
 errno_t vmo_new_paged(struct pager_ops pager, struct paged_vmo** out) {
     struct paged_vmo* result = mem_alloc(sizeof(struct paged_vmo), 0);
     if (!result)
         return ENOMEM;
 
+    refcount_init(&result->object.rc);
     result->source = pager;
     result->object.get_page = paged_get_page;
+    result->object.destroy = paged_destroy;
 
     *out = result;
     return 0;
@@ -156,8 +199,7 @@ static errno_t phys_get_page(struct pager_ops* pager, uintptr_t offset, struct p
 }
 
 static errno_t phys_put_page(struct pager_ops* pager, uintptr_t offset, struct page* page) {
-    // We do nothing here.
-    return 0;
+    return mem_phys_free(vm_page_addr(page), 1);
 }
 
 static const struct pager_ops phys_pager = {
@@ -177,16 +219,24 @@ struct phys_range_vmo {
 
 static errno_t phys_range_get_page(struct vmo* vmo, uintptr_t offset_idx, struct page** out) {
     struct phys_range_vmo* p = containerof(vmo, struct phys_range_vmo, object);
+    if (offset_idx >= p->len / arch_mem_page_size())
+        return EINVAL;
     *out = &vm_pfndb[(p->start / arch_mem_page_size()) + offset_idx];
     return 0;
 }
 
+static void phys_range_destroy(struct vmo* vmo) {
+    mem_free(containerof(vmo, struct phys_range_vmo, object));
+}
+
 errno_t vmo_new_phys_range(uintptr_t addr, size_t length, struct vmo** out) {
     struct phys_range_vmo* vmo = mem_alloc(sizeof(struct phys_range_vmo), 0);
     if (!vmo)
         return ENOMEM;
 
+    refcount_init(&vmo->object.rc);
     vmo->object.get_page = phys_range_get_page;
+    vmo->object.destroy = phys_range_destroy;
     vmo->start = ALIGN_DOWN(addr, arch_mem_page_size());
     vmo->len = ALIGN_UP(length, arch_mem_page_size());