Changes in kernel/generic/src/mm/backend_anon.c [9d58539:83b6ba9f] in mainline

File:

• kernel/generic/src/mm/backend_anon.c (modified) (13 diffs)

kernel/generic/src/mm/backend_anon.c

@@ -59 +59 @@
 static void anon_destroy(as_area_t *);
 
+static bool anon_is_resizable(as_area_t *);
+static bool anon_is_shareable(as_area_t *);
+
 static int anon_page_fault(as_area_t *, uintptr_t, pf_access_t);
 static void anon_frame_free(as_area_t *, uintptr_t, uintptr_t);
@@ -68 +71 @@
         .destroy = anon_destroy,
 
+        .is_resizable = anon_is_resizable,
+        .is_shareable = anon_is_shareable,
+
         .page_fault = anon_page_fault,
         .frame_free = anon_frame_free,
+
+        .create_shared_data = NULL,
+        .destroy_shared_data = NULL
 };
 
 bool anon_create(as_area_t *area)
 {
+        if (area->flags & AS_AREA_LATE_RESERVE)
+                return true;
+
         return reserve_try_alloc(area->pages);
 }
@@ -79 +91 @@
 bool anon_resize(as_area_t *area, size_t new_pages)
 {
+        if (area->flags & AS_AREA_LATE_RESERVE)
+                return true;
+
         if (new_pages > area->pages)
                 return reserve_try_alloc(new_pages - area->pages);
@@ -100 +115 @@
         ASSERT(mutex_locked(&area->as->lock));
         ASSERT(mutex_locked(&area->lock));
+        ASSERT(!(area->flags & AS_AREA_LATE_RESERVE));
 
         /*
@@ -105 +121 @@
          */
         mutex_lock(&area->sh_info->lock);
-        list_foreach(area->used_space.leaf_list, cur) {
-                btree_node_t *node;
+        list_foreach(area->used_space.leaf_list, leaf_link, btree_node_t,
+            node) {
                 unsigned int i;
                 
-                node = list_get_instance(cur, btree_node_t, leaf_link);
                 for (i = 0; i < node->keys; i++) {
                         uintptr_t base = node->key[i];
@@ -139 +154 @@
 void anon_destroy(as_area_t *area)
 {
+        if (area->flags & AS_AREA_LATE_RESERVE)
+                return;
+
         reserve_free(area->pages);
 }
 
+bool anon_is_resizable(as_area_t *area)
+{
+        return true;
+}
+
+bool anon_is_shareable(as_area_t *area)
+{
+        return !(area->flags & AS_AREA_LATE_RESERVE);
+}
 
 /** Service a page fault in the anonymous memory address space area.
@@ -148 +175 @@
  *
  * @param area Pointer to the address space area.
- * @param addr Faulting virtual address.
+ * @param upage Faulting virtual page.
  * @param access Access mode that caused the fault (i.e. read/write/exec).
  *
@@ -154 +181 @@
  *     serviced).
  */
-int anon_page_fault(as_area_t *area, uintptr_t addr, pf_access_t access)
-{
-        uintptr_t upage = ALIGN_DOWN(addr, PAGE_SIZE);
+int anon_page_fault(as_area_t *area, uintptr_t upage, pf_access_t access)
+{
         uintptr_t kpage;
         uintptr_t frame;
@@ -162 +188 @@
         ASSERT(page_table_locked(AS));
         ASSERT(mutex_locked(&area->lock));
+        ASSERT(IS_ALIGNED(upage, PAGE_SIZE));
 
         if (!as_area_check_access(area, access))
                 return AS_PF_FAULT;
 
-        if (area->sh_info) {
+        mutex_lock(&area->sh_info->lock);
+        if (area->sh_info->shared) {
                 btree_node_t *leaf;
                 
@@ -176 +204 @@
                  * mapping, a new frame is allocated and the mapping is created.
                  */
-                mutex_lock(&area->sh_info->lock);
                 frame = (uintptr_t) btree_search(&area->sh_info->pagemap,
                     upage - area->base, &leaf);
@@ -208 +235 @@
                 }
                 frame_reference_add(ADDR2PFN(frame));
-                mutex_unlock(&area->sh_info->lock);
         } else {
 
@@ -225 +251 @@
                  *   the different causes
                  */
+
+                if (area->flags & AS_AREA_LATE_RESERVE) {
+                        /*
+                         * Reserve the memory for this page now.
+                         */
+                        if (!reserve_try_alloc(1)) {
+                                mutex_unlock(&area->sh_info->lock);
+                                return AS_PF_SILENT;
+                        }
+                }
+
                 kpage = km_temporary_page_get(&frame, FRAME_NO_RESERVE);
                 memsetb((void *) kpage, PAGE_SIZE, 0);
                 km_temporary_page_put(kpage);
         }
+        mutex_unlock(&area->sh_info->lock);
         
         /*
@@ -255 +293 @@
         ASSERT(mutex_locked(&area->lock));
 
-        frame_free_noreserve(frame);
+        if (area->flags & AS_AREA_LATE_RESERVE) {
+                /*
+                 * In case of the late reserve areas, physical memory will not
+                 * be unreserved when the area is destroyed so we need to use
+                 * the normal unreserving frame_free().
+                 */
+                frame_free(frame, 1);
+        } else {
+                /*
+                 * The reserve will be given back when the area is destroyed or
+                 * resized, so use the frame_free_noreserve() which does not
+                 * manipulate the reserve or it would be given back twice.
+                 */
+                frame_free_noreserve(frame, 1);
+        }
 }