Subversion Repositories Kolibri OS

#include 

#include 

#include 

#include 

#include 

{

   link_t link;

   link_t adj;

   addr_t base;

   size_t size;

   void*  parent;

   u32_t  reserved;

}md_t;

   SPINLOCK_DECLARE(lock);   /**< this lock protects everything below */

   link_t list[32];

}heap_t;

slab_cache_t *phm_slab;

heap_t sheap;

{ asm volatile ("bts DWORD PTR [_lheap], %0"::"r"(idx):"cc"); }

{ asm volatile ("btr DWORD PTR [_lheap], %0"::"r"(idx):"cc"); }

{ asm volatile ("bts DWORD PTR [_sheap], %0"::"r"(idx):"cc"); }

{ asm volatile ("btr DWORD PTR [_sheap], %0"::"r"(idx):"cc"); }

{

   md_t *md;

   u32_t i;

   ASSERT(size != 0)

   ASSERT(base & 0x3FFFFF == 0);

   ASSERT(size & 0x3FFFFF == 0);

   {

     list_initialize(&lheap.list[i]);

     list_initialize(&sheap.list[i]);

   };

   md->base = base;

   md->size = size;

   md->parent = NULL;

   md->reserved = 0;

   lheap.availmask = 0x80000000;

   sheap.availmask = 0x00000000;

};

{

   md_t *md = NULL;

   u32_t mask;

   mask = lheap.availmask & ( -1<

   {

     idx0 = _bsf(mask);

   }

   else

     return NULL;

   if(list_empty(&lheap.list[idx0]))

     _reset_lmask(idx0);

   {

     count_t idx1;

     md_t *new_md = (md_t*)slab_alloc(md_slab,0);

     list_insert(&md->adj, &new_md->adj);

     new_md->size = size;

     md->size-= size;

     _set_lmask(idx1);

   }

   return md;

}

{

   eflags_t efl;

   u32_t mask;

   mask = sheap.availmask & ( -1<

   {

     idx0 = _bsf(mask);

     if(list_empty(&sheap.list[idx0]))

       _reset_smask(idx0);

   }

   else

   {

     md_t *lmd;

     lmd = find_large_md((size+0x3FFFFF)&~0x3FFFFF);

     if( !lmd)

     {

       safe_sti(efl);

       return NULL;

     };

     link_initialize(&md->link);

     list_initialize(&md->adj);

     md->base = lmd->base;

     md->size = lmd->size;

     md->parent  = lmd;

     md->reserved = 0;

   };

   {

     count_t idx1;

     md_t *new_md = (md_t*)slab_alloc(md_slab,0);

     list_insert(&md->adj, &new_md->adj);

     new_md->size = size;

     new_md->parent = md->parent;

     new_md->reserved = 0;

     md->size-= size;

     _set_smask(idx1);

   }

   safe_sti(efl);

   return md;

}

{

   phismem_t *phm;

   count_t tmp;

   phm = (phismem_t*)slab_alloc(phm_slab, 0);

   tmp = count;

   while(tmp)

   {

      u32_t order;

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

}

{

   count_t count;

   addr_t  *pte;

   pte = &((addr_t*)page_tabs)[base>>12];

   {

     u32_t order;

     addr_t frame;

     count_t size;

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

     size = (1 << order);

     while(size--)

     {

       *pte++ = frame;

       frame+= 4096;

     }

   }

};

{

   md_t *md;

   phismem_t *phm;

   if( md )

   {

     phm = phis_alloc(size>>12);

     map_phm(md->base, phm, flags);

     return (void*)md->base;

   }

   return NULL;

};

{

   md_t *md;

   if( md )

     return (void*)md->base;

   return NULL;

}

//{

//

//   return NULL;

//}

//*/