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

 /*
  * Copyright (c) 2001-2005 Jakub Jermar
  * Copyright (c) 2005 Sergey Bondari
+ * Copyright (c) 2009 Martin Decky
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * @{
  */
 /**
  * @file
- * @brief   Physical frame allocator.
+ * @brief Physical frame allocator.
+ *
  * This file contains the physical frame allocator and memory zone management.
  * The frame allocator is built on top of the buddy allocator.
+ *
  * @see buddy.c
  */
-/*
- * Locking order
- *
- * In order to access particular zone, the process must first lock
- * the zones.lock, then lock the zone and then unlock the zones.lock.
- * This insures, that we can fiddle with the zones in runtime without
- * affecting the processes.
- *
- */
 #include <arch/types.h>
 #include <mm/frame.h>
 #include <mm/as.h>
 #include <panic.h>
 #include <debug.h>
 #include <bitops.h>
 #include <macros.h>
 #include <config.h>
 typedef struct {
-    count_t refcount;   /**< tracking of shared frames  */
+    count_t refcount;     /**< Tracking of shared frames */
-    uint8_t buddy_order;    /**< buddy system block order */
+    uint8_t buddy_order;  /**< Buddy system block order */
-    link_t buddy_link;  /**< link to the next free block inside one
+    link_t buddy_link;    /**< Link to the next free block inside
-                     order */
+                               one order */
-    void *parent;           /**< If allocated by slab, this points there */
+    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
-    pfn_t base;     /**< frame_no of the first frame in the frames
+                                        in the frames array */
-                     array */
-    count_t count;          /**< Size of zone */
+    count_t count;                 /**< Size of zone */
-    frame_t *frames;    /**< array of frame_t structures in this
+    count_t free_count;            /**< Number of free frame_t
-                     zone */
+                                        structures */
-    count_t free_count; /**< number of free frame_t structures */
+    count_t busy_count;            /**< Number of busy frame_t
-    count_t busy_count; /**< number of busy frame_t structures */
+                                        structures */
+    zone_flags_t flags;            /**< Type of the zone */
+    frame_t *frames;               /**< Array of frame_t structures
+                                        in this zone */
-    buddy_system_t *buddy_system; /**< buddy system for the zone */
+    buddy_system_t *buddy_system;  /**< Buddy system for the zone */
-    int flags;
 } zone_t;
 /*
  * The zoneinfo.lock must be locked when accessing zoneinfo structure.
  * Some of the attributes in zone_t structures are 'read-only'
  */
 typedef struct {
     SPINLOCK_DECLARE(lock);
-    unsigned int count;
+    count_t count;
-    zone_t *info[ZONES_MAX];
+    zone_t info[ZONES_MAX];
 } zones_t;
 static zones_t zones;
 /*
  * Synchronization primitives used to sleep when there is no memory
  * available.
  */
 mutex_t mem_avail_mtx;
 condvar_t mem_avail_cv;
-unsigned long mem_avail_frames = 0; /**< Number of available frames. */
+count_t mem_avail_req = 0;  /**< Number of frames requested. */
-unsigned long mem_avail_gen = 0;    /**< Generation counter. */
+count_t mem_avail_gen = 0;  /**< Generation counter. */
 /********************/
 /* Helper functions */
 /********************/
 static inline index_t frame_index_abs(zone_t *zone, frame_t *frame)
+{
     return (index_t) (frame - zone->frames) + zone->base;
+}
-static inline int frame_index_valid(zone_t *zone, index_t index)
+static inline bool frame_index_valid(zone_t *zone, index_t index)
+{
     return (index < zone->count);
+}
-/** Compute pfn_t from frame_t pointer & zone pointer */
-static index_t make_frame_index(zone_t *zone, frame_t *frame)
+static inline index_t make_frame_index(zone_t *zone, frame_t *frame)
+{
     return (frame - zone->frames);
+}
+static inline bool zone_flags_available(zone_flags_t flags)
+{
+    return ((flags & (ZONE_RESERVED | ZONE_FIRMWARE)) == 0);
+}
 /** Initialize frame structure.
+ *
- * @param frame     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;
+}
-/**********************/
+/*******************/
-/* Zoneinfo functions */
+/* Zones functions */
-/**********************/
+/*******************/
 /** Insert-sort zone into zones list.
+ *
+ * Assume interrupts are disabled and zones lock is
+ * locked.
+ *
- * @param newzone   New zone to be inserted into zone list.
+ * @param base  Base frame of the newly inserted zone.
+ * @param count Number of frames of the newly inserted zone.
+ *
- * @return      Zone number on success, -1 on error.
+ * @return Zone number on success, -1 on error.
+ *
  */
-static int zones_add_zone(zone_t *newzone)
+static count_t zones_insert_zone(pfn_t base, count_t count)
+{
-    unsigned int i, j;
-    ipl_t ipl;
-    zone_t *z;
-    ipl = interrupts_disable();
-    spinlock_lock(&zones.lock);
-    /* Try to merge */
     if (zones.count + 1 == ZONES_MAX) {
         printf("Maximum zone count %u exceeded!\n", ZONES_MAX);
-        spinlock_unlock(&zones.lock);
-        interrupts_restore(ipl);
-        return -1;
+        return (count_t) -1;
+    }
+    count_t i;
     for (i = 0; i < zones.count; i++) {
-        /* Check for overflow */
+        /* Check for overlap */
-        z = zones.info[i];
+        if (overlaps(base, count,
-        if (overlaps(newzone->base, newzone->count, z->base,
+            zones.info[i].base, zones.info[i].count)) {
-            z->count)) {
             printf("Zones overlap!\n");
-            return -1;
+            return (count_t) -1;
+        }
-        if (newzone->base < z->base)
+        if (base < zones.info[i].base)
             break;
+    }
     /* Move other zones up */
+    count_t j;
     for (j = i; j < zones.count; j++)
         zones.info[j + 1] = zones.info[j];
-    zones.info[i] = newzone;
     zones.count++;
-    spinlock_unlock(&zones.lock);
-    interrupts_restore(ipl);
     return i;
+}
+/** Get total available frames.
+ *
-/** Try to find a zone where can we find the frame.
+ * Assume interrupts are disabled and zones lock is
+ * locked.
+ *
- * Assume interrupts are disabled.
+ * @return Total number of available frames.
+ *
- * @param frame     Frame number contained in zone.
- * @param pzone     If not null, it is used as zone hint. Zone index is
- *          filled into the variable on success.
- * @return      Pointer to locked zone containing frame.
  */
-static zone_t *find_zone_and_lock(pfn_t frame, unsigned int *pzone)
+static count_t total_frames_free(void)
+{
+    count_t total = 0;
-    unsigned int i;
+    count_t i;
-    unsigned int hint = pzone ? *pzone : 0;
+    for (i = 0; i < zones.count; i++)
-    zone_t *z;
+        total += zones.info[i].free_count;
-    spinlock_lock(&zones.lock);
+    return total;
+}
+/** Find a zone with a given frame.
+ *
+ * Assume interrupts are disabled and zones lock is
+ * locked.
+ *
+ * @param frame Frame number contained in zone.
+ * @param hint  Used as zone hint.
+ *
+ * @return Zone index or -1 if not found.
+ *
+ */
+static count_t find_zone(pfn_t frame, count_t hint)
+{
     if (hint >= zones.count)
         hint = 0;
-    i = hint;
+    count_t i = hint;
     do {
-        z = zones.info[i];
+        if ((zones.info[i].base <= frame)
-        spinlock_lock(&z->lock);
-        if (z->base <= frame && z->base + z->count > frame) {
+            && (zones.info[i].base + zones.info[i].count > frame))
-            /* Unlock the global lock */
-            spinlock_unlock(&zones.lock);
-            if (pzone)
-                *pzone = i;
-            return z;
+            return i;
-        }
-        spinlock_unlock(&z->lock);
         i++;
         if (i >= zones.count)
             i = 0;
     } while (i != hint);
-    spinlock_unlock(&zones.lock);
-    return NULL;
+    return (count_t) -1;
+}
 /** @return True if zone can allocate specified order */
-static int zone_can_alloc(zone_t *z, uint8_t order)
+static bool zone_can_alloc(zone_t *zone, uint8_t order)
+{
+    return (zone_flags_available(zone->flags)
-    return buddy_system_can_alloc(z->buddy_system, order);
+        && buddy_system_can_alloc(zone->buddy_system, order));
+}
-/** Find and lock zone that can allocate order frames.
+/** Find a zone that can allocate order frames.
+ *
+ * Assume interrupts are disabled and zones lock is
+ * locked.
+ *
+ * @param order Size (2^order) of free space we are trying to find.
+ * @param flags Required flags of the target zone.
- * Assume interrupts are disabled.
+ * @param hind  Preferred zone.
+ *
- * @param order     Size (2^order) of free space we are trying to find.
- * @param flags     Required flags of the target zone.
- * @param pzone     Pointer to preferred zone or NULL, on return contains
- *          zone number.
  */
-static zone_t *
-find_free_zone_and_lock(uint8_t order, int flags, unsigned int *pzone)
+static count_t find_free_zone(uint8_t order, zone_flags_t flags, count_t hint)
+{
-    unsigned int i;
-    zone_t *z;
-    unsigned int hint = pzone ? *pzone : 0;
-    /* Mask off flags that are not applicable. */
-    flags &= FRAME_LOW_4_GiB;
-    spinlock_lock(&zones.lock);
     if (hint >= zones.count)
         hint = 0;
-    i = hint;
+    count_t i = hint;
     do {
-        z = zones.info[i];
-        spinlock_lock(&z->lock);
         /*
          * Check whether the zone meets the search criteria.
          */
-        if ((z->flags & flags) == flags) {
+        if ((zones.info[i].flags & flags) == flags) {
             /*
              * Check if the zone has 2^order frames area available.
              */
-            if (zone_can_alloc(z, order)) {
+            if (zone_can_alloc(&zones.info[i], order))
-                spinlock_unlock(&zones.lock);
-                if (pzone)
-                    *pzone = i;
-                return z;
+                return i;
-            }
+        }
-        spinlock_unlock(&z->lock);
+        i++;
-        if (++i >= zones.count)
+        if (i >= zones.count)
             i = 0;
     } while (i != hint);
-    spinlock_unlock(&zones.lock);
-    return NULL;
+    return (count_t) -1;
+}
 /**************************/
 /* Buddy system functions */
 /**************************/
 /** Buddy system find_block implementation.
+ *
  * Find block that is parent of current list.
  * That means go to lower addresses, until such block is found
+ *
- * @param order     Order of parent must be different then this
+ * @param order Order of parent must be different then this
- *          parameter!!
+ *              parameter!!
+ *
  */
-static link_t *zone_buddy_find_block(buddy_system_t *b, link_t *child,
+static link_t *zone_buddy_find_block(buddy_system_t *buddy, link_t *child,
     uint8_t order)
+{
-    frame_t *frame;
+    frame_t *frame = list_get_instance(child, frame_t, buddy_link);
-    zone_t *zone;
+    zone_t *zone = (zone_t *) buddy->data;
-    index_t index;
-    frame = list_get_instance(child, frame_t, buddy_link);
-    zone = (zone_t *) b->data;
-    index = frame_index(zone, frame);
+    index_t index = frame_index(zone, frame);
     do {
-        if (zone->frames[index].buddy_order != order) {
+        if (zone->frames[index].buddy_order != order)
             return &zone->frames[index].buddy_link;
-        }
-    } while(index-- > 0);
+    } while (index-- > 0);
     return NULL;
+}
 /** Buddy system find_buddy implementation.
+ *
- * @param b     Buddy system.
+ * @param buddy Buddy system.
- * @param block     Block for which buddy should be found.
+ * @param block Block for which buddy should be found.
+ *
+ * @return Buddy for given block if found.
+ *
- * @return      Buddy for given block if found.
  */
-static link_t *zone_buddy_find_buddy(buddy_system_t *b, link_t *block)
+static link_t *zone_buddy_find_buddy(buddy_system_t *buddy, link_t *block)
+{
-    frame_t *frame;
-    zone_t *zone;
-    index_t index;
-    bool is_left, is_right;
-    frame = list_get_instance(block, frame_t, buddy_link);
+    frame_t *frame = list_get_instance(block, frame_t, buddy_link);
-    zone = (zone_t *) b->data;
+    zone_t *zone = (zone_t *) buddy->data;
     ASSERT(IS_BUDDY_ORDER_OK(frame_index_abs(zone, frame),
         frame->buddy_order));
-    is_left = IS_BUDDY_LEFT_BLOCK_ABS(zone, frame);
+    bool is_left = IS_BUDDY_LEFT_BLOCK_ABS(zone, frame);
-    is_right = IS_BUDDY_RIGHT_BLOCK_ABS(zone, frame);
+    bool is_right = IS_BUDDY_RIGHT_BLOCK_ABS(zone, frame);
     ASSERT(is_left ^ is_right);
+    index_t index;
     if (is_left) {
         index = (frame_index(zone, frame)) +
             (1 << frame->buddy_order);
-    } else {    /* if (is_right) */
+    } else {  /* if (is_right) */
         index = (frame_index(zone, frame)) -
             (1 << frame->buddy_order);
+    }
     if (frame_index_valid(zone, index)) {
-        if (zone->frames[index].buddy_order == frame->buddy_order &&
+        if ((zone->frames[index].buddy_order == frame->buddy_order) &&
-            zone->frames[index].refcount == 0) {
+            (zone->frames[index].refcount == 0)) {
             return &zone->frames[index].buddy_link;
+        }
+    }
     return NULL;
+}
 /** Buddy system bisect implementation.
+ *
- * @param b     Buddy system.
+ * @param buddy Buddy system.
- * @param block     Block to bisect.
+ * @param block Block to bisect.
+ *
+ * @return Right block.
+ *
- * @return      Right block.
  */
-static link_t *zone_buddy_bisect(buddy_system_t *b, link_t *block)
+static link_t *zone_buddy_bisect(buddy_system_t *buddy, link_t *block)
+{
-    frame_t *frame_l, *frame_r;
-    frame_l = list_get_instance(block, frame_t, buddy_link);
+    frame_t *frame_l = list_get_instance(block, frame_t, buddy_link);
-    frame_r = (frame_l + (1 << (frame_l->buddy_order - 1)));
+    frame_t *frame_r = (frame_l + (1 << (frame_l->buddy_order - 1)));
     return &frame_r->buddy_link;
+}
 /** Buddy system coalesce implementation.
+ *
- * @param b     Buddy system.
+ * @param buddy   Buddy system.
- * @param block_1   First block.
+ * @param block_1 First block.
- * @param block_2   First block's buddy.
+ * @param block_2 First block's buddy.
+ *
+ * @return Coalesced block (actually block that represents lower
+ *         address).
+ *
- * @return      Coalesced block (actually block that represents lower
- *          address).
  */
-static link_t *zone_buddy_coalesce(buddy_system_t *b, link_t *block_1,
+static link_t *zone_buddy_coalesce(buddy_system_t *buddy, link_t *block_1,
     link_t *block_2)
+{
-    frame_t *frame1, *frame2;
-    frame1 = list_get_instance(block_1, frame_t, buddy_link);
+    frame_t *frame1 = list_get_instance(block_1, frame_t, buddy_link);
-    frame2 = list_get_instance(block_2, frame_t, buddy_link);
+    frame_t *frame2 = list_get_instance(block_2, frame_t, buddy_link);
-    return frame1 < frame2 ? block_1 : block_2;
+    return ((frame1 < frame2) ? block_1 : block_2);
+}
 /** Buddy system set_order implementation.
+ *
- * @param b     Buddy system.
+ * @param buddy Buddy system.
- * @param block     Buddy system block.
+ * @param block Buddy system block.
- * @param order     Order to set.
+ * @param order Order to set.
+ *
  */
-static void zone_buddy_set_order(buddy_system_t *b, link_t *block,
+static void zone_buddy_set_order(buddy_system_t *buddy, link_t *block,
     uint8_t order)
+{
-    frame_t *frame;
-    frame = list_get_instance(block, frame_t, buddy_link);
+    list_get_instance(block, frame_t, buddy_link)->buddy_order = order;
-    frame->buddy_order = order;
+}
 /** Buddy system get_order implementation.
+ *
- * @param b     Buddy system.
+ * @param buddy Buddy system.
- * @param block     Buddy system block.
+ * @param block Buddy system block.
+ *
+ * @return Order of block.
+ *
- * @return      Order of block.
  */
-static uint8_t zone_buddy_get_order(buddy_system_t *b, link_t *block)
+static uint8_t zone_buddy_get_order(buddy_system_t *buddy, link_t *block)
+{
-    frame_t *frame;
-    frame = list_get_instance(block, frame_t, buddy_link);
+    return list_get_instance(block, frame_t, buddy_link)->buddy_order;
-    return frame->buddy_order;
+}
 /** Buddy system mark_busy implementation.
+ *
- * @param b     Buddy system.
+ * @param buddy Buddy system.
- * @param block     Buddy system block.
+ * @param block Buddy system block.
+ *
  */
-static void zone_buddy_mark_busy(buddy_system_t *b, link_t * block)
+static void zone_buddy_mark_busy(buddy_system_t *buddy, link_t * block)
+{
-    frame_t * frame;
-    frame = list_get_instance(block, frame_t, buddy_link);
+    list_get_instance(block, frame_t, buddy_link)->refcount = 1;
-    frame->refcount = 1;
+}
 /** Buddy system mark_available implementation.
+ *
- * @param b     Buddy system.
+ * @param buddy Buddy system.
- * @param block     Buddy system block.
+ * @param block Buddy system block.
  */
-static void zone_buddy_mark_available(buddy_system_t *b, link_t *block)
+static void zone_buddy_mark_available(buddy_system_t *buddy, link_t *block)
+{
-    frame_t *frame;
-    frame = list_get_instance(block, frame_t, buddy_link);
+    list_get_instance(block, frame_t, buddy_link)->refcount = 0;
-    frame->refcount = 0;
+}
 static buddy_system_operations_t zone_buddy_system_operations = {
     .find_buddy = zone_buddy_find_buddy,
     .bisect = zone_buddy_bisect,
 /* Zone functions */
 /******************/
 /** Allocate frame in particular zone.
+ *
- * Assume zone is locked.
+ * Assume zone is locked and is available for allocation.
  * Panics if allocation is impossible.
+ *
- * @param zone      Zone to allocate from.
+ * @param zone  Zone to allocate from.
- * @param order     Allocate exactly 2^order frames.
+ * @param order Allocate exactly 2^order frames.
+ *
- * @return      Frame index in zone.
+ * @return Frame index in zone.
+ *
  */
 static pfn_t zone_frame_alloc(zone_t *zone, uint8_t order)
+{
-    pfn_t v;
-    link_t *tmp;
-    frame_t *frame;
+    ASSERT(zone_flags_available(zone->flags));
     /* Allocate frames from zone buddy system */
-    tmp = buddy_system_alloc(zone->buddy_system, order);
+    link_t *link = buddy_system_alloc(zone->buddy_system, order);
-    ASSERT(tmp);
+    ASSERT(link);
     /* Update zone information. */
     zone->free_count -= (1 << order);
     zone->busy_count += (1 << order);
     /* Frame will be actually a first frame of the block. */
-    frame = list_get_instance(tmp, frame_t, buddy_link);
+    frame_t *frame = list_get_instance(link, frame_t, buddy_link);
-    /* get frame address */
+    /* Get frame address */
-    v = make_frame_index(zone, frame);
+    return make_frame_index(zone, frame);
-    return v;
+}
 /** Free frame from zone.
+ *
- * Assume zone is locked.
+ * Assume zone is locked and is available for deallocation.
+ *
+ * @param zone      Pointer to zone from which the frame is to be freed.
+ * @param frame_idx Frame index relative to zone.
+ *
- * @param zone      Pointer to zone from which the frame is to be freed.
- * @param frame_idx Frame index relative to zone.
  */
 static void zone_frame_free(zone_t *zone, index_t frame_idx)
+{
-    frame_t *frame;
+    ASSERT(zone_flags_available(zone->flags));
-    uint8_t order;
+    frame_t *frame = &zone->frames[frame_idx];
+    /* Remember frame order */
-    frame = &zone->frames[frame_idx];
+    uint8_t order = frame->buddy_order;
-    /* remember frame order */
-    order = frame->buddy_order;
     ASSERT(frame->refcount);
     if (!--frame->refcount) {
         buddy_system_free(zone->buddy_system, &frame->buddy_link);
         /* Update zone information. */
         zone->free_count += (1 << order);
         zone->busy_count -= (1 << order);
+    }
+}
+}
 /** Mark frame in zone unavailable to allocation. */
 static void zone_mark_unavailable(zone_t *zone, index_t frame_idx)
+{
-    frame_t *frame;
+    ASSERT(zone_flags_available(zone->flags));
-    link_t *link;
-    frame = zone_get_frame(zone, frame_idx);
+    frame_t *frame = zone_get_frame(zone, frame_idx);
     if (frame->refcount)
         return;
-    link = buddy_system_alloc_block(zone->buddy_system,
+    link_t *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.
+/** Merge two zones.
+ *
- * Expect zone_t *z to point to space at least zone_conf_size large.
+ * Expect buddy to point to space at least zone_conf_size large.
+ * Assume z1 & z2 are locked and compatible and zones lock is
+ * locked.
+ *
- * Assume z1 & z2 are locked.
+ * @param z1     First zone to merge.
+ * @param z2     Second zone to merge.
+ * @param old_z1 Original date of the first zone.
+ * @param buddy  Merged zone buddy.
+ *
- * @param z     Target zone structure pointer.
- * @param z1        Zone to merge.
- * @param z2        Zone to merge.
  */
-static void _zone_merge(zone_t *z, zone_t *z1, zone_t *z2)
+static void zone_merge_internal(count_t z1, count_t z2, zone_t *old_z1, buddy_system_t *buddy)
+{
+    ASSERT(zone_flags_available(zones.info[z1].flags));
+    ASSERT(zone_flags_available(zones.info[z2].flags));
+    ASSERT(zones.info[z1].flags == zones.info[z2].flags);
-    uint8_t max_order;
+    ASSERT(zones.info[z1].base < zones.info[z2].base);
+    ASSERT(!overlaps(zones.info[z1].base, zones.info[z1].count,
-    unsigned int i;
+        zones.info[z2].base, zones.info[z2].count));
-    int z2idx;
-    pfn_t frame_idx;
+    /* Difference between zone bases */
-    frame_t *frame;
+    pfn_t base_diff = zones.info[z2].base - zones.info[z1].base;
+    zones.info[z1].count = base_diff + zones.info[z2].count;
+    zones.info[z1].free_count += zones.info[z2].free_count;
-    ASSERT(!overlaps(z1->base, z1->count, z2->base, z2->count));
+    zones.info[z1].busy_count += zones.info[z2].busy_count;
-    ASSERT(z1->base < z2->base);
+    zones.info[z1].buddy_system = buddy;
-    spinlock_initialize(&z->lock, "zone_lock");
+    uint8_t order = fnzb(zones.info[z1].count);
+    buddy_system_create(zones.info[z1].buddy_system, order,
+        &zone_buddy_system_operations, (void *) &zones.info[z1]);
-    z->base = z1->base;
+    zones.info[z1].frames =
-    z->count = z2->base + z2->count - z1->base;
+        (frame_t *) ((uint8_t *) zones.info[z1].buddy_system
-    z->flags = z1->flags & z2->flags;
+        + buddy_conf_size(order));
+    /* This marks all frames busy */
+    count_t i;
-    z->free_count = z1->free_count + z2->free_count;
+    for (i = 0; i < zones.info[z1].count; i++)
-    z->busy_count = z1->busy_count + z2->busy_count;
+        frame_initialize(&zones.info[z1].frames[i]);
-    max_order = fnzb(z->count);
-    z->buddy_system = (buddy_system_t *) &z[1];
-    buddy_system_create(z->buddy_system, max_order,
-        &zone_buddy_system_operations, (void *) z);
-    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,
-     * parents etc. Set all free frames with refcount=0 to 1, because
+     * parents etc. Set all free frames with refcount = 0 to 1, because
-     * we add all free frames to buddy allocator later again, clear
+     * we add all free frames to buddy allocator later again, clearing
-     * order to 0. Don't set busy frames with refcount=0, as they
+     * order to 0. Don't set busy frames with refcount = 0, as they
      * will not be reallocated during merge and it would make later
      * problems with allocation/free.
      */
-    for (i = 0; i < z1->count; i++)
+    for (i = 0; i < old_z1->count; i++)
-        z->frames[i] = z1->frames[i];
+        zones.info[z1].frames[i] = old_z1->frames[i];
-    for (i = 0; i < z2->count; i++) {
+    for (i = 0; i < zones.info[z2].count; i++)
-        z2idx = i + (z2->base - z1->base);
+        zones.info[z1].frames[base_diff + i]
-        z->frames[z2idx] = z2->frames[i];
+            = zones.info[z2].frames[i];
-    }
     i = 0;
-    while (i < z->count) {
+    while (i < zones.info[z1].count) {
-        if (z->frames[i].refcount) {
+        if (zones.info[z1].frames[i].refcount) {
-            /* skip busy frames */
+            /* Skip busy frames */
-            i += 1 << z->frames[i].buddy_order;
+            i += 1 << zones.info[z1].frames[i].buddy_order;
+        } else {
-        } else { /* Free frames, set refcount=1 */
+            /* Free frames, set refcount = 1
-            /* All free frames have refcount=0, we need not
+             * (all free frames have refcount == 0, we need not
-             * to check the order */
+             * to check the order)
+             */
-            z->frames[i].refcount = 1;
+            zones.info[z1].frames[i].refcount = 1;
-            z->frames[i].buddy_order = 0;
+            zones.info[z1].frames[i].buddy_order = 0;
             i++;
+        }
+    }
-    /* Add free blocks from the 2 original zones */
+    /* Add free blocks from the original zone z1 */
-    while (zone_can_alloc(z1, 0)) {
+    while (zone_can_alloc(old_z1, 0)) {
+        /* Allocate from the original zone */
-        frame_idx = zone_frame_alloc(z1, 0);
+        pfn_t frame_idx = zone_frame_alloc(old_z1, 0);
+        /* Free the frame from the merged zone */
-        frame = &z->frames[frame_idx];
+        frame_t *frame = &zones.info[z1].frames[frame_idx];
         frame->refcount = 0;
-        buddy_system_free(z->buddy_system, &frame->buddy_link);
+        buddy_system_free(zones.info[z1].buddy_system, &frame->buddy_link);
+    }
+    /* Add free blocks from the original zone z2 */
-    while (zone_can_alloc(z2, 0)) {
+    while (zone_can_alloc(&zones.info[z2], 0)) {
+        /* Allocate from the original zone */
-        frame_idx = zone_frame_alloc(z2, 0);
+        pfn_t frame_idx = zone_frame_alloc(&zones.info[z2], 0);
+        /* Free the frame from the merged zone */
-        frame = &z->frames[frame_idx + (z2->base - z1->base)];
+        frame_t *frame = &zones.info[z1].frames[base_diff + frame_idx];
         frame->refcount = 0;
-        buddy_system_free(z->buddy_system, &frame->buddy_link);
+        buddy_system_free(zones.info[z1].buddy_system, &frame->buddy_link);
+    }
+}
 /** Return old configuration frames into the zone.
+ *
- * We have several cases
+ * We have two cases:
+ * - The configuration data is outside the zone
- * - the conf. data is outside of zone -> exit, shall we call frame_free??
+ *   -> do nothing (perhaps call frame_free?)
- * - the conf. data was created by zone_create or
+ * - The configuration data was created by zone_create
- *   updated with reduce_region -> free every frame
+ *   or updated by reduce_region -> free every frame
  *
- * @param newzone   The actual zone where freeing should occur.
+ * @param znum  The actual zone where freeing should occur.
- * @param oldzone   Pointer to old zone configuration data that should
+ * @param pfn   Old zone configuration frame.
- *          be freed from new zone.
+ * @param count Old zone frame count.
+ *
  */
-static void return_config_frames(zone_t *newzone, zone_t *oldzone)
+static void return_config_frames(count_t znum, pfn_t pfn, count_t count)
+{
-    pfn_t pfn;
-    frame_t *frame;
-    count_t cframes;
-    unsigned int i;
+    ASSERT(zone_flags_available(zones.info[znum].flags));
-    pfn = ADDR2PFN((uintptr_t)KA2PA(oldzone));
-    cframes = SIZE2FRAMES(zone_conf_size(oldzone->count));
+    count_t cframes = SIZE2FRAMES(zone_conf_size(count));
+    if ((pfn < zones.info[znum].base)
-    if (pfn < newzone->base || pfn >= newzone->base + newzone->count)
+        || (pfn >= zones.info[znum].base + zones.info[znum].count))
         return;
+    frame_t *frame
-    frame = &newzone->frames[pfn - newzone->base];
+        = &zones.info[znum].frames[pfn - zones.info[znum].base];
     ASSERT(!frame->buddy_order);
+    count_t i;
     for (i = 0; i < cframes; i++) {
-        newzone->busy_count++;
+        zones.info[znum].busy_count++;
-        zone_frame_free(newzone, pfn+i-newzone->base);
+        zone_frame_free(&zones.info[znum],
+            pfn - zones.info[znum].base + i);
+    }
+}
 /** Reduce allocated block to count of order 0 frames.
+ *
- * The allocated block need 2^order frames of space. Reduce all frames
+ * The allocated block needs 2^order frames. Reduce all frames
- * in block to order 0 and free the unneeded frames. This means, that
+ * in the block to order 0 and free the unneeded frames. This means that
  * when freeing the previously allocated block starting with frame_idx,
  * you have to free every frame.
+ *
- * @param zone
+ * @param znum      Zone.
- * @param frame_idx     Index to block.
+ * @param frame_idx Index the first frame of the block.
- * @param count         Allocated space in block.
+ * @param count     Allocated frames in block.
+ *
  */
-static void zone_reduce_region(zone_t *zone, pfn_t frame_idx, count_t count)
+static void zone_reduce_region(count_t znum, pfn_t frame_idx, count_t count)
+{
-    count_t i;
-    uint8_t order;
+    ASSERT(zone_flags_available(zones.info[znum].flags));
-    frame_t *frame;
+    ASSERT(frame_idx + count < zones.info[znum].count);
-    ASSERT(frame_idx + count < zone->count);
-    order = zone->frames[frame_idx].buddy_order;
+    uint8_t order = zones.info[znum].frames[frame_idx].buddy_order;
     ASSERT((count_t) (1 << order) >= count);
     /* Reduce all blocks to order 0 */
+    count_t i;
     for (i = 0; i < (count_t) (1 << order); i++) {
-        frame = &zone->frames[i + frame_idx];
+        frame_t *frame = &zones.info[znum].frames[i + frame_idx];
         frame->buddy_order = 0;
         if (!frame->refcount)
             frame->refcount = 1;
         ASSERT(frame->refcount == 1);
+    }
     /* Free unneeded frames */
-    for (i = count; i < (count_t) (1 << order); i++) {
+    for (i = count; i < (count_t) (1 << order); i++)
-        zone_frame_free(zone, i + frame_idx);
+        zone_frame_free(&zones.info[znum], i + frame_idx);
-    }
+}
 /** Merge zones z1 and z2.
+ *
- * - the zones must be 2 zones with no zone existing in between,
+ * The merged zones must be 2 zones with no zone existing in between
+ * (which means that z2 = z1 + 1). Both zones must be available zones
- *   which means that z2 = z1+1
+ * with the same flags.
+ *
+ * When you create a new zone, the frame allocator configuration does
+ * 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
+ *
- * - When you create a new zone, the frame allocator configuration does
- *   not to be 2^order size. Once the allocator is running it is no longer
- *   possible, merged configuration data occupies more space :-/
  */
-void zone_merge(unsigned int z1, unsigned int z2)
+bool zone_merge(count_t z1, count_t z2)
+{
-    ipl_t ipl;
-    zone_t *zone1, *zone2, *newzone;
-    unsigned int cframes;
-    uint8_t order;
-    unsigned int i;
-    pfn_t pfn;
-    ipl = interrupts_disable();
+    ipl_t ipl = interrupts_disable();
     spinlock_lock(&zones.lock);
-    if ((z1 >= zones.count) || (z2 >= zones.count))
-        goto errout;
+    bool ret = true;
-    /* We can join only 2 zones with none existing inbetween */
+    /* We can join only 2 zones with none existing inbetween,
+     * the zones have to be available and with the same
+     * set of flags
+     */
+    if ((z1 >= zones.count) || (z2 >= zones.count)
-    if (z2 - z1 != 1)
+        || (z2 - z1 != 1)
+        || (!zone_flags_available(zones.info[z1].flags))
+        || (!zone_flags_available(zones.info[z2].flags))
+        || (zones.info[z1].flags != zones.info[z2].flags)) {
+        ret = false;
         goto errout;
+    }
-    zone1 = zones.info[z1];
+    pfn_t cframes = SIZE2FRAMES(zone_conf_size(
-    zone2 = zones.info[z2];
+        zones.info[z2].base - zones.info[z1].base
-    spinlock_lock(&zone1->lock);
-    spinlock_lock(&zone2->lock);
+        + zones.info[z2].count));
-    cframes = SIZE2FRAMES(zone_conf_size(zone2->base + zone2->count -
-        zone1->base));
+    uint8_t order;
     if (cframes == 1)
         order = 0;
-    else
-        order = fnzb(cframes - 1) + 1;
-    /* Allocate zonedata inside one of the zones */
-    if (zone_can_alloc(zone1, order))
-        pfn = zone1->base + zone_frame_alloc(zone1, order);
-    else if (zone_can_alloc(zone2, order))
-        pfn = zone2->base + zone_frame_alloc(zone2, order);
     else
+        order = fnzb(cframes - 1) + 1;
+    /* Allocate merged zone data inside one of the zones */
+    pfn_t pfn;
+    if (zone_can_alloc(&zones.info[z1], order)) {
+        pfn = zones.info[z1].base + zone_frame_alloc(&zones.info[z1], order);
+    } else if (zone_can_alloc(&zones.info[z2], order)) {
+        pfn = zones.info[z2].base + zone_frame_alloc(&zones.info[z2], order);
+    } else {
+        ret = false;
-        goto errout2;
+        goto errout;
+    }
+    /* Preserve original data from z1 */
-    newzone = (zone_t *) PA2KA(PFN2ADDR(pfn));
+    zone_t old_z1 = zones.info[z1];
+    old_z1.buddy_system->data = (void *) &old_z1;
+    /* Do zone merging */
+    buddy_system_t *buddy = (buddy_system_t *) PA2KA(PFN2ADDR(pfn));
-    _zone_merge(newzone, zone1, zone2);
+    zone_merge_internal(z1, z2, &old_z1, buddy);
     /* Free unneeded config frames */
-    zone_reduce_region(newzone, pfn - newzone->base,  cframes);
+    zone_reduce_region(z1, pfn - zones.info[z1].base, cframes);
     /* Subtract zone information from busy frames */
-    newzone->busy_count -= cframes;
+    zones.info[z1].busy_count -= cframes;
-    /* Replace existing zones in zoneinfo list */
+    /* Free old zone information */
+    return_config_frames(z1,
+        ADDR2PFN(KA2PA((uintptr_t) old_z1.frames)), old_z1.count);
+    return_config_frames(z1,
+        ADDR2PFN(KA2PA((uintptr_t) zones.info[z2].frames)),
-    zones.info[z1] = newzone;
+        zones.info[z2].count);
+    /* Shift existing zones */
+    count_t i;
     for (i = z2 + 1; i < zones.count; i++)
         zones.info[i - 1] = zones.info[i];
     zones.count--;
-    /* Free old zone information */
-    return_config_frames(newzone, zone1);
-    return_config_frames(newzone, zone2);
-errout2:
-    /* Nobody is allowed to enter to zone, so we are safe
-     * to touch the spinlocks last time */
-    spinlock_unlock(&zone1->lock);
-    spinlock_unlock(&zone2->lock);
 errout:
     spinlock_unlock(&zones.lock);
     interrupts_restore(ipl);
+    return ret;
+}
-/** Merge all zones into one big zone.
+/** Merge all mergeable zones into one big zone.
+ *
+ * It is reasonable to do this on systems where
+ * BIOS reports parts in chunks, so that we could
+ * have 1 zone (it's faster).
+ *
- * It is reasonable to do this on systems whose bios reports parts in chunks,
- * so that we could have 1 zone (it's faster).
  */
 void zone_merge_all(void)
+{
-    int count = zones.count;
+    count_t i = 0;
-    while (zones.count > 1 && --count) {
+    while (i < zones.count) {
-        zone_merge(0, 1);
+        if (!zone_merge(i, i + 1))
-        break;
+            i++;
+    }
+}
 /** Create new frame zone.
+ *
+ * @param zone  Zone to construct.
+ * @param buddy Address of buddy system configuration information.
- * @param start     Physical address of the first frame within the zone.
+ * @param start Physical address of the first frame within the zone.
- * @param count     Count of frames in zone.
+ * @param count Count of frames in zone.
- * @param z     Address of configuration information of zone.
+ * @param flags Zone flags.
+ *
- * @param flags     Zone flags.
+ * @return Initialized zone.
+ *
- * @return      Initialized zone.
  */
-static void zone_construct(pfn_t start, count_t count, zone_t *z, int flags)
+static void zone_construct(zone_t *zone, buddy_system_t *buddy, pfn_t start, count_t count, zone_flags_t flags)
+{
-    unsigned int i;
-    uint8_t max_order;
-    spinlock_initialize(&z->lock, "zone_lock");
-    z->base = start;
+    zone->base = start;
-    z->count = count;
+    zone->count = count;
-    /* Mask off flags that are calculated automatically. */
-    flags &= ~FRAME_LOW_4_GiB;
-    /* Determine calculated flags. */
-    if (z->base + count < (1ULL << (32 - FRAME_WIDTH))) /* 4 GiB */
-        flags |= FRAME_LOW_4_GiB;
-    z->flags = flags;
+    zone->flags = flags;
-    z->free_count = count;
+    zone->free_count = count;
-    z->busy_count = 0;
+    zone->busy_count = 0;
-    /*
-     * Compute order for buddy system, initialize
-     */
-    max_order = fnzb(count);
-    z->buddy_system = (buddy_system_t *)&z[1];
+    zone->buddy_system = buddy;
-    buddy_system_create(z->buddy_system, max_order,
-        &zone_buddy_system_operations, (void *) z);
+    if (zone_flags_available(flags)) {
+        /*
+         * Compute order for buddy system and initialize
+         */
+        uint8_t order = fnzb(count);
+        buddy_system_create(zone->buddy_system, order,
+            &zone_buddy_system_operations, (void *) zone);
-    /* Allocate frames _after_ the conframe */
+        /* Allocate frames _after_ the confframe */
-    /* Check sizes */
+        /* Check sizes */
-    z->frames = (frame_t *)((uint8_t *) z->buddy_system +
+        zone->frames = (frame_t *) ((uint8_t *) zone->buddy_system +
-        buddy_conf_size(max_order));
+            buddy_conf_size(order));
+        count_t i;
-    for (i = 0; i < count; i++) {
+        for (i = 0; i < count; i++)
-        frame_initialize(&z->frames[i]);
+            frame_initialize(&zone->frames[i]);
-    }
-    /* Stuffing frames */
+        /* Stuffing frames */
-    for (i = 0; i < count; i++) {
+        for (i = 0; i < count; i++) {
-        z->frames[i].refcount = 0;
+            zone->frames[i].refcount = 0;
-        buddy_system_free(z->buddy_system, &z->frames[i].buddy_link);
+            buddy_system_free(zone->buddy_system, &zone->frames[i].buddy_link);
-    }
+        }
+    } else
+        zone->frames = NULL;
+}
 /** Compute configuration data size for zone.
+ *
- * @param count     Size of zone in frames.
+ * @param count Size of zone in frames.
+ *
- * @return      Size of zone configuration info (in bytes).
+ * @return Size of zone configuration info (in bytes).
+ *
  */
 uintptr_t zone_conf_size(count_t count)
+{
-    int size = sizeof(zone_t) + count * sizeof(frame_t);
+    return (count * sizeof(frame_t) + buddy_conf_size(fnzb(count)));
-    int max_order;
-    max_order = fnzb(count);
-    size += buddy_conf_size(max_order);
-    return size;
+}
 /** Create and add zone to system.
+ *
  * @param start     First frame number (absolute).
  * @param count     Size of zone in frames.
  * @param confframe Where configuration frames are supposed to be.
- *          Automatically checks, that we will not disturb the
+ *                  Automatically checks, that we will not disturb the
- *          kernel and possibly init.  If confframe is given
+ *                  kernel and possibly init. If confframe is given
- *          _outside_ this zone, it is expected, that the area is
+ *                  _outside_ this zone, it is expected, that the area is
- *          already marked BUSY and big enough to contain
+ *                  already marked BUSY and big enough to contain
- *          zone_conf_size() amount of data.  If the confframe is
+ *                  zone_conf_size() amount of data. If the confframe is
- *          inside the area, the zone free frame information is
+ *                  inside the area, the zone free frame information is
- *          modified not to include it.
+ *                  modified not to include it.
  *
- * @return      Zone number or -1 on error.
+ * @return Zone number or -1 on error.
+ *
  */
-int zone_create(pfn_t start, count_t count, pfn_t confframe, int flags)
+count_t zone_create(pfn_t start, count_t count, pfn_t confframe, zone_flags_t flags)
 {
-    zone_t *z;
-    uintptr_t addr;
+    ipl_t ipl = interrupts_disable();
-    count_t confcount;
+    spinlock_lock(&zones.lock);
-    unsigned int i;
-    int znum;
+    if (zone_flags_available(flags)) {  /* Create available zone */
-    /* Theoretically we could have here 0, practically make sure
+        /* Theoretically we could have NULL here, practically make sure
-     * nobody tries to do that. If some platform requires, remove
+         * nobody tries to do that. If some platform requires, remove
-     * the assert
+         * the assert
-     */
+         */
-    ASSERT(confframe);
+        ASSERT(confframe != NULL);
-    /* If conframe is supposed to be inside our zone, then make sure
+        /* If confframe is supposed to be inside our zone, then make sure
-     * it does not span kernel & init
+         * it does not span kernel & init
-     */
+         */
-    confcount = SIZE2FRAMES(zone_conf_size(count));
+        count_t 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);
+                uintptr_t 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),
-                KA2PA(config.stack_base), config.stack_size))
-                continue;
+                    continue;
-            bool overlap = false;
-            count_t i;
-            for (i = 0; i < init.cnt; i++)
                 if (overlaps(addr, PFN2ADDR(confcount),
+                    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),
+                        KA2PA(init.tasks[i].addr),
-                    init.tasks[i].size)) {
+                        init.tasks[i].size)) {
-                    overlap = true;
+                        overlap = true;
-                    break;
+                        break;
-                }
+                    }
-            if (overlap)
+                if (overlap)
-                continue;
+                    continue;
+                break;
+            }
-            break;
+            if (confframe >= start + count)
+                panic("Cannot find configuration data for zone.");
+        }
-        if (confframe >= start + count)
-            panic("Cannot find configuration data for zone.");
-    }
-    z = (zone_t *) PA2KA(PFN2ADDR(confframe));
+        count_t znum = zones_insert_zone(start, count);
-    zone_construct(start, count, z, flags);
+        if (znum == (count_t) -1) {
-    znum = zones_add_zone(z);
+            spinlock_unlock(&zones.lock);
-    if (znum == -1)
+            interrupts_restore(ipl);
-        return -1;
+            return (count_t) -1;
+        }
-    mutex_lock(&mem_avail_mtx);
+        buddy_system_t *buddy = (buddy_system_t *) PA2KA(PFN2ADDR(confframe));
-    mem_avail_frames += count;
-    mutex_unlock(&mem_avail_mtx);
+        zone_construct(&zones.info[znum], buddy, start, count, flags);
-    /* If confdata in zone, mark as unavailable */
+        /* If confdata in zone, mark as unavailable */
-    if (confframe >= start && confframe < start + count)
+        if ((confframe >= start) && (confframe < start + count)) {
+            count_t i;
-        for (i = confframe; i < confframe + confcount; i++) {
+            for (i = confframe; i < confframe + confcount; i++)
-            zone_mark_unavailable(z, i - z->base);
+                zone_mark_unavailable(&zones.info[znum],
+                    i - zones.info[znum].base);
+        }
+        spinlock_unlock(&zones.lock);
+        interrupts_restore(ipl);
+        return znum;
+    }
+    /* Non-available zone */
+    count_t znum = zones_insert_zone(start, count);
+    if (znum == (count_t) -1) {
+        spinlock_unlock(&zones.lock);
+        interrupts_restore(ipl);
+        return (count_t) -1;
+    }
+    zone_construct(&zones.info[znum], NULL, start, count, flags);
+    spinlock_unlock(&zones.lock);
+    interrupts_restore(ipl);
     return znum;
+}
-/***************************************/
+/*******************/
 /* Frame functions */
+/*******************/
 /** Set parent of frame. */
-void frame_set_parent(pfn_t pfn, void *data, unsigned int hint)
+void frame_set_parent(pfn_t pfn, void *data, count_t hint)
+{
+    ipl_t ipl = interrupts_disable();
+    spinlock_lock(&zones.lock);
-    zone_t *zone = find_zone_and_lock(pfn, &hint);
+    count_t znum = find_zone(pfn, hint);
-    ASSERT(zone);
+    ASSERT(znum != (count_t) -1);
+    zone_get_frame(&zones.info[znum],
-    zone_get_frame(zone, pfn - zone->base)->parent = data;
+        pfn - zones.info[znum].base)->parent = data;
-    spinlock_unlock(&zone->lock);
+    spinlock_unlock(&zones.lock);
+    interrupts_restore(ipl);
+}
-void *frame_get_parent(pfn_t pfn, unsigned int hint)
+void *frame_get_parent(pfn_t pfn, count_t hint)
+{
-    zone_t *zone = find_zone_and_lock(pfn, &hint);
+    ipl_t ipl = interrupts_disable();
-    void *res;
+    spinlock_lock(&zones.lock);
+    count_t znum = find_zone(pfn, hint);
-    ASSERT(zone);
+    ASSERT(znum != (count_t) -1);
+    void *res = zone_get_frame(&zones.info[znum],
-    res = zone_get_frame(zone, pfn - zone->base)->parent;
+        pfn - zones.info[znum].base)->parent;
+    spinlock_unlock(&zones.lock);
+    interrupts_restore(ipl);
-    spinlock_unlock(&zone->lock);
     return res;
+}
 /** Allocate power-of-two frames of physical memory.
+ *
- * @param order     Allocate exactly 2^order frames.
+ * @param order Allocate exactly 2^order frames.
- * @param flags     Flags for host zone selection and address processing.
+ * @param flags Flags for host zone selection and address processing.
- * @param pzone     Preferred zone.
+ * @param pzone Preferred zone.
+ *
- * @return      Physical address of the allocated frame.
+ * @return Physical address of the allocated frame.
+ *
  */
-void *frame_alloc_generic(uint8_t order, int flags, unsigned int *pzone)
+void *frame_alloc_generic(uint8_t order, frame_flags_t flags, count_t *pzone)
+{
+    count_t size = ((count_t) 1) << order;
     ipl_t ipl;
-    int freed;
-    pfn_t v;
-    zone_t *zone;
-    unsigned long gen = 0;
+    count_t hint = pzone ? (*pzone) : 0;
 loop:
     ipl = interrupts_disable();
+    spinlock_lock(&zones.lock);
     /*
      * First, find suitable frame zone.
      */
-    zone = find_free_zone_and_lock(order, flags, pzone);
+    count_t znum = find_free_zone(order,
+        FRAME_TO_ZONE_FLAGS(flags), hint);
     /* If no memory, reclaim some slab memory,
        if it does not help, reclaim all */
-    if (!zone && !(flags & FRAME_NO_RECLAIM)) {
+    if ((znum == (count_t) -1) && (!(flags & FRAME_NO_RECLAIM))) {
-        freed = slab_reclaim(0);
+        count_t freed = slab_reclaim(0);
-        if (freed)
+        if (freed > 0)
-            zone = find_free_zone_and_lock(order, flags, pzone);
+            znum = find_free_zone(order,
+                FRAME_TO_ZONE_FLAGS(flags), hint);
-        if (!zone) {
+        if (znum == (count_t) -1) {
             freed = slab_reclaim(SLAB_RECLAIM_ALL);
-            if (freed)
+            if (freed > 0)
-                zone = find_free_zone_and_lock(order, flags,
+                znum = find_free_zone(order,
-                    pzone);
+                    FRAME_TO_ZONE_FLAGS(flags), hint);
+        }
+    }
-    if (!zone) {
-        /*
-         * Sleep until some frames are available again.
+    if (znum == (count_t) -1) {
-         */
         if (flags & FRAME_ATOMIC) {
+            spinlock_unlock(&zones.lock);
             interrupts_restore(ipl);
-            return 0;
+            return NULL;
+        }
 #ifdef CONFIG_DEBUG
-        unsigned long avail;
-        mutex_lock(&mem_avail_mtx);
-        avail = mem_avail_frames;
+        count_t avail = total_frames_free();
-        mutex_unlock(&mem_avail_mtx);
-        printf("Thread %" PRIu64 " waiting for %u frames, "
-            "%u available.\n", THREAD->tid, 1ULL << order, avail);
 #endif
+        spinlock_unlock(&zones.lock);
+        interrupts_restore(ipl);
+        /*
+         * Sleep until some frames are available again.
+         */
+#ifdef CONFIG_DEBUG
+        printf("Thread %" PRIu64 " waiting for %" PRIc " frames, "
+            "%" PRIc " available.\n", THREAD->tid, size, avail);
+#endif
         mutex_lock(&mem_avail_mtx);
-        while ((mem_avail_frames < (1ULL << order)) ||
+        if (mem_avail_req > 0)
+            mem_avail_req = min(mem_avail_req, size);
+        else
+            mem_avail_req = size;
+        count_t gen = mem_avail_gen;
-            gen == mem_avail_gen)
+        while (gen == mem_avail_gen)
             condvar_wait(&mem_avail_cv, &mem_avail_mtx);
-        gen = mem_avail_gen;
         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, %u frames available.\n",
+        printf("Thread %" PRIu64 " woken up.\n", THREAD->tid);
-            THREAD->tid, avail);
 #endif
-        interrupts_restore(ipl);
         goto loop;
+    }
-    v = zone_frame_alloc(zone, order);
+    pfn_t pfn = zone_frame_alloc(&zones.info[znum], order)
-    v += zone->base;
+        + zones.info[znum].base;
-    spinlock_unlock(&zone->lock);
-    mutex_lock(&mem_avail_mtx);
-    mem_avail_frames -= (1ULL << order);
-    mutex_unlock(&mem_avail_mtx);
+    spinlock_unlock(&zones.lock);
     interrupts_restore(ipl);
+    if (pzone)
+        *pzone = znum;
     if (flags & FRAME_KA)
-        return (void *)PA2KA(PFN2ADDR(v));
+        return (void *) PA2KA(PFN2ADDR(pfn));
-    return (void *)PFN2ADDR(v);
+    return (void *) PFN2ADDR(pfn);
+}
 /** Free a frame.
+ *
  * Find respective frame structure for supplied physical frame address.
+ * Decrement frame reference count. If it drops to zero, move the frame
- * Decrement frame reference count.
+ * structure to free list.
+ *
- * If it drops to zero, move the frame structure to free list.
+ * @param frame Physical Address of of the frame to be freed.
+ *
- * @param frame     Physical Address of of the frame to be freed.
  */
 void frame_free(uintptr_t frame)
+{
-    ipl_t ipl;
-    zone_t *zone;
-    pfn_t pfn = ADDR2PFN(frame);
+    ipl_t ipl = interrupts_disable();
-    ipl = interrupts_disable();
+    spinlock_lock(&zones.lock);
     /*
      * First, find host frame zone for addr.
      */
+    pfn_t pfn = ADDR2PFN(frame);
-    zone = find_zone_and_lock(pfn, NULL);
+    count_t znum = find_zone(pfn, NULL);
-    ASSERT(zone);
+    ASSERT(znum != (count_t) -1);
-    zone_frame_free(zone, pfn - zone->base);
+    zone_frame_free(&zones.info[znum], pfn - zones.info[znum].base);
-    spinlock_unlock(&zone->lock);
+    spinlock_unlock(&zones.lock);
+    interrupts_restore(ipl);
     /*
      * Signal that some memory has been freed.
      */
     mutex_lock(&mem_avail_mtx);
+    if (mem_avail_req > 0)
-    mem_avail_frames++;
+        mem_avail_req--;
+    if (mem_avail_req == 0) {
-    mem_avail_gen++;
+        mem_avail_gen++;
-    condvar_broadcast(&mem_avail_cv);
+        condvar_broadcast(&mem_avail_cv);
+    }
     mutex_unlock(&mem_avail_mtx);
-    interrupts_restore(ipl);
+}
 /** Add reference to frame.
+ *
  * Find respective frame structure for supplied PFN and
  * increment frame reference count.
+ *
- * @param pfn       Frame number of the frame to be freed.
+ * @param pfn Frame number of the frame to be freed.
+ *
  */
 void frame_reference_add(pfn_t pfn)
+{
-    ipl_t ipl;
+    ipl_t ipl = interrupts_disable();
-    zone_t *zone;
-    frame_t *frame;
-    ipl = interrupts_disable();
+    spinlock_lock(&zones.lock);
     /*
      * First, find host frame zone for addr.
      */
-    zone = find_zone_and_lock(pfn, NULL);
+    count_t znum = find_zone(pfn, NULL);
-    ASSERT(zone);
+    ASSERT(znum != (count_t) -1);
-    frame = &zone->frames[pfn - zone->base];
+    zones.info[znum].frames[pfn - zones.info[znum].base].refcount++;
-    frame->refcount++;
-    spinlock_unlock(&zone->lock);
+    spinlock_unlock(&zones.lock);
     interrupts_restore(ipl);
+}
 /** Mark given range unavailable in frame zones. */
 void frame_mark_unavailable(pfn_t start, count_t count)
+{
-    unsigned int i;
+    ipl_t ipl = interrupts_disable();
-    zone_t *zone;
-    unsigned int prefzone = 0;
+    spinlock_lock(&zones.lock);
+    count_t i;
     for (i = 0; i < count; i++) {
-        zone = find_zone_and_lock(start + i, &prefzone);
+        count_t znum = find_zone(start + i, 0);
-        if (!zone) /* PFN not found */
+        if (znum == (count_t) -1)  /* PFN not found */
             continue;
-        zone_mark_unavailable(zone, start + i - zone->base);
+        zone_mark_unavailable(&zones.info[znum],
-        spinlock_unlock(&zone->lock);
+            start + i - zones.info[znum].base);
+    }
+    spinlock_unlock(&zones.lock);
+    interrupts_restore(ipl);
+}
 /** Initialize physical memory management. */
 void frame_init(void)
+{
         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)),
             SIZE2FRAMES(config.kernel_size));
         for (i = 0; i < init.cnt; i++) {
             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));
         /* Black list first frame, as allocating NULL would
-         * fail in some places */
+         * fail in some places
+         */
         frame_mark_unavailable(0, 1);
+    }
+}
 /** Return total size of all zones. */
 uint64_t zone_total_size(void)
+{
-    zone_t *zone = NULL;
-    unsigned int i;
-    ipl_t ipl;
-    uint64_t total = 0;
-    ipl = interrupts_disable();
+    ipl_t ipl = interrupts_disable();
     spinlock_lock(&zones.lock);
-    for (i = 0; i < zones.count; i++) {
+    uint64_t total = 0;
-        zone = zones.info[i];
+    count_t i;
-        spinlock_lock(&zone->lock);
+    for (i = 0; i < zones.count; i++)
-        total += (uint64_t) FRAMES2SIZE(zone->count);
+        total += (uint64_t) FRAMES2SIZE(zones.info[i].count);
-        spinlock_unlock(&zone->lock);
-    }
     spinlock_unlock(&zones.lock);
     interrupts_restore(ipl);
     return total;
+}
 /** Prints list of zones. */
 void zone_print_list(void)
+{
-    zone_t *zone = NULL;
-    unsigned int i;
-    ipl_t ipl;
 #ifdef __32_BITS__
-    printf("#  base address free frames  busy frames\n");
+    printf("#  base address flags    free frames  busy frames\n");
-    printf("-- ------------ ------------ ------------\n");
+    printf("-- ------------ -------- ------------ ------------\n");
 #endif
 #ifdef __64_BITS__
-    printf("#  base address         free frames  busy frames\n");
+    printf("#  base address         flags    free frames  busy frames\n");
-    printf("-- -------------------- ------------ ------------\n");
+    printf("-- -------------------- -------- ------------ ------------\n");
 #endif
     /*
      * Because printing may require allocation of memory, we may not hold
      * the frame allocator locks when printing zone statistics.  Therefore,
+     *
      * When someone adds/removes zones while we are printing the statistics,
      * we may end up with inaccurate output (e.g. a zone being skipped from
      * the listing).
      */
-    for (i = 0; ; i++) {
-        uintptr_t base;
-        count_t free_count;
+    count_t i;
-        count_t busy_count;
+    for (i = 0;; i++) {
-        ipl = interrupts_disable();
+        ipl_t ipl = interrupts_disable();
         spinlock_lock(&zones.lock);
         if (i >= zones.count) {
             spinlock_unlock(&zones.lock);
             interrupts_restore(ipl);
             break;
+        }
-        zone = zones.info[i];
+        uintptr_t base = PFN2ADDR(zones.info[i].base);
-        spinlock_lock(&zone->lock);
+        zone_flags_t flags = zones.info[i].flags;
-        base = PFN2ADDR(zone->base);
-        free_count = zone->free_count;
+        count_t free_count = zones.info[i].free_count;
-        busy_count = zone->busy_count;
+        count_t busy_count = zones.info[i].busy_count;
-        spinlock_unlock(&zone->lock);
         spinlock_unlock(&zones.lock);
         interrupts_restore(ipl);
+        bool available = zone_flags_available(flags);
 #ifdef __32_BITS__
-        printf("%-2u   %10p %12" PRIc " %12" PRIc "\n", i, base,
+        printf("%-2" PRIc "   %10p %c%c%c      ", i, base,
-            free_count, busy_count);
+            available ? 'A' : ' ',
+            (flags & ZONE_RESERVED) ? 'R' : ' ',
+            (flags & ZONE_FIRMWARE) ? 'F' : ' ');
 #endif
 #ifdef __64_BITS__
-        printf("%-2u   %18p %12" PRIc " %12" PRIc "\n", i, base,
+        printf("%-2" PRIc "   %18p %c%c%c      ", i, base,
-            free_count, busy_count);
+            available ? 'A' : ' ',
+            (flags & ZONE_RESERVED) ? 'R' : ' ',
+            (flags & ZONE_FIRMWARE) ? 'F' : ' ');
 #endif
+        if (available)
+            printf("%12" PRIc " %12" PRIc,
+                free_count, busy_count);
+        printf("\n");
+    }
+}
 /** Prints zone details.
+ *
- * @param num       Zone base address or zone number.
+ * @param num Zone base address or zone number.
+ *
  */
-void zone_print_one(unsigned int num)
+void zone_print_one(count_t num)
+{
-    zone_t *zone = NULL;
-    ipl_t ipl;
-    unsigned int i;
-    uintptr_t base;
-    count_t count;
-    count_t busy_count;
-    count_t free_count;
-    ipl = interrupts_disable();
+    ipl_t ipl = interrupts_disable();
     spinlock_lock(&zones.lock);
+    count_t znum = (count_t) -1;
+    count_t i;
     for (i = 0; i < zones.count; i++) {
-        if ((i == num) || (PFN2ADDR(zones.info[i]->base) == num)) {
+        if ((i == num) || (PFN2ADDR(zones.info[i].base) == num)) {
-            zone = zones.info[i];
+            znum = i;
             break;
+        }
+    }
-    if (!zone) {
+    if (znum == (count_t) -1) {
         spinlock_unlock(&zones.lock);
         interrupts_restore(ipl);
         printf("Zone not found.\n");
         return;
+    }
-    spinlock_lock(&zone->lock);
-    base = PFN2ADDR(zone->base);
+    uintptr_t base = PFN2ADDR(zones.info[i].base);
-    count = zone->count;
+    zone_flags_t flags = zones.info[i].flags;
-    busy_count = zone->busy_count;
+    count_t count = zones.info[i].count;
-    free_count = zone->free_count;
+    count_t free_count = zones.info[i].free_count;
-    spinlock_unlock(&zone->lock);
+    count_t busy_count = zones.info[i].busy_count;
     spinlock_unlock(&zones.lock);
     interrupts_restore(ipl);
+    bool available = zone_flags_available(flags);
+    printf("Zone number:       %" PRIc "\n", znum);
     printf("Zone base address: %p\n", base);
-    printf("Zone size: %" PRIc " frames (%" PRIs " KiB)\n", count,
+    printf("Zone size:         %" PRIc " frames (%" PRIs " KiB)\n", count,
         SIZE2KB(FRAMES2SIZE(count)));
+    printf("Zone flags:        %c%c%c\n",
+        available ? 'A' : ' ',
+        (flags & ZONE_RESERVED) ? 'R' : ' ',
+        (flags & ZONE_FIRMWARE) ? 'F' : ' ');
+    if (available) {
-    printf("Allocated space: %" PRIc " frames (%" PRIs " KiB)\n",
+        printf("Allocated space:   %" PRIc " frames (%" PRIs " KiB)\n",
-        busy_count, SIZE2KB(FRAMES2SIZE(busy_count)));
+            busy_count, SIZE2KB(FRAMES2SIZE(busy_count)));
-    printf("Available space: %" PRIc " frames (%" PRIs " KiB)\n",
+        printf("Available space:   %" PRIc " frames (%" PRIs " KiB)\n",
-        free_count, SIZE2KB(FRAMES2SIZE(free_count)));
+            free_count, SIZE2KB(FRAMES2SIZE(free_count)));
+    }
+}
 /** @}
  */

Subversion Repositories HelenOS

(root)//trunk/kernel/generic/src/mm/frame.c – Rev 3208 → 3972