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



 * Synchronization primitives used to sleep when there is no memory
 * available.
 */
mutex_t mem_avail_mtx;
condvar_t mem_avail_cv;
size_t mem_avail_req = 0;  /**< Number of frames requested. */
size_t mem_avail_gen = 0;  /**< Generation counter. */
 
/********************/
/* Helper functions */
/********************/
 
static inline size_t frame_index(zone_t *zone, frame_t *frame)
{
    return (size_t) (frame - zone->frames);
}
 
static inline size_t frame_index_abs(zone_t *zone, frame_t *frame)
{
    return (size_t) (frame - zone->frames) + zone->base;
}
 
static inline bool frame_index_valid(zone_t *zone, size_t index)
{
    return (index < zone->count);
}
 
static inline size_t make_frame_index(zone_t *zone, frame_t *frame)
{
    return (frame - zone->frames);
}
 
/** Initialize frame structure.

 * @param count Number of frames of the newly inserted zone.
 *
 * @return Zone number on success, -1 on error.
 *
 */
static size_t zones_insert_zone(pfn_t base, size_t count)
{
    if (zones.count + 1 == ZONES_MAX) {
        printf("Maximum zone count %u exceeded!\n", ZONES_MAX);
        return (size_t) -1;
    }
   
    size_t i;
    for (i = 0; i < zones.count; i++) {
        /* Check for overlap */
        if (overlaps(base, count,
            zones.info[i].base, zones.info[i].count)) {
            printf("Zones overlap!\n");
            return (size_t) -1;
        }
        if (base < zones.info[i].base)
            break;
    }
   
    /* Move other zones up */
    size_t j;
    for (j = zones.count; j > i; j--) {
        zones.info[j] = zones.info[j - 1];
        zones.info[j].buddy_system->data =
            (void *) &zones.info[j - 1];
    }

 *
 * @return Total number of available frames.
 *
 */
#ifdef CONFIG_DEBUG
static size_t total_frames_free(void)
{
    size_t total = 0;
    size_t i;
    for (i = 0; i < zones.count; i++)
        total += zones.info[i].free_count;
   
    return total;
}

 * @param hint  Used as zone hint.
 *
 * @return Zone index or -1 if not found.
 *
 */
size_t find_zone(pfn_t frame, size_t count, size_t hint)
{
    if (hint >= zones.count)
        hint = 0;
   
    size_t i = hint;
    do {
        if ((zones.info[i].base <= frame)
            && (zones.info[i].base + zones.info[i].count >= frame + count))
            return i;
       
        i++;
        if (i >= zones.count)
            i = 0;
    } while (i != hint);
   
    return (size_t) -1;
}
 
/** @return True if zone can allocate specified order */
static bool zone_can_alloc(zone_t *zone, uint8_t order)
{

 * @param order Size (2^order) of free space we are trying to find.
 * @param flags Required flags of the target zone.
 * @param hind  Preferred zone.
 *
 */
static size_t find_free_zone(uint8_t order, zone_flags_t flags, size_t hint)
{
    if (hint >= zones.count)
        hint = 0;
   
    size_t i = hint;
    do {
        /*
         * Check whether the zone meets the search criteria.
         */
        if ((zones.info[i].flags & flags) == flags) {

        i++;
        if (i >= zones.count)
            i = 0;
    } while (i != hint);
   
    return (size_t) -1;
}
 
/**************************/
/* Buddy system functions */
/**************************/

    uint8_t order)
{
    frame_t *frame = list_get_instance(child, frame_t, buddy_link);
    zone_t *zone = (zone_t *) buddy->data;
   
    size_t index = frame_index(zone, frame);
    do {
        if (zone->frames[index].buddy_order != order)
            return &zone->frames[index].buddy_link;
    } while (index-- > 0);
   

    ASSERT(IS_BUDDY_ORDER_OK(frame_index_abs(zone, frame),
        frame->buddy_order));
   
    bool is_left = IS_BUDDY_LEFT_BLOCK_ABS(zone, frame);
   
    size_t index;
    if (is_left) {
        index = (frame_index(zone, frame)) +
            (1 << frame->buddy_order);
    } else {    /* is_right */
        index = (frame_index(zone, frame)) -

 *
 * @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, size_t frame_idx)
{
    ASSERT(zone_flags_available(zone->flags));
   
    frame_t *frame = &zone->frames[frame_idx];
   

        zone->busy_count -= (1 << order);
    }
}
 
/** Return frame from zone. */
static frame_t *zone_get_frame(zone_t *zone, size_t frame_idx)
{
    ASSERT(frame_idx < zone->count);
    return &zone->frames[frame_idx];
}
 
/** Mark frame in zone unavailable to allocation. */
static void zone_mark_unavailable(zone_t *zone, size_t frame_idx)
{
    ASSERT(zone_flags_available(zone->flags));
   
    frame_t *frame = zone_get_frame(zone, frame_idx);
    if (frame->refcount)

 * @param z2     Second zone to merge.
 * @param old_z1 Original date of the first zone.
 * @param buddy  Merged zone buddy.
 *
 */
static void zone_merge_internal(size_t z1, size_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);
    ASSERT(zones.info[z1].base < zones.info[z2].base);

    zones.info[z1].frames =
        (frame_t *) ((uint8_t *) zones.info[z1].buddy_system
        + buddy_conf_size(order));
   
    /* This marks all frames busy */
    size_t i;
    for (i = 0; i < zones.info[z1].count; i++)
        frame_initialize(&zones.info[z1].frames[i]);
   
    /* Copy frames from both zones to preserve full frame orders,
     * parents etc. Set all free frames with refcount = 0 to 1, because

 * @param znum  The actual zone where freeing should occur.
 * @param pfn   Old zone configuration frame.
 * @param count Old zone frame count.
 *
 */
static void return_config_frames(size_t znum, pfn_t pfn, size_t count)
{
    ASSERT(zone_flags_available(zones.info[znum].flags));
   
    size_t cframes = SIZE2FRAMES(zone_conf_size(count));
   
    if ((pfn < zones.info[znum].base)
        || (pfn >= zones.info[znum].base + zones.info[znum].count))
        return;
   
    frame_t *frame __attribute__ ((unused));
 
    frame = &zones.info[znum].frames[pfn - zones.info[znum].base];
    ASSERT(!frame->buddy_order);
   
    size_t i;
    for (i = 0; i < cframes; i++) {
        zones.info[znum].busy_count++;
        zone_frame_free(&zones.info[znum],
            pfn - zones.info[znum].base + i);
    }

 * @param znum      Zone.
 * @param frame_idx Index the first frame of the block.
 * @param count     Allocated frames in block.
 *
 */
static void zone_reduce_region(size_t znum, pfn_t frame_idx, size_t count)
{
    ASSERT(zone_flags_available(zones.info[znum].flags));
    ASSERT(frame_idx + count < zones.info[znum].count);
   
    uint8_t order = zones.info[znum].frames[frame_idx].buddy_order;
    ASSERT((size_t) (1 << order) >= count);
   
    /* Reduce all blocks to order 0 */
    size_t i;
    for (i = 0; i < (size_t) (1 << order); i++) {
        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 < (size_t) (1 << order); i++)
        zone_frame_free(&zones.info[znum], i + frame_idx);
}
 
/** Merge zones z1 and z2.
 *

 * possible, merged configuration data occupies more space :-/
 *
 * The function uses
 *
 */
bool zone_merge(size_t z1, size_t z2)
{
    ipl_t ipl = interrupts_disable();
    spinlock_lock(&zones.lock);
   
    bool ret = true;

    return_config_frames(z1,
        ADDR2PFN(KA2PA((uintptr_t) zones.info[z2].frames)),
        zones.info[z2].count);
   
    /* Move zones down */
    size_t i;
    for (i = z2 + 1; i < zones.count; i++) {
        zones.info[i - 1] = zones.info[i];
        zones.info[i - 1].buddy_system->data =
            (void *) &zones.info[i - 1];
    }

 * have 1 zone (it's faster).
 *
 */
void zone_merge_all(void)
{
    size_t i = 0;
    while (i < zones.count) {
        if (!zone_merge(i, i + 1))
            i++;
    }
}

 * @param flags Zone flags.
 *
 * @return Initialized zone.
 *
 */
static void zone_construct(zone_t *zone, buddy_system_t *buddy, pfn_t start, size_t count, zone_flags_t flags)
{
    zone->base = start;
    zone->count = count;
    zone->flags = flags;
    zone->free_count = count;

       
        /* Check sizes */
        zone->frames = (frame_t *) ((uint8_t *) zone->buddy_system +
            buddy_conf_size(order));
       
        size_t i;
        for (i = 0; i < count; i++)
            frame_initialize(&zone->frames[i]);
       
        /* Stuffing frames */
        for (i = 0; i < count; i++) {

 * @param count Size of zone in frames.
 *
 * @return Size of zone configuration info (in bytes).
 *
 */
uintptr_t zone_conf_size(size_t count)
{
    return (count * sizeof(frame_t) + buddy_conf_size(fnzb(count)));
}
 
/** Create and add zone to system.

 *                  modified not to include it.
 *
 * @return Zone number or -1 on error.
 *
 */
size_t zone_create(pfn_t start, size_t count, pfn_t confframe, zone_flags_t flags)
{
    ipl_t ipl = interrupts_disable();
    spinlock_lock(&zones.lock);
   
    if (zone_flags_available(flags)) {  /* Create available zone */

        ASSERT(confframe != NULL);
       
        /* If confframe is supposed to be inside our zone, then make sure
         * it does not span kernel & init
         */
        size_t confcount = SIZE2FRAMES(zone_conf_size(count));
        if ((confframe >= start) && (confframe < start + count)) {
            for (; confframe < start + count; confframe++) {
                uintptr_t addr = PFN2ADDR(confframe);
                if (overlaps(addr, PFN2ADDR(confcount),
                    KA2PA(config.base), config.kernel_size))

                if (overlaps(addr, PFN2ADDR(confcount),
                    KA2PA(config.stack_base), config.stack_size))
                    continue;
               
                bool overlap = false;
                size_t i;
                for (i = 0; i < init.cnt; i++)
                    if (overlaps(addr, PFN2ADDR(confcount),
                        KA2PA(init.tasks[i].addr),
                        init.tasks[i].size)) {
                        overlap = true;

           
            if (confframe >= start + count)
                panic("Cannot find configuration data for zone.");
        }
       
        size_t znum = zones_insert_zone(start, count);
        if (znum == (size_t) -1) {
            spinlock_unlock(&zones.lock);
            interrupts_restore(ipl);
            return (size_t) -1;
        }
       
        buddy_system_t *buddy = (buddy_system_t *) PA2KA(PFN2ADDR(confframe));
        zone_construct(&zones.info[znum], buddy, start, count, flags);
       
        /* If confdata in zone, mark as unavailable */
        if ((confframe >= start) && (confframe < start + count)) {
            size_t i;
            for (i = confframe; i < confframe + confcount; i++)
                zone_mark_unavailable(&zones.info[znum],
                    i - zones.info[znum].base);
        }
       

       
        return znum;
    }
   
    /* Non-available zone */
    size_t znum = zones_insert_zone(start, count);
    if (znum == (size_t) -1) {
        spinlock_unlock(&zones.lock);
        interrupts_restore(ipl);
        return (size_t) -1;
    }
    zone_construct(&zones.info[znum], NULL, start, count, flags);
   
    spinlock_unlock(&zones.lock);
    interrupts_restore(ipl);

/*******************/
/* Frame functions */
/*******************/
 
/** Set parent of frame. */
void frame_set_parent(pfn_t pfn, void *data, size_t hint)
{
    ipl_t ipl = interrupts_disable();
    spinlock_lock(&zones.lock);
   
    size_t znum = find_zone(pfn, 1, hint);
   
    ASSERT(znum != (size_t) -1);
   
    zone_get_frame(&zones.info[znum],
        pfn - zones.info[znum].base)->parent = data;
   
    spinlock_unlock(&zones.lock);
    interrupts_restore(ipl);
}
 
void *frame_get_parent(pfn_t pfn, size_t hint)
{
    ipl_t ipl = interrupts_disable();
    spinlock_lock(&zones.lock);
   
    size_t znum = find_zone(pfn, 1, hint);
   
    ASSERT(znum != (size_t) -1);
   
    void *res = zone_get_frame(&zones.info[znum],
        pfn - zones.info[znum].base)->parent;
   
    spinlock_unlock(&zones.lock);

 * @param pzone Preferred zone.
 *
 * @return Physical address of the allocated frame.
 *
 */
void *frame_alloc_generic(uint8_t order, frame_flags_t flags, size_t *pzone)
{
    size_t size = ((size_t) 1) << order;
    ipl_t ipl;
    size_t hint = pzone ? (*pzone) : 0;
   
loop:
    ipl = interrupts_disable();
    spinlock_lock(&zones.lock);
   
    /*
     * First, find suitable frame zone.
     */
    size_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 ((znum == (size_t) -1) && (!(flags & FRAME_NO_RECLAIM))) {
        spinlock_unlock(&zones.lock);
        interrupts_restore(ipl);
       
        size_t freed = slab_reclaim(0);
       
        ipl = interrupts_disable();
        spinlock_lock(&zones.lock);
       
        if (freed > 0)
            znum = find_free_zone(order,
                FRAME_TO_ZONE_FLAGS(flags), hint);
       
        if (znum == (size_t) -1) {
            spinlock_unlock(&zones.lock);
            interrupts_restore(ipl);
           
            freed = slab_reclaim(SLAB_RECLAIM_ALL);
           

                znum = find_free_zone(order,
                    FRAME_TO_ZONE_FLAGS(flags), hint);
        }
    }
   
    if (znum == (size_t) -1) {
        if (flags & FRAME_ATOMIC) {
            spinlock_unlock(&zones.lock);
            interrupts_restore(ipl);
            return NULL;
        }
       
#ifdef CONFIG_DEBUG
        size_t avail = total_frames_free();
#endif
       
        spinlock_unlock(&zones.lock);
        interrupts_restore(ipl);
       
        /*
         * Sleep until some frames are available again.
         */
       
#ifdef CONFIG_DEBUG
        printf("Thread %" PRIu64 " waiting for %" PRIs " frames, "
            "%" PRIs " available.\n", THREAD->tid, size, avail);
#endif
       
        mutex_lock(&mem_avail_mtx);
       
        if (mem_avail_req > 0)
            mem_avail_req = min(mem_avail_req, size);
        else
            mem_avail_req = size;
        size_t gen = mem_avail_gen;
       
        while (gen == mem_avail_gen)
            condvar_wait(&mem_avail_cv, &mem_avail_mtx);
       
        mutex_unlock(&mem_avail_mtx);

   
    /*
     * First, find host frame zone for addr.
     */
    pfn_t pfn = ADDR2PFN(frame);
    size_t znum = find_zone(pfn, 1, NULL);
   
    ASSERT(znum != (size_t) -1);
   
    zone_frame_free(&zones.info[znum], pfn - zones.info[znum].base);
   
    spinlock_unlock(&zones.lock);
    interrupts_restore(ipl);

    spinlock_lock(&zones.lock);
   
    /*
     * First, find host frame zone for addr.
     */
    size_t znum = find_zone(pfn, 1, NULL);
   
    ASSERT(znum != (size_t) -1);
   
    zones.info[znum].frames[pfn - zones.info[znum].base].refcount++;
   
    spinlock_unlock(&zones.lock);
    interrupts_restore(ipl);
}
 
/** Mark given range unavailable in frame zones. */
void frame_mark_unavailable(pfn_t start, size_t count)
{
    ipl_t ipl = interrupts_disable();
    spinlock_lock(&zones.lock);
   
    size_t i;
    for (i = 0; i < count; i++) {
        size_t znum = find_zone(start + i, 1, 0);
        if (znum == (size_t) -1)  /* PFN not found */
            continue;
       
        zone_mark_unavailable(&zones.info[znum],
            start + i - zones.info[znum].base);
    }

        frame_mark_unavailable(ADDR2PFN(KA2PA(config.base)),
            SIZE2FRAMES(config.kernel_size));
        frame_mark_unavailable(ADDR2PFN(KA2PA(config.stack_base)),
            SIZE2FRAMES(config.stack_size));
       
        size_t i;
        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));
        }

{
    ipl_t ipl = interrupts_disable();
    spinlock_lock(&zones.lock);
   
    uint64_t total = 0;
    size_t i;
    for (i = 0; i < zones.count; i++)
        total += (uint64_t) FRAMES2SIZE(zones.info[i].count);
   
    spinlock_unlock(&zones.lock);
    interrupts_restore(ipl);

     * 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).
     */
   
    size_t i;
    for (i = 0;; i++) {
        ipl_t ipl = interrupts_disable();
        spinlock_lock(&zones.lock);
       
        if (i >= zones.count) {

            interrupts_restore(ipl);
            break;
        }
       
        uintptr_t base = PFN2ADDR(zones.info[i].base);
        size_t count = zones.info[i].count;
        zone_flags_t flags = zones.info[i].flags;
        size_t free_count = zones.info[i].free_count;
        size_t busy_count = zones.info[i].busy_count;
       
        spinlock_unlock(&zones.lock);
        interrupts_restore(ipl);
       
        bool available = zone_flags_available(flags);
       
        printf("%-2" PRIs, i);
       
#ifdef __32_BITS__
        printf("   %10p", base);
#endif
       
#ifdef __64_BITS__
        printf("   %18p", base);
#endif
       
        printf(" %12" PRIs " %c%c%c      ", count,
            available ? 'A' : ' ',
            (flags & ZONE_RESERVED) ? 'R' : ' ',
            (flags & ZONE_FIRMWARE) ? 'F' : ' ');
       
        if (available)
            printf("%12" PRIs " %12" PRIs,
                free_count, busy_count);
       
        printf("\n");
    }
}

/** Prints zone details.
 *
 * @param num Zone base address or zone number.
 *
 */
void zone_print_one(size_t num)
{
    ipl_t ipl = interrupts_disable();
    spinlock_lock(&zones.lock);
    size_t znum = (size_t) -1;
   
    size_t i;
    for (i = 0; i < zones.count; i++) {
        if ((i == num) || (PFN2ADDR(zones.info[i].base) == num)) {
            znum = i;
            break;
        }
    }
   
    if (znum == (size_t) -1) {
        spinlock_unlock(&zones.lock);
        interrupts_restore(ipl);
        printf("Zone not found.\n");
        return;
    }
   
    uintptr_t base = PFN2ADDR(zones.info[i].base);
    zone_flags_t flags = zones.info[i].flags;
    size_t count = zones.info[i].count;
    size_t free_count = zones.info[i].free_count;
    size_t busy_count = zones.info[i].busy_count;
   
    spinlock_unlock(&zones.lock);
    interrupts_restore(ipl);
   
    bool available = zone_flags_available(flags);
   
    printf("Zone number:       %" PRIs "\n", znum);
    printf("Zone base address: %p\n", base);
    printf("Zone size:         %" PRIs " 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:   %" PRIs " frames (%" PRIs " KiB)\n",
            busy_count, SIZE2KB(FRAMES2SIZE(busy_count)));
        printf("Available space:   %" PRIs " frames (%" PRIs " KiB)\n",
            free_count, SIZE2KB(FRAMES2SIZE(free_count)));
    }
}
 
/** @}

Rev 4377	Rev 4692
Line 65...	Line 65...
65	* Synchronization primitives used to sleep when there is no memory	65	* Synchronization primitives used to sleep when there is no memory
66	* available.	66	* available.
67	*/	67	*/
68	mutex_t mem_avail_mtx;	68	mutex_t mem_avail_mtx;
69	condvar_t mem_avail_cv;	69	condvar_t mem_avail_cv;
70	count_t mem_avail_req = 0; /*< Number of frames requested. /	70	size_t mem_avail_req = 0; /*< Number of frames requested. /
71	count_t mem_avail_gen = 0; /*< Generation counter. /	71	size_t mem_avail_gen = 0; /*< Generation counter. /
72		72
73	/********************/	73	/********************/
74	/* Helper functions */	74	/* Helper functions */
75	/********************/	75	/********************/
76		76
77	static inline index_t frame_index(zone_t zone, frame_t frame)	77	static inline size_t frame_index(zone_t zone, frame_t frame)
78	{	78	{
79	return (index_t) (frame - zone->frames);	79	return (size_t) (frame - zone->frames);
80	}	80	}
81		81
82	static inline index_t frame_index_abs(zone_t zone, frame_t frame)	82	static inline size_t frame_index_abs(zone_t zone, frame_t frame)
83	{	83	{
84	return (index_t) (frame - zone->frames) + zone->base;	84	return (size_t) (frame - zone->frames) + zone->base;
85	}	85	}
86		86
87	static inline bool frame_index_valid(zone_t *zone, index_t index)	87	static inline bool frame_index_valid(zone_t *zone, size_t index)
88	{	88	{
89	return (index < zone->count);	89	return (index < zone->count);
90	}	90	}
91		91
92	static inline index_t make_frame_index(zone_t zone, frame_t frame)	92	static inline size_t make_frame_index(zone_t zone, frame_t frame)
93	{	93	{
94	return (frame - zone->frames);	94	return (frame - zone->frames);
95	}	95	}
96		96
97	/** Initialize frame structure.	97	/** Initialize frame structure.
Line 118...	Line 118...
118	* @param count Number of frames of the newly inserted zone.	118	* @param count Number of frames of the newly inserted zone.
119	*	119	*
120	* @return Zone number on success, -1 on error.	120	* @return Zone number on success, -1 on error.
121	*	121	*
122	*/	122	*/
123	static count_t zones_insert_zone(pfn_t base, count_t count)	123	static size_t zones_insert_zone(pfn_t base, size_t count)
124	{	124	{
125	if (zones.count + 1 == ZONES_MAX) {	125	if (zones.count + 1 == ZONES_MAX) {
126	printf("Maximum zone count %u exceeded!\n", ZONES_MAX);	126	printf("Maximum zone count %u exceeded!\n", ZONES_MAX);
127	return (count_t) -1;	127	return (size_t) -1;
128	}	128	}
129		129
130	count_t i;	130	size_t i;
131	for (i = 0; i < zones.count; i++) {	131	for (i = 0; i < zones.count; i++) {
132	/* Check for overlap */	132	/* Check for overlap */
133	if (overlaps(base, count,	133	if (overlaps(base, count,
134	zones.info[i].base, zones.info[i].count)) {	134	zones.info[i].base, zones.info[i].count)) {
135	printf("Zones overlap!\n");	135	printf("Zones overlap!\n");
136	return (count_t) -1;	136	return (size_t) -1;
137	}	137	}
138	if (base < zones.info[i].base)	138	if (base < zones.info[i].base)
139	break;	139	break;
140	}	140	}
141		141
142	/* Move other zones up */	142	/* Move other zones up */
143	count_t j;	143	size_t j;
144	for (j = zones.count; j > i; j--) {	144	for (j = zones.count; j > i; j--) {
145	zones.info[j] = zones.info[j - 1];	145	zones.info[j] = zones.info[j - 1];
146	zones.info[j].buddy_system->data =	146	zones.info[j].buddy_system->data =
147	(void *) &zones.info[j - 1];	147	(void *) &zones.info[j - 1];
148	}	148	}
Line 159...	Line 159...
159	*	159	*
160	* @return Total number of available frames.	160	* @return Total number of available frames.
161	*	161	*
162	*/	162	*/
163	#ifdef CONFIG_DEBUG	163	#ifdef CONFIG_DEBUG
164	static count_t total_frames_free(void)	164	static size_t total_frames_free(void)
165	{	165	{
166	count_t total = 0;	166	size_t total = 0;
167	count_t i;	167	size_t i;
168	for (i = 0; i < zones.count; i++)	168	for (i = 0; i < zones.count; i++)
169	total += zones.info[i].free_count;	169	total += zones.info[i].free_count;
170		170
171	return total;	171	return total;
172	}	172	}
Line 182...	Line 182...
182	* @param hint Used as zone hint.	182	* @param hint Used as zone hint.
183	*	183	*
184	* @return Zone index or -1 if not found.	184	* @return Zone index or -1 if not found.
185	*	185	*
186	*/	186	*/
187	count_t find_zone(pfn_t frame, count_t count, count_t hint)	187	size_t find_zone(pfn_t frame, size_t count, size_t hint)
188	{	188	{
189	if (hint >= zones.count)	189	if (hint >= zones.count)
190	hint = 0;	190	hint = 0;
191		191
192	count_t i = hint;	192	size_t i = hint;
193	do {	193	do {
194	if ((zones.info[i].base <= frame)	194	if ((zones.info[i].base <= frame)
195	&& (zones.info[i].base + zones.info[i].count >= frame + count))	195	&& (zones.info[i].base + zones.info[i].count >= frame + count))
196	return i;	196	return i;
197		197
198	i++;	198	i++;
199	if (i >= zones.count)	199	if (i >= zones.count)
200	i = 0;	200	i = 0;
201	} while (i != hint);	201	} while (i != hint);
202		202
203	return (count_t) -1;	203	return (size_t) -1;
204	}	204	}
205		205
206	/** @return True if zone can allocate specified order */	206	/** @return True if zone can allocate specified order */
207	static bool zone_can_alloc(zone_t *zone, uint8_t order)	207	static bool zone_can_alloc(zone_t *zone, uint8_t order)
208	{	208	{
Line 218...	Line 218...
218	* @param order Size (2^order) of free space we are trying to find.	218	* @param order Size (2^order) of free space we are trying to find.
219	* @param flags Required flags of the target zone.	219	* @param flags Required flags of the target zone.
220	* @param hind Preferred zone.	220	* @param hind Preferred zone.
221	*	221	*
222	*/	222	*/
223	static count_t find_free_zone(uint8_t order, zone_flags_t flags, count_t hint)	223	static size_t find_free_zone(uint8_t order, zone_flags_t flags, size_t hint)
224	{	224	{
225	if (hint >= zones.count)	225	if (hint >= zones.count)
226	hint = 0;	226	hint = 0;
227		227
228	count_t i = hint;	228	size_t i = hint;
229	do {	229	do {
230	/*	230	/*
231	* Check whether the zone meets the search criteria.	231	* Check whether the zone meets the search criteria.
232	*/	232	*/
233	if ((zones.info[i].flags & flags) == flags) {	233	if ((zones.info[i].flags & flags) == flags) {
Line 241...	Line 241...
241	i++;	241	i++;
242	if (i >= zones.count)	242	if (i >= zones.count)
243	i = 0;	243	i = 0;
244	} while (i != hint);	244	} while (i != hint);
245		245
246	return (count_t) -1;	246	return (size_t) -1;
247	}	247	}
248		248
249	/**************************/	249	/**************************/
250	/* Buddy system functions */	250	/* Buddy system functions */
251	/**************************/	251	/**************************/
Line 263...	Line 263...
263	uint8_t order)	263	uint8_t order)
264	{	264	{
265	frame_t *frame = list_get_instance(child, frame_t, buddy_link);	265	frame_t *frame = list_get_instance(child, frame_t, buddy_link);
266	zone_t zone = (zone_t ) buddy->data;	266	zone_t zone = (zone_t ) buddy->data;
267		267
268	index_t index = frame_index(zone, frame);	268	size_t index = frame_index(zone, frame);
269	do {	269	do {
270	if (zone->frames[index].buddy_order != order)	270	if (zone->frames[index].buddy_order != order)
271	return &zone->frames[index].buddy_link;	271	return &zone->frames[index].buddy_link;
272	} while (index-- > 0);	272	} while (index-- > 0);
273		273
Line 289...	Line 289...
289	ASSERT(IS_BUDDY_ORDER_OK(frame_index_abs(zone, frame),	289	ASSERT(IS_BUDDY_ORDER_OK(frame_index_abs(zone, frame),
290	frame->buddy_order));	290	frame->buddy_order));
291		291
292	bool is_left = IS_BUDDY_LEFT_BLOCK_ABS(zone, frame);	292	bool is_left = IS_BUDDY_LEFT_BLOCK_ABS(zone, frame);
293		293
294	index_t index;	294	size_t index;
295	if (is_left) {	295	if (is_left) {
296	index = (frame_index(zone, frame)) +	296	index = (frame_index(zone, frame)) +
297	(1 << frame->buddy_order);	297	(1 << frame->buddy_order);
298	} else { /* is_right */	298	} else { /* is_right */
299	index = (frame_index(zone, frame)) -	299	index = (frame_index(zone, frame)) -
Line 444...	Line 444...
444	*	444	*
445	* @param zone Pointer to zone from which the frame is to be freed.	445	* @param zone Pointer to zone from which the frame is to be freed.
446	* @param frame_idx Frame index relative to zone.	446	* @param frame_idx Frame index relative to zone.
447	*	447	*
448	*/	448	*/
449	static void zone_frame_free(zone_t *zone, index_t frame_idx)	449	static void zone_frame_free(zone_t *zone, size_t frame_idx)
450	{	450	{
451	ASSERT(zone_flags_available(zone->flags));	451	ASSERT(zone_flags_available(zone->flags));
452		452
453	frame_t *frame = &zone->frames[frame_idx];	453	frame_t *frame = &zone->frames[frame_idx];
454		454
Line 465...	Line 465...
465	zone->busy_count -= (1 << order);	465	zone->busy_count -= (1 << order);
466	}	466	}
467	}	467	}
468		468
469	/** Return frame from zone. */	469	/** Return frame from zone. */
470	static frame_t zone_get_frame(zone_t zone, index_t frame_idx)	470	static frame_t zone_get_frame(zone_t zone, size_t frame_idx)
471	{	471	{
472	ASSERT(frame_idx < zone->count);	472	ASSERT(frame_idx < zone->count);
473	return &zone->frames[frame_idx];	473	return &zone->frames[frame_idx];
474	}	474	}
475		475
476	/** Mark frame in zone unavailable to allocation. */	476	/** Mark frame in zone unavailable to allocation. */
477	static void zone_mark_unavailable(zone_t *zone, index_t frame_idx)	477	static void zone_mark_unavailable(zone_t *zone, size_t frame_idx)
478	{	478	{
479	ASSERT(zone_flags_available(zone->flags));	479	ASSERT(zone_flags_available(zone->flags));
480		480
481	frame_t *frame = zone_get_frame(zone, frame_idx);	481	frame_t *frame = zone_get_frame(zone, frame_idx);
482	if (frame->refcount)	482	if (frame->refcount)
Line 501...	Line 501...
501	* @param z2 Second zone to merge.	501	* @param z2 Second zone to merge.
502	* @param old_z1 Original date of the first zone.	502	* @param old_z1 Original date of the first zone.
503	* @param buddy Merged zone buddy.	503	* @param buddy Merged zone buddy.
504	*	504	*
505	*/	505	*/
506	static void zone_merge_internal(count_t z1, count_t z2, zone_t old_z1, buddy_system_t buddy)	506	static void zone_merge_internal(size_t z1, size_t z2, zone_t old_z1, buddy_system_t buddy)
507	{	507	{
508	ASSERT(zone_flags_available(zones.info[z1].flags));	508	ASSERT(zone_flags_available(zones.info[z1].flags));
509	ASSERT(zone_flags_available(zones.info[z2].flags));	509	ASSERT(zone_flags_available(zones.info[z2].flags));
510	ASSERT(zones.info[z1].flags == zones.info[z2].flags);	510	ASSERT(zones.info[z1].flags == zones.info[z2].flags);
511	ASSERT(zones.info[z1].base < zones.info[z2].base);	511	ASSERT(zones.info[z1].base < zones.info[z2].base);
Line 527...	Line 527...
527	zones.info[z1].frames =	527	zones.info[z1].frames =
528	(frame_t ) ((uint8_t ) zones.info[z1].buddy_system	528	(frame_t ) ((uint8_t ) zones.info[z1].buddy_system
529	+ buddy_conf_size(order));	529	+ buddy_conf_size(order));
530		530
531	/* This marks all frames busy */	531	/* This marks all frames busy */
532	count_t i;	532	size_t i;
533	for (i = 0; i < zones.info[z1].count; i++)	533	for (i = 0; i < zones.info[z1].count; i++)
534	frame_initialize(&zones.info[z1].frames[i]);	534	frame_initialize(&zones.info[z1].frames[i]);
535		535
536	/* Copy frames from both zones to preserve full frame orders,	536	/* Copy frames from both zones to preserve full frame orders,
537	* parents etc. Set all free frames with refcount = 0 to 1, because	537	* parents etc. Set all free frames with refcount = 0 to 1, because
Line 597...	Line 597...
597	* @param znum The actual zone where freeing should occur.	597	* @param znum The actual zone where freeing should occur.
598	* @param pfn Old zone configuration frame.	598	* @param pfn Old zone configuration frame.
599	* @param count Old zone frame count.	599	* @param count Old zone frame count.
600	*	600	*
601	*/	601	*/
602	static void return_config_frames(count_t znum, pfn_t pfn, count_t count)	602	static void return_config_frames(size_t znum, pfn_t pfn, size_t count)
603	{	603	{
604	ASSERT(zone_flags_available(zones.info[znum].flags));	604	ASSERT(zone_flags_available(zones.info[znum].flags));
605		605
606	count_t cframes = SIZE2FRAMES(zone_conf_size(count));	606	size_t cframes = SIZE2FRAMES(zone_conf_size(count));
607		607
608	if ((pfn < zones.info[znum].base)	608	if ((pfn < zones.info[znum].base)
609	\|\| (pfn >= zones.info[znum].base + zones.info[znum].count))	609	\|\| (pfn >= zones.info[znum].base + zones.info[znum].count))
610	return;	610	return;
611		611
612	frame_t *frame __attribute__ ((unused));	612	frame_t *frame __attribute__ ((unused));
613		613
614	frame = &zones.info[znum].frames[pfn - zones.info[znum].base];	614	frame = &zones.info[znum].frames[pfn - zones.info[znum].base];
615	ASSERT(!frame->buddy_order);	615	ASSERT(!frame->buddy_order);
616		616
617	count_t i;	617	size_t i;
618	for (i = 0; i < cframes; i++) {	618	for (i = 0; i < cframes; i++) {
619	zones.info[znum].busy_count++;	619	zones.info[znum].busy_count++;
620	zone_frame_free(&zones.info[znum],	620	zone_frame_free(&zones.info[znum],
621	pfn - zones.info[znum].base + i);	621	pfn - zones.info[znum].base + i);
622	}	622	}
Line 632...	Line 632...
632	* @param znum Zone.	632	* @param znum Zone.
633	* @param frame_idx Index the first frame of the block.	633	* @param frame_idx Index the first frame of the block.
634	* @param count Allocated frames in block.	634	* @param count Allocated frames in block.
635	*	635	*
636	*/	636	*/
637	static void zone_reduce_region(count_t znum, pfn_t frame_idx, count_t count)	637	static void zone_reduce_region(size_t znum, pfn_t frame_idx, size_t count)
638	{	638	{
639	ASSERT(zone_flags_available(zones.info[znum].flags));	639	ASSERT(zone_flags_available(zones.info[znum].flags));
640	ASSERT(frame_idx + count < zones.info[znum].count);	640	ASSERT(frame_idx + count < zones.info[znum].count);
641		641
642	uint8_t order = zones.info[znum].frames[frame_idx].buddy_order;	642	uint8_t order = zones.info[znum].frames[frame_idx].buddy_order;
643	ASSERT((count_t) (1 << order) >= count);	643	ASSERT((size_t) (1 << order) >= count);
644		644
645	/* Reduce all blocks to order 0 */	645	/* Reduce all blocks to order 0 */
646	count_t i;	646	size_t i;
647	for (i = 0; i < (count_t) (1 << order); i++) {	647	for (i = 0; i < (size_t) (1 << order); i++) {
648	frame_t *frame = &zones.info[znum].frames[i + frame_idx];	648	frame_t *frame = &zones.info[znum].frames[i + frame_idx];
649	frame->buddy_order = 0;	649	frame->buddy_order = 0;
650	if (!frame->refcount)	650	if (!frame->refcount)
651	frame->refcount = 1;	651	frame->refcount = 1;
652	ASSERT(frame->refcount == 1);	652	ASSERT(frame->refcount == 1);
653	}	653	}
654		654
655	/* Free unneeded frames */	655	/* Free unneeded frames */
656	for (i = count; i < (count_t) (1 << order); i++)	656	for (i = count; i < (size_t) (1 << order); i++)
657	zone_frame_free(&zones.info[znum], i + frame_idx);	657	zone_frame_free(&zones.info[znum], i + frame_idx);
658	}	658	}
659		659
660	/** Merge zones z1 and z2.	660	/** Merge zones z1 and z2.
661	*	661	*
Line 668...	Line 668...
668	* possible, merged configuration data occupies more space :-/	668	* possible, merged configuration data occupies more space :-/
669	*	669	*
670	* The function uses	670	* The function uses
671	*	671	*
672	*/	672	*/
673	bool zone_merge(count_t z1, count_t z2)	673	bool zone_merge(size_t z1, size_t z2)
674	{	674	{
675	ipl_t ipl = interrupts_disable();	675	ipl_t ipl = interrupts_disable();
676	spinlock_lock(&zones.lock);	676	spinlock_lock(&zones.lock);
677		677
678	bool ret = true;	678	bool ret = true;
Line 731...	Line 731...
731	return_config_frames(z1,	731	return_config_frames(z1,
732	ADDR2PFN(KA2PA((uintptr_t) zones.info[z2].frames)),	732	ADDR2PFN(KA2PA((uintptr_t) zones.info[z2].frames)),
733	zones.info[z2].count);	733	zones.info[z2].count);
734		734
735	/* Move zones down */	735	/* Move zones down */
736	count_t i;	736	size_t i;
737	for (i = z2 + 1; i < zones.count; i++) {	737	for (i = z2 + 1; i < zones.count; i++) {
738	zones.info[i - 1] = zones.info[i];	738	zones.info[i - 1] = zones.info[i];
739	zones.info[i - 1].buddy_system->data =	739	zones.info[i - 1].buddy_system->data =
740	(void *) &zones.info[i - 1];	740	(void *) &zones.info[i - 1];
741	}	741	}
Line 756...	Line 756...
756	* have 1 zone (it's faster).	756	* have 1 zone (it's faster).
757	*	757	*
758	*/	758	*/
759	void zone_merge_all(void)	759	void zone_merge_all(void)
760	{	760	{
761	count_t i = 0;	761	size_t i = 0;
762	while (i < zones.count) {	762	while (i < zones.count) {
763	if (!zone_merge(i, i + 1))	763	if (!zone_merge(i, i + 1))
764	i++;	764	i++;
765	}	765	}
766	}	766	}
Line 774...	Line 774...
774	* @param flags Zone flags.	774	* @param flags Zone flags.
775	*	775	*
776	* @return Initialized zone.	776	* @return Initialized zone.
777	*	777	*
778	*/	778	*/
779	static void zone_construct(zone_t zone, buddy_system_t buddy, pfn_t start, count_t count, zone_flags_t flags)	779	static void zone_construct(zone_t zone, buddy_system_t buddy, pfn_t start, size_t count, zone_flags_t flags)
780	{	780	{
781	zone->base = start;	781	zone->base = start;
782	zone->count = count;	782	zone->count = count;
783	zone->flags = flags;	783	zone->flags = flags;
784	zone->free_count = count;	784	zone->free_count = count;
Line 797...	Line 797...
797		797
798	/* Check sizes */	798	/* Check sizes */
799	zone->frames = (frame_t ) ((uint8_t ) zone->buddy_system +	799	zone->frames = (frame_t ) ((uint8_t ) zone->buddy_system +
800	buddy_conf_size(order));	800	buddy_conf_size(order));
801		801
802	count_t i;	802	size_t i;
803	for (i = 0; i < count; i++)	803	for (i = 0; i < count; i++)
804	frame_initialize(&zone->frames[i]);	804	frame_initialize(&zone->frames[i]);
805		805
806	/* Stuffing frames */	806	/* Stuffing frames */
807	for (i = 0; i < count; i++) {	807	for (i = 0; i < count; i++) {
Line 817...	Line 817...
817	* @param count Size of zone in frames.	817	* @param count Size of zone in frames.
818	*	818	*
819	* @return Size of zone configuration info (in bytes).	819	* @return Size of zone configuration info (in bytes).
820	*	820	*
821	*/	821	*/
822	uintptr_t zone_conf_size(count_t count)	822	uintptr_t zone_conf_size(size_t count)
823	{	823	{
824	return (count * sizeof(frame_t) + buddy_conf_size(fnzb(count)));	824	return (count * sizeof(frame_t) + buddy_conf_size(fnzb(count)));
825	}	825	}
826		826
827	/** Create and add zone to system.	827	/** Create and add zone to system.
Line 838...	Line 838...
838	* modified not to include it.	838	* modified not to include it.
839	*	839	*
840	* @return Zone number or -1 on error.	840	* @return Zone number or -1 on error.
841	*	841	*
842	*/	842	*/
843	count_t zone_create(pfn_t start, count_t count, pfn_t confframe, zone_flags_t flags)	843	size_t zone_create(pfn_t start, size_t count, pfn_t confframe, zone_flags_t flags)
844	{	844	{
845	ipl_t ipl = interrupts_disable();	845	ipl_t ipl = interrupts_disable();
846	spinlock_lock(&zones.lock);	846	spinlock_lock(&zones.lock);
847		847
848	if (zone_flags_available(flags)) { /* Create available zone */	848	if (zone_flags_available(flags)) { /* Create available zone */
Line 853...	Line 853...
853	ASSERT(confframe != NULL);	853	ASSERT(confframe != NULL);
854		854
855	/* If confframe is supposed to be inside our zone, then make sure	855	/* If confframe is supposed to be inside our zone, then make sure
856	* it does not span kernel & init	856	* it does not span kernel & init
857	*/	857	*/
858	count_t confcount = SIZE2FRAMES(zone_conf_size(count));	858	size_t confcount = SIZE2FRAMES(zone_conf_size(count));
859	if ((confframe >= start) && (confframe < start + count)) {	859	if ((confframe >= start) && (confframe < start + count)) {
860	for (; confframe < start + count; confframe++) {	860	for (; confframe < start + count; confframe++) {
861	uintptr_t addr = PFN2ADDR(confframe);	861	uintptr_t addr = PFN2ADDR(confframe);
862	if (overlaps(addr, PFN2ADDR(confcount),	862	if (overlaps(addr, PFN2ADDR(confcount),
863	KA2PA(config.base), config.kernel_size))	863	KA2PA(config.base), config.kernel_size))
Line 866...	Line 866...
866	if (overlaps(addr, PFN2ADDR(confcount),	866	if (overlaps(addr, PFN2ADDR(confcount),
867	KA2PA(config.stack_base), config.stack_size))	867	KA2PA(config.stack_base), config.stack_size))
868	continue;	868	continue;
869		869
870	bool overlap = false;	870	bool overlap = false;
871	count_t i;	871	size_t i;
872	for (i = 0; i < init.cnt; i++)	872	for (i = 0; i < init.cnt; i++)
873	if (overlaps(addr, PFN2ADDR(confcount),	873	if (overlaps(addr, PFN2ADDR(confcount),
874	KA2PA(init.tasks[i].addr),	874	KA2PA(init.tasks[i].addr),
875	init.tasks[i].size)) {	875	init.tasks[i].size)) {
876	overlap = true;	876	overlap = true;
Line 884...	Line 884...
884		884
885	if (confframe >= start + count)	885	if (confframe >= start + count)
886	panic("Cannot find configuration data for zone.");	886	panic("Cannot find configuration data for zone.");
887	}	887	}
888		888
889	count_t znum = zones_insert_zone(start, count);	889	size_t znum = zones_insert_zone(start, count);
890	if (znum == (count_t) -1) {	890	if (znum == (size_t) -1) {
891	spinlock_unlock(&zones.lock);	891	spinlock_unlock(&zones.lock);
892	interrupts_restore(ipl);	892	interrupts_restore(ipl);
893	return (count_t) -1;	893	return (size_t) -1;
894	}	894	}
895		895
896	buddy_system_t buddy = (buddy_system_t ) PA2KA(PFN2ADDR(confframe));	896	buddy_system_t buddy = (buddy_system_t ) PA2KA(PFN2ADDR(confframe));
897	zone_construct(&zones.info[znum], buddy, start, count, flags);	897	zone_construct(&zones.info[znum], buddy, start, count, flags);
898		898
899	/* If confdata in zone, mark as unavailable */	899	/* If confdata in zone, mark as unavailable */
900	if ((confframe >= start) && (confframe < start + count)) {	900	if ((confframe >= start) && (confframe < start + count)) {
901	count_t i;	901	size_t i;
902	for (i = confframe; i < confframe + confcount; i++)	902	for (i = confframe; i < confframe + confcount; i++)
903	zone_mark_unavailable(&zones.info[znum],	903	zone_mark_unavailable(&zones.info[znum],
904	i - zones.info[znum].base);	904	i - zones.info[znum].base);
905	}	905	}
906		906
Line 909...	Line 909...
909		909
910	return znum;	910	return znum;
911	}	911	}
912		912
913	/* Non-available zone */	913	/* Non-available zone */
914	count_t znum = zones_insert_zone(start, count);	914	size_t znum = zones_insert_zone(start, count);
915	if (znum == (count_t) -1) {	915	if (znum == (size_t) -1) {
916	spinlock_unlock(&zones.lock);	916	spinlock_unlock(&zones.lock);
917	interrupts_restore(ipl);	917	interrupts_restore(ipl);
918	return (count_t) -1;	918	return (size_t) -1;
919	}	919	}
920	zone_construct(&zones.info[znum], NULL, start, count, flags);	920	zone_construct(&zones.info[znum], NULL, start, count, flags);
921		921
922	spinlock_unlock(&zones.lock);	922	spinlock_unlock(&zones.lock);
923	interrupts_restore(ipl);	923	interrupts_restore(ipl);
Line 928...	Line 928...
928	/*******************/	928	/*******************/
929	/* Frame functions */	929	/* Frame functions */
930	/*******************/	930	/*******************/
931		931
932	/** Set parent of frame. */	932	/** Set parent of frame. */
933	void frame_set_parent(pfn_t pfn, void *data, count_t hint)	933	void frame_set_parent(pfn_t pfn, void *data, size_t hint)
934	{	934	{
935	ipl_t ipl = interrupts_disable();	935	ipl_t ipl = interrupts_disable();
936	spinlock_lock(&zones.lock);	936	spinlock_lock(&zones.lock);
937		937
938	count_t znum = find_zone(pfn, 1, hint);	938	size_t znum = find_zone(pfn, 1, hint);
939		939
940	ASSERT(znum != (count_t) -1);	940	ASSERT(znum != (size_t) -1);
941		941
942	zone_get_frame(&zones.info[znum],	942	zone_get_frame(&zones.info[znum],
943	pfn - zones.info[znum].base)->parent = data;	943	pfn - zones.info[znum].base)->parent = data;
944		944
945	spinlock_unlock(&zones.lock);	945	spinlock_unlock(&zones.lock);
946	interrupts_restore(ipl);	946	interrupts_restore(ipl);
947	}	947	}
948		948
949	void *frame_get_parent(pfn_t pfn, count_t hint)	949	void *frame_get_parent(pfn_t pfn, size_t hint)
950	{	950	{
951	ipl_t ipl = interrupts_disable();	951	ipl_t ipl = interrupts_disable();
952	spinlock_lock(&zones.lock);	952	spinlock_lock(&zones.lock);
953		953
954	count_t znum = find_zone(pfn, 1, hint);	954	size_t znum = find_zone(pfn, 1, hint);
955		955
956	ASSERT(znum != (count_t) -1);	956	ASSERT(znum != (size_t) -1);
957		957
958	void *res = zone_get_frame(&zones.info[znum],	958	void *res = zone_get_frame(&zones.info[znum],
959	pfn - zones.info[znum].base)->parent;	959	pfn - zones.info[znum].base)->parent;
960		960
961	spinlock_unlock(&zones.lock);	961	spinlock_unlock(&zones.lock);
Line 971...	Line 971...
971	* @param pzone Preferred zone.	971	* @param pzone Preferred zone.
972	*	972	*
973	* @return Physical address of the allocated frame.	973	* @return Physical address of the allocated frame.
974	*	974	*
975	*/	975	*/
976	void frame_alloc_generic(uint8_t order, frame_flags_t flags, count_t pzone)	976	void frame_alloc_generic(uint8_t order, frame_flags_t flags, size_t pzone)
977	{	977	{
978	count_t size = ((count_t) 1) << order;	978	size_t size = ((size_t) 1) << order;
979	ipl_t ipl;	979	ipl_t ipl;
980	count_t hint = pzone ? (*pzone) : 0;	980	size_t hint = pzone ? (*pzone) : 0;
981		981
982	loop:	982	loop:
983	ipl = interrupts_disable();	983	ipl = interrupts_disable();
984	spinlock_lock(&zones.lock);	984	spinlock_lock(&zones.lock);
985		985
986	/*	986	/*
987	* First, find suitable frame zone.	987	* First, find suitable frame zone.
988	*/	988	*/
989	count_t znum = find_free_zone(order,	989	size_t znum = find_free_zone(order,
990	FRAME_TO_ZONE_FLAGS(flags), hint);	990	FRAME_TO_ZONE_FLAGS(flags), hint);
991		991
992	/* If no memory, reclaim some slab memory,	992	/* If no memory, reclaim some slab memory,
993	if it does not help, reclaim all */	993	if it does not help, reclaim all */
994	if ((znum == (count_t) -1) && (!(flags & FRAME_NO_RECLAIM))) {	994	if ((znum == (size_t) -1) && (!(flags & FRAME_NO_RECLAIM))) {
995	spinlock_unlock(&zones.lock);	995	spinlock_unlock(&zones.lock);
996	interrupts_restore(ipl);	996	interrupts_restore(ipl);
997		997
998	count_t freed = slab_reclaim(0);	998	size_t freed = slab_reclaim(0);
999		999
1000	ipl = interrupts_disable();	1000	ipl = interrupts_disable();
1001	spinlock_lock(&zones.lock);	1001	spinlock_lock(&zones.lock);
1002		1002
1003	if (freed > 0)	1003	if (freed > 0)
1004	znum = find_free_zone(order,	1004	znum = find_free_zone(order,
1005	FRAME_TO_ZONE_FLAGS(flags), hint);	1005	FRAME_TO_ZONE_FLAGS(flags), hint);
1006		1006
1007	if (znum == (count_t) -1) {	1007	if (znum == (size_t) -1) {
1008	spinlock_unlock(&zones.lock);	1008	spinlock_unlock(&zones.lock);
1009	interrupts_restore(ipl);	1009	interrupts_restore(ipl);
1010		1010
1011	freed = slab_reclaim(SLAB_RECLAIM_ALL);	1011	freed = slab_reclaim(SLAB_RECLAIM_ALL);

Subversion Repositories HelenOS

(root)/branches/tracing/kernel/generic/src/mm/frame.c – Rev 4377 → 4692