Subversion Repositories Kolibri OS

#include 

#include 

#include 

#include 

{

  u32_t val;

  asm volatile ("mov %0, edx":"=r"(val));

  return val;

};

{

  asm volatile (""::"d" (val) );

};

static void  __fastcall buddy_system_free(zone_t *z, link_t *block);

static void zone_mark_unavailable(zone_t *zone, index_t frame_idx);

void __fastcall zone_free(zone_t *zone, pfn_t frame_idx);

static void zone_reserve(zone_t *z, pfn_t base, count_t count);

static void zone_release(zone_t *z, pfn_t base, count_t count);

{

   int i;

   u32_t   size;

   count_t pages;

   size_t  conf_size;

   size_t  core_size;

   DBG("last page = %x total pages =  %x\n",mem_amount, pages);

   DBG("conf_size = %x  free mem start =%x\n",conf_size, pg_balloc);

   zone_reserve(&z_core, 0, pg_balloc >> FRAME_WIDTH);

   core_size = (pg_free+conf_size+1024*1024*5)&(-1024*1024*4);

//   printf("core size = %x core heap = %x\n",core_size,core_size-conf_size-pg_free);

   u32_t b0, b1;

   p1 = (last_page-core_size)>>12;

   b1 = p1*sizeof(frame_t);

//   printf("buddy_1: %x pages  conf_size %x\n", p1, b1);

   zone_create(&z_user, p0, p1);

   {

     u32_t page;

     if( mem_table[i].type != 1)

       continue;

     page = (mem_table[i].base+mem_table[i].size)&(~4095);

     if(page > last_page)

        last_page = page;

     zone_release(&z_user,mem_table[i].base>>12, mem_table[i].size>>12);

   };

   zone_reserve(&z_core, 0x100000>>12,(pg_balloc-OS_BASE-0x100000)>>12);

#endif

};

{

	unsigned int i;

//  int znum;

	 * nobody tries to do that. If some platform requires, remove

	 * the assert

	 */

//  ASSERT(confframe);

	/* If conframe is supposed to be inside our zone, then make sure

	 * it does not span kernel & init

	 */

	z->base = start;

	z->count = count;

	z->free_count = count;

	z->busy_count = 0;

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

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

	}

}

{

  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, &z->frames[i-z->base].buddy_link);

    }

};

{

	return (index_t) (frame - zone->frames);

}

{

  return (index_t) (frame - zone->frames);

}

{

	return (index < zone->count);

}

static inline index_t make_frame_index(zone_t *zone, frame_t *frame)

{

	return (frame - zone->frames);

}

{

	frame->refcount = 1;

	frame->buddy_order = 0;

}

    u32_t order)

{

	frame_t *frame;

	index_t index;

	do {

		if (zone->frames[index].buddy_order != order) {

			return &zone->frames[index].buddy_link;

		}

	} while(index-- > 0);

	return NULL;

}

	frame_t *frame_l, *frame_r;

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

}

  frame_t *frame = (frame_t*)block;

	return frame->buddy_order;

}

    u32_t order) {

  frame_t *frame = (frame_t*)block;

	frame->buddy_order = order;

}

    link_t *block_2)

{

	frame_t *frame1, *frame2;

  frame2 = (frame_t*)block_2;

}

  frame_t * frame = (frame_t*)block;

	frame->refcount = 1;

}

  frame_t *frame = (frame_t*)block;

	frame->refcount = 0;

}

    ((~(((u32_t) -1) << (order)) & (index)) == 0)

#define IS_BUDDY_LEFT_BLOCK_ABS(zone, frame)  \

  (((frame_index_abs((zone), (frame)) >> (frame)->buddy_order) & 0x1) == 0)

	(((frame_index_abs((zone), (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(zone, frame);

	if (is_left) {

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

	} else { 	/* if (is_right) */

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

	}

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

		    zone->frames[index].refcount == 0) {

			return &zone->frames[index].buddy_link;

		}

	}

}

{

	link_t *left,*right, *tmp;

  u32_t order;

  ASSERT(left);

	list_remove(left);

	while (1) {

    if (! buddy_get_order(z,left)) {

      buddy_mark_busy(z, left);

			return left;

		}

    buddy_set_order(z, left, order-1);

    buddy_set_order(z, right, order-1);

			right = left;

			left = tmp;

		}

    ASSERT(tmp == left);

    buddy_mark_busy(z, left);

    buddy_system_free(z, right);

    buddy_mark_available(z, left);

	}

}

{

	link_t *buddy, *hlp;

  u8_t i;

	 * Determine block's order.

	 */

  i = buddy_get_order(z, block);

		/*

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

		 */

    buddy = find_buddy(z, block);

		if (buddy) {

			/*

			 * Remove buddy from the list of order i.

			 */

			list_remove(buddy);

			 * Invalidate order of both block and buddy.

			 */

      buddy_set_order(z, block, BUDDY_SYSTEM_INNER_BLOCK);

      buddy_set_order(z, buddy, BUDDY_SYSTEM_INNER_BLOCK);

			 * Coalesce block and buddy into one block.

			 */

      hlp = buddy_coalesce(z, block, buddy);

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

			 */

      buddy_set_order(z, hlp, i + 1);

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

			 */

      buddy_system_free(z, hlp);

			return;

		}

	}

	 * Insert block into the list of order i.

	 */

  list_append(block, &z->order[i]);

{

  ASSERT(frame_idx < zone->count);

	return &zone->frames[frame_idx];

}

{

	frame_t *frame;

	link_t *link;

	if (frame->refcount)

		return;

  link = buddy_system_alloc_block(zone, &frame->buddy_link);

  ASSERT(link);

	zone->free_count--;

}

{

	link_t *res, *hlp;

	 * If the list of order i is not empty,

	 * the request can be immediatelly satisfied.

	 */

	if (!list_empty(&z->order[i])) {

		res = z->order[i].next;

		list_remove(res);

		buddy_mark_busy(z, res);

		return res;

	}

	/*

	 * If order i is already the maximal order,

	 * the request cannot be satisfied.

	 */

	if (i == z->max_order)

		return NULL;

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

	 */

	hlp = buddy_system_alloc(z, 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(z, res);

	buddy_set_order(z, res, i);

	buddy_set_order(z, hlp, i);

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

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

	 */

	buddy_mark_busy(z, res);

	buddy_system_free(z, hlp);

{

	pfn_t v;

	link_t *tmp;

	frame_t *frame;

	tmp = buddy_system_alloc(zone, order);

	zone->free_count -= (1 << order);

	zone->busy_count += (1 << order);

	frame = (frame_t*)tmp;

	v = make_frame_index(zone, frame);

}

void __fastcall frame_set_parent(pfn_t pfn, void *data)

{

/*  zone_t *zone = find_zone_and_lock(pfn, &hint);

  ASSERT(zone);

 */

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

  spinlock_unlock(&z_core.lock);

}

{

//	zone_t *zone = find_zone_and_lock(pfn, &hint);

	void *res;

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

  spinlock_unlock(&z_core.lock);

}

{

  int n;

  asm volatile (

                "xor eax, eax \n\t"

                "bsr eax, edx \n\t"

                "inc eax"

                :"=a" (n)

                :"d"(arg)

                );

	return n;

}

{

   eflags_t efl;

   pfn_t v;

     spinlock_lock(&zone->lock);

       v = zone_frame_alloc(zone, order);

       v += zone->base;

     spinlock_unlock(&zone->lock);

   safe_sti(efl);

}

{

   eflags_t efl;

   pfn_t v;

     spinlock_lock(&z_core.lock);

       v = zone_frame_alloc(&z_core, order);

     spinlock_unlock(&z_core.lock);

   safe_sti(efl);

};

{

   eflags_t efl;

     spinlock_lock(&z_core.lock);

       zone_free(&z_core, frame>>12);

     spinlock_unlock(&z_core.lock);

   safe_sti(efl);

}

{

   eflags_t efl;

   u32_t    edx;

   pfn_t v;

   efl = safe_cli();

     spinlock_lock(&z_core.lock);

       v = zone_frame_alloc(&z_core, 0);

     spinlock_unlock(&z_core.lock);

   safe_sti(efl);

   return (v << FRAME_WIDTH);

};

{

   eflags_t efl;

   u32_t edx;

   pfn_t v;

   efl = safe_cli();

     spinlock_lock(&z_core.lock);

       v = zone_frame_alloc(&z_core, to_order(count));

     spinlock_unlock(&z_core.lock);

   safe_sti(efl);

};

{

	frame_t *frame;

  u32_t order;

	order = frame->buddy_order;

		buddy_system_free(zone, &frame->buddy_link);

		zone->free_count += (1 << order);

		zone->busy_count -= (1 << order);

	}

}

{

   eflags_t efl;

   zone_t *zone;

     spinlock_lock(&z_core.lock);

       zone_free(&z_core, frame>>12);

     spinlock_unlock(&z_core.lock);

  safe_sti(efl);

}

{

   return z_core.free_count;

}