WebSVN – HelenOS – Diff – /trunk/kernel/generic/src/mm/frame.c

 /*
  * Synchronization primitives used to sleep when there is no memory
  * available.
  */
-mutex_t zones_mtx;
+mutex_t mem_avail_mtx;
-condvar_t zones_cv;
+condvar_t mem_avail_cv;
+unsigned long mem_avail_frames = 0; /**< Number of available frames. */
-int new_freed_mem = false;
+unsigned long mem_avail_gen = 0;    /**< Generation counter. */
 /********************/
 /* Helper functions */
 /********************/
     return (frame - zone->frames);
+}
 /** Initialize frame structure.
+ *
- * @param framei    Frame structure to be initialized.
+ * @param frame     Frame structure to be initialized.
  */
 static void frame_initialize(frame_t *frame)
+{
     frame->refcount = 1;
     frame->buddy_order = 0;
         zone->busy_count -= (1 << order);
+    }
+}
 /** Return frame from zone. */
-static frame_t * zone_get_frame(zone_t *zone, index_t frame_idx)
+static frame_t *zone_get_frame(zone_t *zone, index_t frame_idx)
+{
     ASSERT(frame_idx < zone->count);
     return &zone->frames[frame_idx];
+}
         return;
     link = buddy_system_alloc_block(zone->buddy_system,
         &frame->buddy_link);
     ASSERT(link);
     zone->free_count--;
+    mutex_lock(&mem_avail_mtx);
+    mem_avail_frames--;
+    mutex_unlock(&mem_avail_mtx);
+}
 /** Join two zones.
+ *
  * Expect zone_t *z to point to space at least zone_conf_size large.
     spinlock_lock(&zones.lock);
     if ((z1 >= zones.count) || (z2 >= zones.count))
         goto errout;
     /* We can join only 2 zones with none existing inbetween */
-    if (z2-z1 != 1)
+    if (z2 - z1 != 1)
         goto errout;
     zone1 = zones.info[z1];
     zone2 = zones.info[z2];
     spinlock_lock(&zone1->lock);
 void zone_merge_all(void)
+{
     int count = zones.count;
     while (zones.count > 1 && --count) {
-        zone_merge(0,1);
+        zone_merge(0, 1);
         break;
+    }
+}
 /** Create new frame zone.
     ASSERT(confframe);
     /* If conframe is supposed to be inside our zone, then make sure
      * it does not span kernel & init
      */
     confcount = SIZE2FRAMES(zone_conf_size(count));
-    if (confframe >= start && confframe < start+count) {
+    if (confframe >= start && confframe < start + count) {
-        for (;confframe < start + count; confframe++) {
+        for (; confframe < start + count; confframe++) {
             addr = PFN2ADDR(confframe);
             if (overlaps(addr, PFN2ADDR(confcount),
                 KA2PA(config.base), config.kernel_size))
                 continue;
     zone_construct(start, count, z, flags);
     znum = zones_add_zone(z);
     if (znum == -1)
         return -1;
+    mutex_lock(&mem_avail_mtx);
+    mem_avail_frames += count;
+    mutex_unlock(&mem_avail_mtx);
     /* If confdata in zone, mark as unavailable */
     if (confframe >= start && confframe < start + count)
         for (i = confframe; i < confframe + confcount; i++) {
             zone_mark_unavailable(z, i - z->base);
+        }
     return znum;
+}
 /***************************************/
 /* Frame functions */
+{
     zone_t *zone = find_zone_and_lock(pfn, &hint);
     ASSERT(zone);
-    zone_get_frame(zone, pfn-zone->base)->parent = data;
+    zone_get_frame(zone, pfn - zone->base)->parent = data;
     spinlock_unlock(&zone->lock);
+}
 void *frame_get_parent(pfn_t pfn, unsigned int hint)
+{
+{
     ipl_t ipl;
     int freed;
     pfn_t v;
     zone_t *zone;
+    unsigned long gen = 0;
 loop:
     ipl = interrupts_disable();
     /*
             interrupts_restore(ipl);
             return 0;
+        }
 #ifdef CONFIG_DEBUG
+        unsigned long avail;
+        mutex_lock(&mem_avail_mtx);
+        avail = mem_avail_frames;
+        mutex_unlock(&mem_avail_mtx);
-        printf("Thread %" PRIu64 " falling asleep, low memory.\n", THREAD->tid);
+        printf("Thread %" PRIu64 " waiting for %u frames, "
+            "%u available.\n", THREAD->tid, 1ULL << order, avail);
 #endif
-        mutex_lock(&zones_mtx);
+        mutex_lock(&mem_avail_mtx);
+        while ((mem_avail_frames < (1ULL << order)) ||
-        if (!new_freed_mem)
+            gen == mem_avail_gen)
-            condvar_wait(&zones_cv, &zones_mtx);
+            condvar_wait(&mem_avail_cv, &mem_avail_mtx);
-        new_freed_mem = false;
+        gen = mem_avail_gen;
-        mutex_unlock(&zones_mtx);
+        mutex_unlock(&mem_avail_mtx);
 #ifdef CONFIG_DEBUG
+        mutex_lock(&mem_avail_mtx);
+        avail = mem_avail_frames;
+        mutex_unlock(&mem_avail_mtx);
-        printf("Thread %" PRIu64 " woken up, memory available.\n", THREAD->tid);
+        printf("Thread %" PRIu64 " woken up, %u frames available.\n",
+            THREAD->tid, avail);
 #endif
         interrupts_restore(ipl);
         goto loop;
+    }
     v = zone_frame_alloc(zone, order);
     v += zone->base;
     spinlock_unlock(&zone->lock);
+    mutex_lock(&mem_avail_mtx);
+    mem_avail_frames -= (1ULL << order);
+    mutex_unlock(&mem_avail_mtx);
     interrupts_restore(ipl);
     if (flags & FRAME_KA)
         return (void *)PA2KA(PFN2ADDR(v));
     return (void *)PFN2ADDR(v);
     spinlock_unlock(&zone->lock);
     /*
      * Signal that some memory has been freed.
      */
-    mutex_lock(&zones_mtx);
+    mutex_lock(&mem_avail_mtx);
-    new_freed_mem = true;
+    mem_avail_frames++;
+    mem_avail_gen++;
-    condvar_broadcast(&zones_cv);
+    condvar_broadcast(&mem_avail_cv);
-    mutex_unlock(&zones_mtx);
+    mutex_unlock(&mem_avail_mtx);
     interrupts_restore(ipl);
+}
 /** Add reference to frame.
 void frame_init(void)
+{
     if (config.cpu_active == 1) {
         zones.count = 0;
         spinlock_initialize(&zones.lock, "zones.lock");
+        mutex_initialize(&mem_avail_mtx, MUTEX_ACTIVE);
+        condvar_initialize(&mem_avail_cv);
+    }
     /* Tell the architecture to create some memory */
     frame_arch_init();
     if (config.cpu_active == 1) {
         frame_mark_unavailable(ADDR2PFN(KA2PA(config.base)),
         /* Black list first frame, as allocating NULL would
          * fail in some places */
         frame_mark_unavailable(0, 1);
+    }
-    mutex_initialize(&zones_mtx, MUTEX_ACTIVE); /* mimic spinlock */
-    condvar_initialize(&zones_cv);
+}
 /** Return total size of all zones. */
 uint64_t zone_total_size(void)

Subversion Repositories HelenOS

(root)/trunk/kernel/generic/src/mm/frame.c – Rev 3187 → 3188