Subversion Repositories Kolibri OS

      (index_t)( (frame) - z_core.frames)

    (frame)->refcount = 1;          \

    (frame)->buddy_order = 0

    ((frame_t*)(block))->buddy_order

     ((frame_t*)(block))->buddy_order = (order)

    ((frame_t*)(block))->refcount = 1

  (((frame_index((frame)) >> (frame)->buddy_order) & 0x1) == 0)

    (((frame_index((frame)) >> (frame)->buddy_order) & 0x1) == 1)

    ((frame_t*)(block))->refcount = 0

{

    frame_t *frame_l, *frame_r;

    frame_r = (frame_l + (1 << (frame_l->buddy_order - 1)));

}

{

    frame_t *frame1, *frame2;

    frame2 = (frame_t*)block_2;

}

{

    frame_t  *frame;

    index_t   index;

    u32_t     is_left, is_right;

 //   ASSERT(IS_BUDDY_ORDER_OK(frame_index_abs(zone, frame),frame->buddy_order));

    is_right = IS_BUDDY_RIGHT_BLOCK( frame);

    if (is_left) {

        index = (frame_index(frame)) + (1 << frame->buddy_order);

    } else {  /* if (is_right) */

        index = (frame_index(frame)) - (1 << frame->buddy_order);

    }

    {

        if (z_core.frames[index].buddy_order == frame->buddy_order &&

            z_core.frames[index].refcount == 0) {

            return &z_core.frames[index].buddy_link;

      }

    }

}

{

    frame_t *frame;

    index_t index;

    do {

        if (z_core.frames[index].buddy_order != order)

            return &z_core.frames[index].buddy_link;

    return NULL;

}

{

    link_t *buddy, *hlp;

    u32_t i;

	 * Determine block's order.

	 */

    i = buddy_get_order(block);

    {

		/*

		 * See if there is any buddy in the list of order i.

		 */

        buddy = find_buddy( block );

        if (buddy)

		{

			/*

			 * Remove buddy from the list of order i.

			 */

			list_remove(buddy);

			 * Invalidate order of both block and buddy.

			 */

            buddy_set_order(block, BUDDY_SYSTEM_INNER_BLOCK);

            buddy_set_order(buddy, BUDDY_SYSTEM_INNER_BLOCK);

			 * Coalesce block and buddy into one block.

			 */

            hlp = buddy_coalesce( block, buddy );

			 * Set order of the coalesced block to i + 1.

			 */

            buddy_set_order(hlp, i + 1);

			 * Recursively add the coalesced block to the list of order i + 1.

			 */

            buddy_system_free( hlp );

			return;

		}

	}

	/*

	 * Insert block into the list of order i.

	 */

    list_append(block, &z_core.order[i]);

}

{

	link_t *res, *hlp;

	 * If the list of order i is not empty,

	 * the request can be immediatelly satisfied.

	 */

    if (!list_empty(&z_core.order[i])) {

        res = z_core.order[i].next;

		list_remove(res);

		buddy_mark_busy(res);

		return res;

	}

	/*

	 * If order i is already the maximal order,

	 * the request cannot be satisfied.

	 */

    if (i == z_core.max_order)

		return NULL;

	 * Try to recursively satisfy the request from higher order lists.

	 */

    hlp = buddy_alloc( i + 1 );

	 * The request could not be satisfied

	 * from higher order lists.

	 */

	if (!hlp)

		return NULL;

	 * Bisect the block and set order of both of its parts to i.

	 */

	hlp = buddy_bisect( res );

	buddy_set_order(hlp, i);

	 * Return the other half to buddy system. Mark the first part

	 * full, so that it won't coalesce again.

	 */

	buddy_mark_busy(res);

	buddy_system_free( hlp );

}

{

	link_t *left,*right, *tmp;

    u32_t order;

    ASSERT(left);

	list_remove(left);

    while (1)

   {

        if ( !buddy_get_order(left))

        {

            buddy_mark_busy(left);

			return left;

		}

        buddy_set_order(left, order-1);

        buddy_set_order(right, order-1);

            right = left;

            left = tmp;

        }

        ASSERT(tmp == left);

        buddy_mark_busy(left);

        buddy_system_free(right);

        buddy_mark_available(left);

	}

}

{

    unsigned int i;

    z->count = count;

    z->free_count = count;

    z->busy_count = 0;

        list_initialize(&z->order[i]);

		frame_initialize(&z->frames[i]);

    for (i = 0; i < count; i++) {

        z_core.frames[i].buddy_order=0;

        z_core.frames[i].parent = NULL;

        z_core.frames[i].refcount=1;

	}

    {

        z_core.frames[i].refcount = 0;

        buddy_system_free(&z_core.frames[i].buddy_link);

    }

*/

         start, count, z->max_order);

{

	frame_t *frame;

	link_t *link;

		return;

    link = buddy_alloc_block( &frame->buddy_link);

    ASSERT(link);

	zone->free_count--;

}

{

    int i;

    pfn_t top = base + count;

        return;

        base = z->base;

        top = z->base+z->count;

        zone_mark_unavailable(z, i - z->base);

{

    int i;

    pfn_t top = base+count;

        return;

        base = z->base;

        top = z->base+z->count;

        z->frames[i-z->base].refcount = 0;

        buddy_system_free(&z->frames[i-z->base].buddy_link);

    }

};

{

    ASSERT(frame_idx < zone->count);

	return &zone->frames[frame_idx];

}

{

  spinlock_lock(&z_core.lock);

  zone_get_frame(&z_core, pfn-z_core.base)->parent = data;

  spinlock_unlock(&z_core.lock);

}

{

	void *res;

    res = zone_get_frame(&z_core, pfn)->parent;

    spinlock_unlock(&z_core.lock);

}