Changeset 1f7753a in mainline for kernel/generic/src/mm

Timestamp:

2012-11-18T22:10:15Z (13 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

0ab362c, c739102

Parents:

a7f7ed12 (diff), 34ae0a5 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge from lp:~jakub/helenos/mm.

Location:

kernel/generic/src/mm

Files:

• as.c (modified) (3 diffs)
• backend_anon.c (modified) (8 diffs)
• backend_elf.c (modified) (3 diffs)
• backend_phys.c (modified) (3 diffs)
• km.c (modified) (3 diffs)

kernel/generic/src/mm/as.c

@@ -426 +426 @@
         /*
          * So far, the area does not conflict with other areas.
-         * Check if it doesn't conflict with kernel address space.
+         * Check if it is contained in the user address space.
          */
         if (!KERNEL_ADDRESS_SPACE_SHADOWED) {
-                return !overlaps(addr, P2SZ(count), KERNEL_ADDRESS_SPACE_START,
-                    KERNEL_ADDRESS_SPACE_END - KERNEL_ADDRESS_SPACE_START);
+                return iswithin(USER_ADDRESS_SPACE_START,
+                    (USER_ADDRESS_SPACE_END - USER_ADDRESS_SPACE_START) + 1,
+                    addr, P2SZ(count));
         }
         
@@ -696 +697 @@
                 return ENOENT;
         }
-        
-        if (area->backend == &phys_backend) {
-                /*
-                 * Remapping of address space areas associated
-                 * with memory mapped devices is not supported.
+
+        if (!area->backend->is_resizable(area)) {
+                /*
+                 * The backend does not support resizing for this area.
                  */
                 mutex_unlock(&area->lock);
@@ -1057 +1057 @@
         }
         
-        if ((!src_area->backend) || (!src_area->backend->share)) {
-                /*
-                 * There is no backend or the backend does not
-                 * know how to share the area.
+        if (!src_area->backend->is_shareable(src_area)) {
+                /*
+                 * The backend does not permit sharing of this area.
                  */
                 mutex_unlock(&src_area->lock);

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,
@@ -74 +80 @@
 bool anon_create(as_area_t *area)
 {
+        if (area->flags & AS_AREA_LATE_RESERVE)
+                return true;
+
         return reserve_try_alloc(area->pages);
 }
@@ -79 +88 @@
 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 +112 @@
         ASSERT(mutex_locked(&area->as->lock));
         ASSERT(mutex_locked(&area->lock));
+        ASSERT(!(area->flags & AS_AREA_LATE_RESERVE));
 
         /*
@@ -139 +152 @@
 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.
@@ -225 +250 @@
                  *   the different causes
                  */
+
+                if (area->flags & AS_AREA_LATE_RESERVE) {
+                        /*
+                         * Reserve the memory for this page now.
+                         */
+                        if (!reserve_try_alloc(1)) {
+                                printf("Killing task %" PRIu64 " due to a "
+                                    "failed late reservation request.\n",
+                                    TASK->taskid);
+                                TASK->silent_kill = true;
+                                return AS_PF_FAULT;
+                        }
+                }
+
                 kpage = km_temporary_page_get(&frame, FRAME_NO_RESERVE);
                 memsetb((void *) kpage, PAGE_SIZE, 0);
@@ -255 +294 @@
         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);
+        } 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);
+        }
 }
 

kernel/generic/src/mm/backend_elf.c

@@ -58 +58 @@
 static void elf_destroy(as_area_t *);
 
+static bool elf_is_resizable(as_area_t *);
+static bool elf_is_shareable(as_area_t *);
+
 static int elf_page_fault(as_area_t *, uintptr_t, pf_access_t);
 static void elf_frame_free(as_area_t *, uintptr_t, uintptr_t);
@@ -66 +69 @@
         .share = elf_share,
         .destroy = elf_destroy,
+
+        .is_resizable = elf_is_resizable,
+        .is_shareable = elf_is_shareable,
 
         .page_fault = elf_page_fault,
@@ -213 +219 @@
 }
 
+bool elf_is_resizable(as_area_t *area)
+{
+        return true;
+}
+
+bool elf_is_shareable(as_area_t *area)
+{
+        return true;
+}
+
+
 /** Service a page fault in the ELF backend address space area.
  *

kernel/generic/src/mm/backend_phys.c

@@ -52 +52 @@
 static void phys_destroy(as_area_t *);
 
+static bool phys_is_resizable(as_area_t *);
+static bool phys_is_shareable(as_area_t *);
+
+
 static int phys_page_fault(as_area_t *, uintptr_t, pf_access_t);
 
@@ -59 +63 @@
         .share = phys_share,
         .destroy = phys_destroy,
+
+        .is_resizable = phys_is_resizable,
+        .is_shareable = phys_is_shareable,
 
         .page_fault = phys_page_fault,
@@ -87 +94 @@
         /* Nothing to do. */
 }
+
+bool phys_is_resizable(as_area_t *area)
+{
+        return false;
+}
+
+bool phys_is_shareable(as_area_t *area)
+{
+        return true;
+}
+
 
 /** Service a page fault in the address space area backed by physical memory.

kernel/generic/src/mm/km.c

@@ -233 +233 @@
  * @param[inout] framep Pointer to a variable which will receive the physical
  *                      address of the allocated frame.
- * @param[in] flags     Frame allocation flags. FRAME_NONE or FRAME_NO_RESERVE.
+ * @param[in] flags     Frame allocation flags. FRAME_NONE, FRAME_NO_RESERVE
+ *                      and FRAME_ATOMIC bits are allowed.
  * @return              Virtual address of the allocated frame.
  */
@@ -243 +244 @@
         ASSERT(THREAD);
         ASSERT(framep);
-        ASSERT(!(flags & ~FRAME_NO_RESERVE));
+        ASSERT(!(flags & ~(FRAME_NO_RESERVE | FRAME_ATOMIC)));
 
         /*
@@ -255 +256 @@
                 ASSERT(page);   // FIXME
         } else {
-                frame = (uintptr_t) frame_alloc_noreserve(ONE_FRAME,
-                    FRAME_LOWMEM);
+                frame = (uintptr_t) frame_alloc(ONE_FRAME,
+                    FRAME_LOWMEM | flags);
+                if (!frame)
+                        return (uintptr_t) NULL;
                 page = PA2KA(frame);
         }