Subversion Repositories Kolibri OS

#include 

#include 

#include 

#include 

#define HF_SIZE     (1 << HF_WIDTH)

	  (index_t)( (frame) - z_heap.frames)

	  (index_t)( (frame) - z_heap.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_t *frame_l, *frame_r;

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

}

{

	frame_t *frame1, *frame2;

    frame2 = (frame_t*)block_2;

}

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

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

{

	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_ABS( frame);

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

    }

    else {    /* if (is_right) */

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

    };

	{

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

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

			return &z_heap.frames[index].buddy_link;

		}

	}

}

{

    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_heap.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_heap.order[i])) {

		res = z_heap.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_heap.max_order)

		return NULL;

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

	 */

	hlp = buddy_system_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 );

}

{

	count_t i;

    count_t count;

    ASSERT( count != 0);

	z_heap.count = count;

	z_heap.free_count = count;

	z_heap.busy_count = 0;

        list_initialize(&z_heap.order[i]);

               count, sizeof(frame_t), PAGE_SIZE);

        return 0;

		z_heap.frames[i].buddy_order=0;

		z_heap.frames[i].parent = NULL;

		z_heap.frames[i].refcount=1;

	}

    {

        z_heap.frames[i].refcount = 0;

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

    }

}

{

    eflags_t  efl;

    addr_t    heap = 0;

    frame_t  *frame;

    index_t   v;

    int i;

    mmap_t   *map;

    count_t   pages;

//                           sizeof(addr_t) * pages);

                           sizeof(addr_t) * pages) >> PAGE_WIDTH));

    {

        order = size >> HF_WIDTH;

            order = fnzb(order - 1) + 1;

        {

            addr_t  page = 0;

            addr_t  mem;

            z_heap.busy_count += (1 << order);

                frame[i].parent = map;

            addr_t  *mpte = &map->pte[0];

            {

                {

                    u32_t   order;

                    addr_t  page_frame;

                    asm volatile ("btr %0, %1" :"=r"(tmp):"r"(order):"cc");

                    {

                        *pte++  = 0; //page;

                        *mpte++ = page;

                        mem+=  4096;

                    };

                }

#else

                {

                    *pte++  = 0;

                    *mpte++ = page;

                    asm volatile ( "invlpg (%0)" ::"r" (mem) );

                    mem+=  4096;

                };

#endif

            }

            else

            {

                while(pages--)

                {

                    *pte++  = 0; //page;

                    *mpte++ = 0;

                    mem+=  4096;

                };

            }

            DBG("%s %x size %d order %d\n", __FUNCTION__, heap, size, order);

        }

    };

}

{

    eflags_t     efl;

    frame_t     *frame;

    count_t      idx;

        (idx >= z_heap.base+z_heap.count)) {

        DBG("invalid address %x\n", addr);

        return;

    }

    {

        mmap_t  *map;

        count_t  i;

                frame[i].parent = NULL;

        z_heap.free_count += (1 << order);

        z_heap.busy_count -= (1 << order);

        safe_sti(efl);

        {

           i+= frame_free(map->pte[i]);

        }

    }

    else

    {

        spinlock_unlock(&z_heap.lock);

        safe_sti(efl);

    };

};

{

    index_t   idx;

    frame_t  *frame;

    mmap_t   *map;

    {

        addr_t page;

        {

            if( page & PG_DEMAND)

            {

                page &= ~PG_DEMAND;

                page = alloc_page() | (page & 0xFFF);

            };

            ((addr_t*)page_tabs)[faddr >> PAGE_WIDTH] = page;

        };

    };

};