Changeset 5df1963 in mainline for kernel/generic/src/mm

Timestamp:

2013-09-10T21:47:25Z (12 years ago)

Author:

Martin Decky <martin@…>

Branches:

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

Children:

0511549

Parents:

a501e22c

Message:

bitmap frame allocator does not keep track of the size of the allocated frame blocks
to avoid memory leaks the number of allocated frames needs to be passed explicitly during deallocation

Location:

kernel/generic/src/mm

Files:

• as.c (modified) (1 diff)
• backend_anon.c (modified) (2 diffs)
• backend_elf.c (modified) (2 diffs)
• frame.c (modified) (6 diffs)
• slab.c (modified) (2 diffs)

kernel/generic/src/mm/as.c

@@ -907 +907 @@
                         
                         for (i = 0; i < node->keys; i++)
-                                frame_free((uintptr_t) node->value[i]);
+                                frame_free((uintptr_t) node->value[i], 1);
                 }
                 

kernel/generic/src/mm/backend_anon.c

@@ -294 +294 @@
                  * the normal unreserving frame_free().
                  */
-                frame_free(frame);
+                frame_free(frame, 1);
         } else {
                 /*
@@ -301 +301 @@
                  * manipulate the reserve or it would be given back twice.
                  */
-                frame_free_noreserve(frame);
+                frame_free_noreserve(frame, 1);
         }
 }

kernel/generic/src/mm/backend_elf.c

@@ -429 +429 @@
                          * data.
                          */
-                        frame_free_noreserve(frame);
+                        frame_free_noreserve(frame, 1);
                 }
         } else {
@@ -437 +437 @@
                  * anonymous). In any case, a frame needs to be freed.
                  */
-                frame_free_noreserve(frame);
+                frame_free_noreserve(frame, 1);
         }
 }

kernel/generic/src/mm/frame.c

@@ -348 +348 @@
         
         frame_t *frame = zone_get_frame(zone, index);
-        size_t size = 0;
         
         ASSERT(frame->refcount > 0);
@@ -359 +358 @@
                 zone->busy_count--;
                 
-                size = FRAME_SIZE;
-        }
-        
-        return size;
+                return 1;
+        }
+        
+        return 0;
 }
 
@@ -891 +890 @@
 }
 
-/** Free a frame.
- *
- * Find respective frame structure for supplied physical frame address.
- * Decrement frame reference count. If it drops to zero, move the frame
- * structure to free list.
- *
- * @param frame Physical Address of of the frame to be freed.
+/** Free frames of physical memory.
+ *
+ * Find respective frame structures for supplied physical frames.
+ * Decrement each frame reference count. If it drops to zero, mark
+ * the frames as available.
+ *
+ * @param start Physical Address of the first frame to be freed.
+ * @param count Number of frames to free.
  * @param flags Flags to control memory reservation.
  *
  */
-void frame_free_generic(uintptr_t frame, frame_flags_t flags)
-{
+void frame_free_generic(uintptr_t start, size_t count, frame_flags_t flags)
+{
+        size_t freed = 0;
+        
         irq_spinlock_lock(&zones.lock, true);
         
-        /*
-         * First, find host frame zone for addr.
-         */
-        pfn_t pfn = ADDR2PFN(frame);
-        size_t znum = find_zone(pfn, 1, 0);
-        
-        ASSERT(znum != (size_t) -1);
-        
-        size_t size =
-            zone_frame_free(&zones.info[znum], pfn - zones.info[znum].base);
+        for (size_t i = 0; i < count; i++) {
+                /*
+                 * First, find host frame zone for addr.
+                 */
+                pfn_t pfn = ADDR2PFN(start) + i;
+                size_t znum = find_zone(pfn, 1, 0);
+                
+                ASSERT(znum != (size_t) -1);
+                
+                freed += zone_frame_free(&zones.info[znum],
+                    pfn - zones.info[znum].base);
+        }
         
         irq_spinlock_unlock(&zones.lock, true);
@@ -920 +924 @@
         /*
          * Signal that some memory has been freed.
-         */
-        
-        
-        /*
-         * Since the mem_avail_mtx is an active mutex, we need to disable interrupts
-         * to prevent deadlock with TLB shootdown.
+         * Since the mem_avail_mtx is an active mutex,
+         * we need to disable interruptsto prevent deadlock
+         * with TLB shootdown.
          */
         
@@ -932 +933 @@
         
         if (mem_avail_req > 0)
-                mem_avail_req -= min(mem_avail_req, size);
+                mem_avail_req -= min(mem_avail_req, freed);
         
         if (mem_avail_req == 0) {
@@ -943 +944 @@
         
         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);
+                reserve_free(freed);
+}
+
+void frame_free(uintptr_t frame, size_t count)
+{
+        frame_free_generic(frame, count, 0);
+}
+
+void frame_free_noreserve(uintptr_t frame, size_t count)
+{
+        frame_free_generic(frame, count, FRAME_NO_RESERVE);
 }
 

kernel/generic/src/mm/slab.c

@@ -193 +193 @@
                 slab = slab_alloc(slab_extern_cache, flags);
                 if (!slab) {
-                        frame_free(KA2PA(data));
+                        frame_free(KA2PA(data), cache->frames);
                         return NULL;
                 }
@@ -225 +225 @@
 NO_TRACE static size_t slab_space_free(slab_cache_t *cache, slab_t *slab)
 {
-        frame_free(KA2PA(slab->start));
+        frame_free(KA2PA(slab->start), slab->cache->frames);
         if (!(cache->flags & SLAB_CACHE_SLINSIDE))
                 slab_free(slab_extern_cache, slab);