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

 #include <config.h>
 typedef struct {
     count_t refcount;   /**< tracking of shared frames  */
     uint8_t buddy_order;    /**< buddy system block order */
-    link_t buddy_link;  /**< link to the next free block inside one order */
+    link_t buddy_link;  /**< link to the next free block inside one
+                     order */
     void *parent;           /**< If allocated by slab, this points there */
 } frame_t;
 typedef struct {
     SPINLOCK_DECLARE(lock); /**< this lock protects everything below */
-    pfn_t base;     /**< frame_no of the first frame in the frames array */
+    pfn_t base;     /**< frame_no of the first frame in the frames
+                     array */
     count_t count;          /**< Size of zone */
-    frame_t *frames;    /**< array of frame_t structures in this zone */
+    frame_t *frames;    /**< array of frame_t structures in this
+                     zone */
     count_t free_count; /**< number of free frame_t structures */
     count_t busy_count; /**< number of busy frame_t structures */
     buddy_system_t *buddy_system; /**< buddy system for the zone */
     int flags;
     if (zones.count + 1 == ZONES_MAX)
         panic("Maximum zone(%d) count exceeded.", ZONES_MAX);
     for (i = 0; i < zones.count; i++) {
         /* Check for overflow */
         z = zones.info[i];
-        if (overlaps(newzone->base,newzone->count,
+        if (overlaps(newzone->base,newzone->count, z->base,
-                 z->base, z->count)) {
+            z->count)) {
             printf("Zones overlap!\n");
             return -1;
+        }
         if (newzone->base < z->base)
             break;
     i = hint;
     do {
         z = zones.info[i];
         spinlock_lock(&z->lock);
         if (z->base <= frame && z->base + z->count > frame) {
+            /* Unlock the global lock */
-            spinlock_unlock(&zones.lock); /* Unlock the global lock */
+            spinlock_unlock(&zones.lock);
             if (pzone)
                 *pzone = i;
             return z;
+        }
         spinlock_unlock(&z->lock);
 /** Find and lock zone that can allocate order frames.
+ *
  * Assume interrupts are disabled.
+ *
  * @param order Size (2^order) of free space we are trying to find
- * @param pzone Pointer to preferred zone or NULL, on return contains zone number
+ * @param pzone Pointer to preferred zone or NULL, on return contains zone
+ *      number
  */
 static zone_t * find_free_zone_and_lock(uint8_t order, unsigned int *pzone)
+{
     unsigned int i;
     zone_t *z;
     index_t index;
     bool is_left, is_right;
     frame = list_get_instance(block, frame_t, buddy_link);
     zone = (zone_t *) b->data;
-    ASSERT(IS_BUDDY_ORDER_OK(frame_index_abs(zone, frame), frame->buddy_order));
+    ASSERT(IS_BUDDY_ORDER_OK(frame_index_abs(zone, frame),
+        frame->buddy_order));
     is_left = IS_BUDDY_LEFT_BLOCK_ABS(zone, frame);
     is_right = IS_BUDDY_RIGHT_BLOCK_ABS(zone, frame);
     ASSERT(is_left ^ is_right);
+ *
  * @param b Buddy system.
  * @param block Buddy system block
  * @param order Order to set
  */
-static void zone_buddy_set_order(buddy_system_t *b, link_t * block, uint8_t order) {
+static void zone_buddy_set_order(buddy_system_t *b, link_t *block,
+    uint8_t order) {
-    frame_t * frame;
+    frame_t *frame;
     frame = list_get_instance(block, frame_t, buddy_link);
     frame->buddy_order = order;
+}
     max_order = fnzb(z->count);
-    z->buddy_system = (buddy_system_t *)&z[1];
+    z->buddy_system = (buddy_system_t *) &z[1];
     buddy_system_create(z->buddy_system, max_order,
-                &zone_buddy_system_operations,
+        &zone_buddy_system_operations, (void *) z);
-                (void *) z);
-    z->frames = (frame_t *)((uint8_t *) z->buddy_system + buddy_conf_size(max_order));
+    z->frames = (frame_t *)((uint8_t *) z->buddy_system +
+        buddy_conf_size(max_order));
     for (i = 0; i < z->count; i++) {
         /* This marks all frames busy */
         frame_initialize(&z->frames[i]);
+    }
     /* Copy frames from both zones to preserve full frame orders,
     zone1 = zones.info[z1];
     zone2 = zones.info[z2];
     spinlock_lock(&zone1->lock);
     spinlock_lock(&zone2->lock);
-    cframes = SIZE2FRAMES(zone_conf_size(zone2->base+zone2->count-zone1->base));
+    cframes = SIZE2FRAMES(zone_conf_size(zone2->base + zone2->count -
+        zone1->base));
     if (cframes == 1)
         order = 0;
     else
         order = fnzb(cframes - 1) + 1;
                 &zone_buddy_system_operations,
                 (void *) z);
     /* Allocate frames _after_ the conframe */
     /* Check sizes */
-    z->frames = (frame_t *)((uint8_t *) z->buddy_system + buddy_conf_size(max_order));
+    z->frames = (frame_t *)((uint8_t *) z->buddy_system +
+        buddy_conf_size(max_order));
     for (i = 0; i < count; i++) {
         frame_initialize(&z->frames[i]);
+    }
     /* Stuffing frames */
      */
     confcount = SIZE2FRAMES(zone_conf_size(count));
     if (confframe >= start && confframe < start+count) {
         for (;confframe < start + count; confframe++) {
             addr = PFN2ADDR(confframe);
+            if (overlaps(addr, PFN2ADDR(confcount),
-            if (overlaps(addr, PFN2ADDR(confcount), KA2PA(config.base), config.kernel_size))
+                KA2PA(config.base), config.kernel_size))
                 continue;
+            if (overlaps(addr, PFN2ADDR(confcount),
-            if (overlaps(addr, PFN2ADDR(confcount), KA2PA(config.stack_base), config.stack_size))
+                KA2PA(config.stack_base), config.stack_size))
                 continue;
             bool overlap = false;
             count_t i;
             for (i = 0; i < init.cnt; i++)
-                if (overlaps(addr, PFN2ADDR(confcount), KA2PA(init.tasks[i].addr), init.tasks[i].size)) {
+                if (overlaps(addr, PFN2ADDR(confcount),
+                    KA2PA(init.tasks[i].addr),
+                    init.tasks[i].size)) {
                     overlap = true;
                     break;
+                }
             if (overlap)
                 continue;
         spinlock_initialize(&zones.lock, "zones.lock");
+    }
     /* Tell the architecture to create some memory */
     frame_arch_init();
     if (config.cpu_active == 1) {
-        frame_mark_unavailable(ADDR2PFN(KA2PA(config.base)), SIZE2FRAMES(config.kernel_size));
+        frame_mark_unavailable(ADDR2PFN(KA2PA(config.base)),
+            SIZE2FRAMES(config.kernel_size));
-        frame_mark_unavailable(ADDR2PFN(KA2PA(config.stack_base)), SIZE2FRAMES(config.stack_size));
+        frame_mark_unavailable(ADDR2PFN(KA2PA(config.stack_base)),
+            SIZE2FRAMES(config.stack_size));
         count_t i;
-        for (i = 0; i < init.cnt; i++)
+        for (i = 0; i < init.cnt; i++) {
-            frame_mark_unavailable(ADDR2PFN(KA2PA(init.tasks[i].addr)), SIZE2FRAMES(init.tasks[i].size));
+            pfn_t pfn = ADDR2PFN(KA2PA(init.tasks[i].addr));
+            frame_mark_unavailable(pfn,
+                SIZE2FRAMES(init.tasks[i].size));
+        }
         if (ballocs.size)
-            frame_mark_unavailable(ADDR2PFN(KA2PA(ballocs.base)), SIZE2FRAMES(ballocs.size));
+            frame_mark_unavailable(ADDR2PFN(KA2PA(ballocs.base)),
+                SIZE2FRAMES(ballocs.size));
         /* Black list first frame, as allocating NULL would
          * fail in some places */
         frame_mark_unavailable(0, 1);
+    }
     printf("#  base address free frames  busy frames\n");
     printf("-- ------------ ------------ ------------\n");
     for (i = 0; i < zones.count; i++) {
         zone = zones.info[i];
         spinlock_lock(&zone->lock);
-        printf("%-2d %12p %12zd %12zd\n", i, PFN2ADDR(zone->base), zone->free_count, zone->busy_count);
+        printf("%-2d %12p %12zd %12zd\n", i, PFN2ADDR(zone->base),
+            zone->free_count, zone->busy_count);
         spinlock_unlock(&zone->lock);
+    }
     spinlock_unlock(&zones.lock);
     interrupts_restore(ipl);
+}
         goto out;
+    }
     spinlock_lock(&zone->lock);
     printf("Memory zone information\n");
-    printf("Zone base address: %#.*p\n", sizeof(uintptr_t) * 2, PFN2ADDR(zone->base));
+    printf("Zone base address: %#.*p\n", sizeof(uintptr_t) * 2,
+        PFN2ADDR(zone->base));
-    printf("Zone size: %zd frames (%zdK)\n", zone->count, ((zone->count) * FRAME_SIZE) >> 10);
+    printf("Zone size: %zd frames (%zdK)\n", zone->count,
+        ((zone->count) * FRAME_SIZE) >> 10);
-    printf("Allocated space: %zd frames (%zdK)\n", zone->busy_count, (zone->busy_count * FRAME_SIZE) >> 10);
+    printf("Allocated space: %zd frames (%zdK)\n", zone->busy_count,
+        (zone->busy_count * FRAME_SIZE) >> 10);
-    printf("Available space: %zd frames (%zdK)\n", zone->free_count, (zone->free_count * FRAME_SIZE) >> 10);
+    printf("Available space: %zd frames (%zdK)\n", zone->free_count,
+        (zone->free_count * FRAME_SIZE) >> 10);
     buddy_system_structure_print(zone->buddy_system, FRAME_SIZE);
     spinlock_unlock(&zone->lock);
 out:
     spinlock_unlock(&zones.lock);
     interrupts_restore(ipl);
+}
 /** @}
  */

Subversion Repositories HelenOS

(root)/trunk/kernel/generic/src/mm/frame.c @ 2128 – Rev 2128 → 2133