WebSVN – Kolibri OS – Diff – /kernel/branches/kolibri_pe/core/heap.c

 #include
 #include
 #include
 #include
 #include
+#define PG_DEMAND   0x400
-#define  MD_FREE    1
+#define HF_WIDTH    16
-#define  MD_USED    2
-typedef struct {
+#define HF_SIZE     (1 << HF_WIDTH)
-    u32_t  av_mapped;
-    u32_t  av_unmapped;
+#define BUDDY_SYSTEM_INNER_BLOCK  0xff
-    link_t mapped[32];
-    link_t unmapped[32];
+static zone_t z_heap;
-    link_t used;
+static link_t  shared_mmap;
-    SPINLOCK_DECLARE(lock);   /**< this lock protects everything below */
-}heap_t;
-slab_cache_t *md_slab;
-slab_cache_t *phm_slab;
-heap_t        lheap;
-heap_t        sheap;
-static inline void _set_lavu(count_t idx)
-{ asm volatile ("bts %0, _lheap+4"::"r"(idx):"cc"); }
-static inline void _reset_lavu(count_t idx)
-{ asm volatile ("btr %0, _lheap+4"::"r"(idx):"cc"); }
-static inline void _set_savm(count_t idx)
-{ asm volatile ("bts %0, _sheap"::"r"(idx):"cc"); }
-static inline void _reset_savm(count_t idx)
-{ asm volatile ("btr %0, _sheap"::"r"(idx):"cc"); }
-static inline void _set_savu(count_t idx)
-{ asm volatile ("bts %0, _sheap+4"::"r"(idx):"cc"); }
-static inline void _reset_savu(count_t idx)
-{ asm volatile ("btr %0, _sheap+4"::"r"(idx):"cc"); }
-int __fastcall init_heap(addr_t base, size_t size)
-{
     md_t *md;
-    u32_t i;
+#define heap_index( frame ) \
+	  (index_t)( (frame) - z_heap.frames)
-    ASSERT(base != 0);
+#define heap_index_abs( frame ) \
-    ASSERT(size != 0)
+	  (index_t)( (frame) - z_heap.frames)
-    ASSERT((base & 0x3FFFFF) == 0);
-    ASSERT((size & 0x3FFFFF) == 0);
-    for (i = 0; i < 32; i++)
+static __inline void frame_initialize(frame_t *frame)
-    {
+{
-        list_initialize(&lheap.mapped[i]);
-        list_initialize(&lheap.unmapped[i]);
-        list_initialize(&sheap.mapped[i]);
-        list_initialize(&sheap.unmapped[i]);
-    };
-    list_initialize(&lheap.used);
-    list_initialize(&sheap.used);
-    md_slab = slab_cache_create(sizeof(md_t), 16,NULL,NULL,SLAB_CACHE_MAGDEFERRED);
-    md = (md_t*)slab_alloc(md_slab,0);
-    list_initialize(&md->adj);
+	frame->refcount = 1;
-    md->base = base;
+	frame->buddy_order = 0;
-    md->size = size;
+}
-    md->parent = NULL;
-    md->state = MD_FREE;
-    list_prepend(&md->link, &lheap.unmapped[31]);
-    lheap.av_mapped    = 0x00000000;
-    lheap.av_unmapped  = 0x80000000;
-    sheap.av_mapped    = 0x00000000;
+#define buddy_get_order( block) \
-    sheap.av_unmapped  = 0x00000000;
-    return 1;
-};
-md_t* __fastcall find_large_md(size_t size)
-{
-    md_t *md = NULL;
-    count_t idx0;
-    u32_t mask;
+    ((frame_t*)(block))->buddy_order
-    ASSERT((size & 0x3FFFFF) == 0);
-    idx0 = (size>>22) - 1 < 32 ? (size>>22) - 1 : 31;
-    mask = lheap.av_unmapped & ( -1<
-    if(mask)
+#define buddy_set_order( block, order) \
      ((frame_t*)(block))->buddy_order = (order)
-        if(idx0 == 31)
+#define buddy_mark_busy( block ) \
-        {
+    ((frame_t*)(block))->refcount = 1
-            md_t *tmp = (md_t*)lheap.unmapped[31].next;
-            while(&tmp->link != &lheap.unmapped[31])
-                if(tmp->size >= size)
-                {
-                    DBG("remove large tmp %x\n", tmp);
+static __inline link_t * buddy_bisect(link_t *block)
-                    md = tmp;
+{
-                    break;
-                };
+    frame_t *frame_l, *frame_r;
-            };
-            tmp = (md_t*)tmp->link.next;
-        }
-        else
-        {
-            idx0 = _bsf(mask);
+    frame_l = (frame_t*)block;
+	frame_r = (frame_l + (1 << (frame_l->buddy_order - 1)));
-            ASSERT( !list_empty(&lheap.unmapped[idx0]))
+	return &frame_r->buddy_link;
+}
-            md = (md_t*)lheap.unmapped[idx0].next;
-        };
+static __inline link_t *buddy_coalesce(link_t *block_1, link_t *block_2)
+{
-    }
+	frame_t *frame1, *frame2;
-    else
-        return NULL;
+    frame1 = (frame_t*)block_1;
+    frame2 = (frame_t*)block_2;
+	return frame1 < frame2 ? block_1 : block_2;
+}
     ASSERT(md->state == MD_FREE);
-    list_remove((link_t*)md);
-    if(list_empty(&lheap.unmapped[idx0]))
-        _reset_lavu(idx0);
 #define IS_BUDDY_LEFT_BLOCK_ABS(frame)  \
-    if(md->size > size)
+  (((heap_index_abs((frame)) >> (frame)->buddy_order) & 0x1) == 0)
-    {
-        count_t idx1;
-        md_t *new_md = (md_t*)slab_alloc(md_slab,0);         /* FIXME check */
+#define IS_BUDDY_RIGHT_BLOCK_ABS(frame) \
-        link_initialize(&new_md->link);
-        list_insert(&new_md->adj, &md->adj);
+	(((heap_index_abs((frame)) >> (frame)->buddy_order) & 0x1) == 1)
-        new_md->base   = md->base;
-        new_md->size   = size;
-        new_md->parent = NULL;
-        new_md->state  = MD_USED;
+static link_t *find_buddy(link_t *block)
-        md->base+= size;
+{
-        md->size-= size;
+	frame_t *frame;
+	index_t index;
-        idx1 = (md->size>>22) - 1 < 32 ? (md->size>>22) - 1 : 31;
+    u32_t is_left, is_right;
+    frame = (frame_t*)block;
+ //   ASSERT(IS_BUDDY_ORDER_OK(frame_index_abs(zone, frame),frame->buddy_order));
+	is_left = IS_BUDDY_LEFT_BLOCK_ABS( frame);
-        list_prepend(&md->link, &lheap.unmapped[idx1]);
+	is_right = IS_BUDDY_RIGHT_BLOCK_ABS( frame);
-        _set_lavu(idx1);
+ //   ASSERT(is_left ^ is_right);
+    if (is_left) {
+        index = (heap_index(frame)) + (1 << frame->buddy_order);
+    }
-        return new_md;
+    else {    /* if (is_right) */
-    };
+        index = (heap_index(frame)) - (1 << frame->buddy_order);
+    };
-    md->state = MD_USED;
+	if ( index < z_heap.count)
+	{
+		if (z_heap.frames[index].buddy_order == frame->buddy_order &&
+		    z_heap.frames[index].refcount == 0) {
+			return &z_heap.frames[index].buddy_link;
+		}
+	}
+	return NULL;
+}
+static void buddy_system_free(link_t *block)
+{
+    link_t *buddy, *hlp;
+    u32_t i;
+    /*
+	 * Determine block's order.
-    return md;
+	 */
+    i = buddy_get_order(block);
+    ASSERT(i <= z_heap.max_order);
-}
+    if (i != z_heap.max_order)
+    {
-md_t* __fastcall find_unmapped_md(size_t size)
+		/*
-{
-    eflags_t efl;
-    md_t *md = NULL;
-    count_t idx0;
-    u32_t mask;
 		 * See if there is any buddy in the list of order i.
-    ASSERT((size & 0xFFF) == 0);
-    efl = safe_cli();
+		 */
-    idx0 = (size>>12) - 1 < 32 ? (size>>12) - 1 : 31;
+        buddy = find_buddy( block );
-    mask = sheap.av_unmapped & ( -1<
-    DBG("smask %x size %x idx0 %x mask %x\n",sheap.av_unmapped, size, idx0, mask);
+		if (buddy)
-    if(mask)
-    {
+		{
-        if(idx0 == 31)
-            ASSERT( !list_empty(&sheap.unmapped[31]));
-            md_t *tmp = (md_t*)sheap.unmapped[31].next;
-            while( &tmp->link != &sheap.unmapped[31])
-            {
+            ASSERT(buddy_get_order(buddy) == i);
+			/*
-                if(tmp->size >= size)
+			 * 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.
+			 */
-                    md = tmp;
+            buddy_set_order(hlp, i + 1);
                     break;
-                };
-                tmp = (md_t*)tmp->link.next;
-            };
+			/*
-        }
+			 * Recursively add the coalesced block to the list of order i + 1.
+			 */
-        else
+            buddy_system_free( hlp );
-        {
+			return;
-            idx0 = _bsf(mask);
+		}
-            ASSERT( !list_empty(&sheap.unmapped[idx0]));
+	}
-            md = (md_t*)sheap.unmapped[idx0].next;
+	/*
-        }
+	 * Insert block into the list of order i.
-    };
+	 */
-    if(md)
+    list_append(block, &z_heap.order[i]);
-    {
-        DBG("remove md %x\n", md);
+}
-        ASSERT(md->state==MD_FREE);
-        ASSERT(md->parent != NULL);
+static link_t* buddy_system_alloc( u32_t i)
+{
-        list_remove((link_t*)md);
-        if(list_empty(&sheap.unmapped[idx0]))
+	link_t *res, *hlp;
-            _reset_savu(idx0);
-    }
+    ASSERT(i <= z_heap.max_order);
-    else
+	/*
+	 * If the list of order i is not empty,
-    {
+	 * the request can be immediatelly satisfied.
-        md_t *lmd;
+	 */
-        lmd = find_large_md((size+0x3FFFFF)&~0x3FFFFF);
+	if (!list_empty(&z_heap.order[i])) {
+		res = z_heap.order[i].next;
-        DBG("get large md %x\n", lmd);
+		list_remove(res);
-        if( !lmd)
 		buddy_mark_busy(res);
-            safe_sti(efl);
-            return NULL;
-        };
+		return res;
+	}
-        ASSERT(lmd->size != 0);
-        ASSERT(lmd->base != 0);
-        ASSERT((lmd->base & 0x3FFFFF) == 0);
-        ASSERT(lmd->parent == NULL);
+	/*
-        md = (md_t*)slab_alloc(md_slab,0);    /* FIXME check */
-        link_initialize(&md->link);
-        list_initialize(&md->adj);
-        md->base = lmd->base;
-        md->size = lmd->size;
+	 * If order i is already the maximal order,
+	 * the request cannot be satisfied.
-        md->parent  = lmd;
+	 */
-        md->state = MD_USED;
+	if (i == z_heap.max_order)
-    };
+		return NULL;
+	/*
+	 * Try to recursively satisfy the request from higher order lists.
-    if(md->size > size)
+	 */
-    {
+	hlp = buddy_system_alloc( i + 1 );
-        count_t idx1;
-        md_t *new_md = (md_t*)slab_alloc(md_slab,0);    /* FIXME check */
-        link_initialize(&new_md->link);
+	/*
-        list_insert(&new_md->adj, &md->adj);
+	 * The request could not be satisfied
-        new_md->base = md->base;
+	 * from higher order lists.
-        new_md->size = size;
+	 */
-        new_md->parent = md->parent;
-        new_md->state = MD_USED;
+	if (!hlp)
+		return NULL;
-        md->base+= size;
-        md->size-= size;
-        md->state = MD_FREE;
-        idx1 = (md->size>>12) - 1 < 32 ? (md->size>>12) - 1 : 31;
+	res = hlp;
-        DBG("insert md %x, base %x size %x idx %x\n", md,md->base, md->size,idx1);
+	/*
+	 * Bisect the block and set order of both of its parts to i.
-        if( idx1 < 31)
+	 */
-          list_prepend(&md->link, &sheap.unmapped[idx1]);
+	hlp = buddy_bisect( res );
-        else
-        {
-            if( list_empty(&sheap.unmapped[31]))
-                list_prepend(&md->link, &sheap.unmapped[31]);
-            else
-            {
+	buddy_set_order(res, i);
-                md_t *tmp = (md_t*)sheap.unmapped[31].next;
 	buddy_set_order(hlp, i);
-                while( &tmp->link != &sheap.unmapped[31])
-                {
-                    if(md->base < tmp->base)
-                        break;
-                    tmp = (md_t*)tmp->link.next;
+	/*
 	 * Return the other half to buddy system. Mark the first part
-                list_insert(&md->link, &tmp->link);
-            };
+	 * full, so that it won't coalesce again.
-        };
+	 */
+	buddy_mark_busy(res);
-        _set_savu(idx1);
+	buddy_system_free( hlp );
-        safe_sti(efl);
-        return new_md;
-    };
-    md->state = MD_USED;
-    safe_sti(efl);
+	return res;
+}
     return md;
+int __fastcall init_heap(addr_t start, size_t size)
-}
-md_t* __fastcall find_mapped_md(size_t size)
+{
-{
-    eflags_t efl;
-    md_t *md = NULL;
+	count_t i;
-    count_t idx0;
-    u32_t mask;
+    count_t count;
-    ASSERT((size & 0xFFF) == 0);
+    count = size >> HF_WIDTH;
-    efl = safe_cli();
+    ASSERT( start != 0);
+    ASSERT( count != 0);
-    idx0 = (size>>12) - 1 < 32 ? (size>>12) - 1 : 31;
-    mask = sheap.av_mapped & ( -1<
+    spinlock_initialize(&z_heap.lock);
-    DBG("small av_mapped %x size %x idx0 %x mask %x\n",sheap.av_mapped, size,
-         idx0, mask);
+    z_heap.base = start >> HF_WIDTH;
+	z_heap.count = count;
-    if(mask)
-    {
-        if(idx0 == 31)
-        {
+	z_heap.free_count = count;
-            ASSERT( !list_empty(&sheap.mapped[31]));
-            md_t *tmp = (md_t*)sheap.mapped[31].next;
-            while( &tmp->link != &sheap.mapped[31])
-            {
-                if(tmp->size >= size)
+	z_heap.busy_count = 0;
-                {
-                    md = tmp;
-                    break;
-                };
-                tmp = (md_t*)tmp->link.next;
+    z_heap.max_order = fnzb(count);
-            };
-        }
+    DBG("create heap zone: base %x count %x\n", start, count);
-        else
-        {
+    ASSERT(z_heap.max_order < BUDDY_SYSTEM_INNER_BLOCK);
-            idx0 = _bsf(mask);
+    for (i = 0; i <= z_heap.max_order; i++)
+        list_initialize(&z_heap.order[i]);
-            ASSERT( !list_empty(&sheap.mapped[idx0]));
-            md = (md_t*)sheap.mapped[idx0].next;
-        }
-    };
-    if(md)
-    {
-        DBG("remove md %x\n", md);
-        ASSERT(md->state==MD_FREE);
-        list_remove((link_t*)md);
-        if(list_empty(&sheap.mapped[idx0]))
-            _reset_savm(idx0);
-    }
-    else
-    {
-        md_t    *lmd;
+    DBG("count %d frame_t %d page_size %d\n",
-        addr_t  frame;
+               count, sizeof(frame_t), PAGE_SIZE);
-        addr_t  *pte;
-        int i;
+    z_heap.frames = (frame_t *)PA2KA(frame_alloc( (count*sizeof(frame_t)) >> PAGE_WIDTH ));
-        lmd = find_large_md((size+0x3FFFFF)&~0x3FFFFF);
-        DBG("get large md %x\n", lmd);
-        if( !lmd)
-        {
-            safe_sti(efl);
-            return NULL;
-        };
+    if( z_heap.frames == 0 )
+        return 0;
-        ASSERT(lmd->size != 0);
-        ASSERT(lmd->base != 0);
+	for (i = 0; i < count; i++) {
-        ASSERT((lmd->base & 0x3FFFFF) == 0);
+		z_heap.frames[i].buddy_order=0;
-        ASSERT(lmd->parent == NULL);
+		z_heap.frames[i].parent = NULL;
+		z_heap.frames[i].refcount=1;
-        frame = core_alloc(10);                        /* FIXME check */
+	}
+    for (i = 0; i < count; i++)
+    {
+        z_heap.frames[i].refcount = 0;
+        buddy_system_free(&z_heap.frames[i].buddy_link);
+    }
-        lmd->parent = (void*)frame;
+    list_initialize(&shared_mmap);
+	return 1;
-        pte = &((addr_t*)page_tabs)[lmd->base>>12];    /* FIXME remove */
-        for(i = 0; i<1024; i++)
+}
-        {
-           *pte++ = frame;
+addr_t  __fastcall mem_alloc(size_t size, u32_t flags)
-           frame+= 4096;
-        }
-        md = (md_t*)slab_alloc(md_slab,0);             /* FIXME check */
-        link_initialize(&md->link);
-        list_initialize(&md->adj);
-        md->base = lmd->base;
+{
-        md->size = lmd->size;
+    eflags_t  efl;
-        md->parent  = lmd;
-        md->state = MD_USED;
-    };
-    if(md->size > size)
-    {
-        count_t idx1;
-        md_t *new_md = (md_t*)slab_alloc(md_slab,0);    /* FIXME check */
+    addr_t    heap = 0;
+    count_t   order;
-        link_initialize(&new_md->link);
+    frame_t  *frame;
-        list_insert(&new_md->adj, &md->adj);
+    index_t   v;
-        new_md->base = md->base;
-        new_md->size = size;
-        new_md->parent = md->parent;
-        md->base+= size;
+    int i;
-        md->size-= size;
-        md->state = MD_FREE;
-        idx1 = (md->size>>12) - 1 < 32 ? (md->size>>12) - 1 : 31;
-        DBG("insert md %x, base %x size %x idx %x\n", md,md->base, md->size,idx1);
-        if( idx1 < 31)
-          list_prepend(&md->link, &sheap.mapped[idx1]);
-        else
-        {
-            if( list_empty(&sheap.mapped[31]))
-                list_prepend(&md->link, &sheap.mapped[31]);
-            else
     mmap_t   *map;
+    count_t   pages;
                 md_t *tmp = (md_t*)sheap.mapped[31].next;
+ //   __asm__ __volatile__ ("xchgw %bx, %bx");
+    size = (size + 4095) & ~4095;
-                while( &tmp->link != &sheap.mapped[31])
+    pages = size >> PAGE_WIDTH;
-                    if(md->base < tmp->base)
+//    map = (mmap_t*)malloc( sizeof(mmap_t) +
-                        break;
-                    tmp = (md_t*)tmp->link.next;
+//                           sizeof(addr_t) * pages);
-                }
-                list_insert(&md->link, &tmp->link);
-            };
-        };
-        _set_savm(idx1);
-        md = new_md;
-    };
-    md->state = MD_USED;
-    safe_sti(efl);
-    return md;
-}
-void __fastcall free_unmapped_md(md_t *md)
-{
-    eflags_t  efl ;
-    md_t     *fd;
-    md_t     *bk;
-    count_t   idx;
-    ASSERT(md->parent != NULL);
-    efl = safe_cli();
-    spinlock_lock(&sheap.lock);
-    if( !list_empty(&md->adj))
+    map = (mmap_t*)PA2KA(frame_alloc( (sizeof(mmap_t) +
-    {
-        bk = (md_t*)md->adj.prev;
-        fd = (md_t*)md->adj.next;
+                           sizeof(addr_t) * pages) >> PAGE_WIDTH));
-        if(fd->state == MD_FREE)
-        {
-            idx = (fd->size>>12) - 1 < 32 ? (fd->size>>12) - 1 : 31;
+    map->size = size;
-            list_remove((link_t*)fd);
-            if(list_empty(&sheap.unmapped[idx]))
-                _reset_savu(idx);
-            md->size+= fd->size;
-            md->adj.next = fd->adj.next;
-            md->adj.next->prev = (link_t*)md;
+    if ( map )
-            slab_free(md_slab, fd);
-        };
-        if(bk->state == MD_FREE)
-        {
-            idx = (bk->size>>12) - 1 < 32 ? (bk->size>>12) - 1 : 31;
-            list_remove((link_t*)bk);
-            if(list_empty(&sheap.unmapped[idx]))
-                _reset_savu(idx);
-            bk->size+= md->size;
+    {
-            bk->adj.next = md->adj.next;
-            bk->adj.next->prev = (link_t*)bk;
-            slab_free(md_slab, md);
-            md = fd;
-        };
-    };
-    md->state = MD_FREE;
+        order = size >> HF_WIDTH;
-    idx = (md->size>>12) - 1 < 32 ? (md->size>>12) - 1 : 31;
-    _set_savu(idx);
+        if( order )
-    if( idx < 31)
+            order = fnzb(order - 1) + 1;
-        list_prepend(&md->link, &sheap.unmapped[idx]);
-    else
+        efl = safe_cli();
-    {
+        spinlock_lock(&z_heap.lock);
-        if( list_empty(&sheap.unmapped[31]))
-            list_prepend(&md->link, &sheap.unmapped[31]);
-        else
+        frame = (frame_t*)buddy_system_alloc(order);
-        {
-            md_t *tmp = (md_t*)sheap.unmapped[31].next;
+        ASSERT( frame );
+        if( frame )
-            while( &tmp->link != &sheap.unmapped[31])
+        {
-            {
-                if(md->base < tmp->base)
-                    break;
+            addr_t  page = 0;
-                tmp = (md_t*)tmp->link.next;
+            addr_t  mem;
-            }
-            list_insert(&md->link, &tmp->link);
+            z_heap.free_count -= (1 << order);
-        };
-    };
-    spinlock_unlock(&sheap.lock);
+            z_heap.busy_count += (1 << order);
-    safe_sti(efl);
 };
 /* get frame address */
 void __fastcall free_mapped_md(md_t *md)
-{
+            v = z_heap.base + (index_t)(frame - z_heap.frames);
-    eflags_t  efl ;
-    md_t     *fd;
-    md_t     *bk;
-    count_t   idx;
-    ASSERT(md->parent != NULL);
+            heap = v << HF_WIDTH;
-    ASSERT( ((md_t*)(md->parent))->parent != NULL);
     efl = safe_cli();
-    spinlock_lock(&sheap.lock);
+            map->base = heap;
+            for(i = 0; i < (1 << order); i++)
+                frame[i].parent = map;
-    if( !list_empty(&md->adj))
-    {
-        bk = (md_t*)md->adj.prev;
+            spinlock_unlock(&z_heap.lock);
-        fd = (md_t*)md->adj.next;
+            safe_sti(efl);
-        if(fd->state == MD_FREE)
-        {
-            idx = (fd->size>>12) - 1 < 32 ? (fd->size>>12) - 1 : 31;
-            list_remove((link_t*)fd);
-            if(list_empty(&sheap.mapped[idx]))
-                _reset_savm(idx);
+            addr_t  *pte = &((addr_t*)page_tabs)[heap >> PAGE_WIDTH];
+            addr_t  *mpte = &map->pte[0];
-            md->size+= fd->size;
-            md->adj.next = fd->adj.next;
-            md->adj.next->prev = (link_t*)md;
-            slab_free(md_slab, fd);
-        };
-        if(bk->state == MD_FREE)
-        {
-            idx = (bk->size>>12) - 1 < 32 ? (bk->size>>12) - 1 : 31;
-            list_remove((link_t*)bk);
-            if(list_empty(&sheap.mapped[idx]))
-                _reset_savm(idx);
-            bk->size+= md->size;
+#if 0
-            bk->adj.next = md->adj.next;
-            bk->adj.next->prev = (link_t*)bk;
+            if( flags & PG_MAP )
-            slab_free(md_slab, md);
+                page = PG_DEMAND | (flags & 0xFFF);
-            md = fd;
-        };
-    };
-    md->state = MD_FREE;
-    idx = (md->size>>12) - 1 < 32 ? (md->size>>12) - 1 : 31;
-    _set_savm(idx);
-    if( idx < 31)
-        list_prepend(&md->link, &sheap.mapped[idx]);
-    else
-    {
-        if( list_empty(&sheap.mapped[31]))
-            list_prepend(&md->link, &sheap.mapped[31]);
-        else
+            mem = heap;
-        {
-            md_t *tmp = (md_t*)sheap.mapped[31].next;
             while(pages--)
+            {
-            while( &tmp->link != &sheap.mapped[31])
+                *pte++  = 0; //page;
-            {
-                if(md->base < tmp->base)
-                    break;
+                *mpte++ = page;
-                tmp = (md_t*)tmp->link.next;
-            }
-            list_insert(&md->link, &tmp->link);
+                asm volatile ( "invlpg (%0)" ::"r" (mem) );
-        };
+                mem+=  4096;
-    };
+            };
-    spinlock_unlock(&sheap.lock);
-    safe_sti(efl);
-};
-md_t* __fastcall  md_alloc(size_t size, u32_t flags)
 #else
-    eflags_t efl;
-    md_t *md;
-    size = (size+4095)&~4095;
-    if( flags & PG_MAP )
-    {
-        md = find_mapped_md(size);
-        if( !md )
-            return NULL;
-        ASSERT(md->state == MD_USED);
-        ASSERT(md->parent != NULL);
-        md_t *lmd = (md_t*)md->parent;
-        ASSERT( lmd != NULL);
-        ASSERT( lmd->parent != NULL);
-        addr_t  frame  = (md->base - lmd->base + (addr_t)lmd->parent)|
-                         (flags & 0xFFF);
-        DBG("frame %x\n", frame);
-        ASSERT(frame != 0);
+            mem = heap;
-        count_t  tmp = size >> 12;
-        addr_t  *pte = &((addr_t*)page_tabs)[md->base>>12];
-        while(tmp--)
-        {
-            *pte++ = frame;
-            frame+= 4096;
-        };
-    }
-    else

Subversion Repositories Kolibri OS

(root)/kernel/branches/kolibri_pe/core/heap.c – Rev 928 → 1066