Changes in kernel/generic/src/mm/frame.c [7e752b2:d060900] in mainline

File:

• kernel/generic/src/mm/frame.c (modified) (15 diffs)

kernel/generic/src/mm/frame.c

@@ -45 +45 @@
 #include <typedefs.h>
 #include <mm/frame.h>
+#include <mm/reserve.h>
 #include <mm/as.h>
 #include <panic.h>
@@ -472 +473 @@
  * @param frame_idx Frame index relative to zone.
  *
- */
-NO_TRACE static void zone_frame_free(zone_t *zone, size_t frame_idx)
+ * @return          Number of freed frames.
+ *
+ */
+NO_TRACE static size_t zone_frame_free(zone_t *zone, size_t frame_idx)
 {
         ASSERT(zone_flags_available(zone->flags));
         
         frame_t *frame = &zone->frames[frame_idx];
-        
-        /* Remember frame order */
-        uint8_t order = frame->buddy_order;
+        size_t size = 1 << frame->buddy_order;
         
         ASSERT(frame->refcount);
@@ -488 +489 @@
                 
                 /* Update zone information. */
-                zone->free_count += (1 << order);
-                zone->busy_count -= (1 << order);
-        }
+                zone->free_count += size;
+                zone->busy_count -= size;
+        }
+        
+        return size;
 }
 
@@ -516 +519 @@
         ASSERT(link);
         zone->free_count--;
+        reserve_force_alloc(1);
 }
 
@@ -645 +649 @@
         for (i = 0; i < cframes; i++) {
                 zones.info[znum].busy_count++;
-                zone_frame_free(&zones.info[znum],
+                (void) zone_frame_free(&zones.info[znum],
                     pfn - zones.info[znum].base + i);
         }
@@ -683 +687 @@
         /* Free unneeded frames */
         for (i = count; i < (size_t) (1 << order); i++)
-                zone_frame_free(&zones.info[znum], i + frame_idx);
+                (void) zone_frame_free(&zones.info[znum], i + frame_idx);
 }
 
@@ -695 +699 @@
  * not to be 2^order size. Once the allocator is running it is no longer
  * possible, merged configuration data occupies more space :-/
- *
- * The function uses
  *
  */
@@ -837 +839 @@
                         buddy_system_free(zone->buddy_system, &zone->frames[i].buddy_link);
                 }
+
+                /* "Unreserve" new frames. */
+                reserve_free(count);
         } else
                 zone->frames = NULL;
@@ -999 +1004 @@
         size_t hint = pzone ? (*pzone) : 0;
         
+        /*
+         * If not told otherwise, we must first reserve the memory.
+         */
+        if (!(flags & FRAME_NO_RESERVE)) {
+                if (flags & FRAME_ATOMIC) {
+                        if (!reserve_try_alloc(size))
+                                return NULL;
+                } else {
+                        reserve_force_alloc(size);
+                }
+        }
+        
 loop:
         irq_spinlock_lock(&zones.lock, true);
@@ -1033 +1050 @@
                 if (flags & FRAME_ATOMIC) {
                         irq_spinlock_unlock(&zones.lock, true);
+                        if (!(flags & FRAME_NO_RESERVE))
+                                reserve_free(size);
                         return NULL;
                 }
@@ -1088 +1107 @@
 }
 
+void *frame_alloc(uint8_t order, frame_flags_t flags)
+{
+        return frame_alloc_generic(order, flags, NULL);
+}
+
+void *frame_alloc_noreserve(uint8_t order, frame_flags_t flags)
+{
+        return frame_alloc_generic(order, flags | FRAME_NO_RESERVE, NULL);
+}
+
 /** Free a frame.
  *
@@ -1095 +1124 @@
  *
  * @param frame Physical Address of of the frame to be freed.
- *
- */
-void frame_free(uintptr_t frame)
-{
+ * @param flags Flags to control memory reservation.
+ *
+ */
+void frame_free_generic(uintptr_t frame, frame_flags_t flags)
+{
+        size_t size;
+        
         irq_spinlock_lock(&zones.lock, true);
         
@@ -1106 +1138 @@
         pfn_t pfn = ADDR2PFN(frame);
         size_t znum = find_zone(pfn, 1, 0);
+
         
         ASSERT(znum != (size_t) -1);
         
-        zone_frame_free(&zones.info[znum], pfn - zones.info[znum].base);
+        size = zone_frame_free(&zones.info[znum], pfn - zones.info[znum].base);
         
         irq_spinlock_unlock(&zones.lock, true);
@@ -1118 +1151 @@
         mutex_lock(&mem_avail_mtx);
         if (mem_avail_req > 0)
-                mem_avail_req--;
+                mem_avail_req -= min(mem_avail_req, size);
         
         if (mem_avail_req == 0) {
@@ -1125 +1158 @@
         }
         mutex_unlock(&mem_avail_mtx);
+        
+        if (!(flags & FRAME_NO_RESERVE))
+                reserve_free(size);
+}
+
+void frame_free(uintptr_t frame)
+{
+        frame_free_generic(frame, 0);
+}
+
+void frame_free_noreserve(uintptr_t frame)
+{
+        frame_free_generic(frame, FRAME_NO_RESERVE);
 }