6,8 → 6,6 |
#include <mm.h> |
#include <slab.h> |
|
#define page_tabs 0xDF800000 |
|
typedef struct |
{ |
link_t link; |
22,15 → 20,12 |
#define MD_USED 2 |
|
typedef struct { |
u32_t av_mapped; |
u32_t av_unmapped; |
SPINLOCK_DECLARE(lock); /**< this lock protects everything below */ |
|
link_t mapped[32]; |
link_t unmapped[32]; |
u32_t availmask; |
link_t free[32]; |
|
link_t used; |
|
SPINLOCK_DECLARE(lock); /**< this lock protects everything below */ |
}heap_t; |
|
|
42,25 → 37,20 |
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_lmask(count_t idx) |
{ asm volatile ("bts %0, _lheap"::"r"(idx):"cc"); } |
|
static inline void _set_savm(count_t idx) |
static inline void _reset_lmask(count_t idx) |
{ asm volatile ("btr %0, _lheap"::"r"(idx):"cc"); } |
|
static inline void _set_smask(count_t idx) |
{ asm volatile ("bts %0, _sheap"::"r"(idx):"cc"); } |
|
static inline void _reset_savm(count_t idx) |
static inline void _reset_smask(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; |
73,11 → 63,8 |
|
for (i = 0; i < 32; i++) |
{ |
list_initialize(&lheap.mapped[i]); |
list_initialize(&lheap.unmapped[i]); |
|
list_initialize(&sheap.mapped[i]); |
list_initialize(&sheap.unmapped[i]); |
list_initialize(&lheap.free[i]); |
list_initialize(&sheap.free[i]); |
}; |
|
list_initialize(&lheap.used); |
94,12 → 81,12 |
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; |
sheap.av_unmapped = 0x00000000; |
list_prepend(&md->link, &lheap.free[31]); |
lheap.availmask = 0x80000000; |
sheap.availmask = 0x00000000; |
|
// phm_slab = slab_cache_create(sizeof(phismem_t), 32,NULL,NULL,SLAB_CACHE_MAGDEFERRED); |
|
return 1; |
}; |
|
113,14 → 100,14 |
ASSERT((size & 0x3FFFFF) == 0); |
|
idx0 = (size>>22) - 1 < 32 ? (size>>22) - 1 : 31; |
mask = lheap.av_unmapped & ( -1<<idx0 ); |
mask = lheap.availmask & ( -1<<idx0 ); |
|
if(mask) |
{ |
if(idx0 == 31) |
{ |
md_t *tmp = (md_t*)lheap.unmapped[31].next; |
while((link_t*)tmp != &lheap.unmapped[31]) |
md_t *tmp = (md_t*)lheap.free[31].next; |
while((link_t*)tmp != &lheap.free[31]) |
{ |
if(tmp->size >= size) |
{ |
136,9 → 123,9 |
{ |
idx0 = _bsf(mask); |
|
ASSERT( !list_empty(&lheap.unmapped[idx0])) |
ASSERT( !list_empty(&lheap.free[idx0])) |
|
md = (md_t*)lheap.unmapped[idx0].next; |
md = (md_t*)lheap.free[idx0].next; |
}; |
} |
else |
147,8 → 134,8 |
ASSERT(md->state == MD_FREE); |
|
list_remove((link_t*)md); |
if(list_empty(&lheap.unmapped[idx0])) |
_reset_lavu(idx0); |
if(list_empty(&lheap.free[idx0])) |
_reset_lmask(idx0); |
|
if(md->size > size) |
{ |
160,7 → 147,6 |
|
new_md->base = md->base; |
new_md->size = size; |
new_md->parent = NULL; |
new_md->state = MD_USED; |
|
md->base+= size; |
168,8 → 154,8 |
|
idx1 = (md->size>>22) - 1 < 32 ? (md->size>>22) - 1 : 31; |
|
list_prepend(&md->link, &lheap.unmapped[idx1]); |
_set_lavu(idx1); |
list_prepend(&md->link, &lheap.free[idx1]); |
_set_lmask(idx1); |
|
return new_md; |
}; |
178,7 → 164,7 |
return md; |
} |
|
md_t* __fastcall find_unmapped_md(size_t size) |
md_t* __fastcall find_small_md(size_t size) |
{ |
eflags_t efl; |
|
192,18 → 178,18 |
efl = safe_cli(); |
|
idx0 = (size>>12) - 1 < 32 ? (size>>12) - 1 : 31; |
mask = sheap.av_unmapped & ( -1<<idx0 ); |
mask = sheap.availmask & ( -1<<idx0 ); |
|
DBG("smask %x size %x idx0 %x mask %x\n",sheap.av_unmapped, size, idx0, mask); |
DBG("smask %x size %x idx0 %x mask %x\n",sheap.availmask, size, idx0, mask); |
|
if(mask) |
{ |
if(idx0 == 31) |
{ |
ASSERT( !list_empty(&sheap.unmapped[31])); |
ASSERT( !list_empty(&sheap.free[31])); |
|
md_t *tmp = (md_t*)sheap.unmapped[31].next; |
while((link_t*)tmp != &sheap.unmapped[31]) |
md_t *tmp = (md_t*)sheap.free[31].next; |
while((link_t*)tmp != &sheap.free[31]) |
{ |
if(tmp->size >= size) |
{ |
217,9 → 203,9 |
{ |
idx0 = _bsf(mask); |
|
ASSERT( !list_empty(&sheap.unmapped[idx0])); |
ASSERT( !list_empty(&sheap.free[idx0])); |
|
md = (md_t*)sheap.unmapped[idx0].next; |
md = (md_t*)sheap.free[idx0].next; |
} |
}; |
|
228,11 → 214,10 |
DBG("remove md %x\n", md); |
|
ASSERT(md->state==MD_FREE); |
ASSERT(md->parent != NULL); |
|
list_remove((link_t*)md); |
if(list_empty(&sheap.unmapped[idx0])) |
_reset_savu(idx0); |
if(list_empty(&sheap.free[idx0])) |
_reset_smask(idx0); |
} |
else |
{ |
247,11 → 232,6 |
return NULL; |
}; |
|
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); |
284,16 → 264,16 |
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.unmapped[idx1]); |
list_prepend(&md->link, &sheap.free[idx1]); |
else |
{ |
if( list_empty(&sheap.unmapped[31])) |
list_prepend(&md->link, &sheap.unmapped[31]); |
if( list_empty(&sheap.free[31])) |
list_prepend(&md->link, &sheap.free[31]); |
else |
{ |
md_t *tmp = (md_t*)sheap.unmapped[31].next; |
md_t *tmp = (md_t*)sheap.free[31].next; |
|
while((link_t*)tmp != &sheap.unmapped[31]) |
while((link_t*)tmp != &sheap.free[31]) |
{ |
if(md->base < tmp->base) |
break; |
303,7 → 283,7 |
}; |
}; |
|
_set_savu(idx1); |
_set_smask(idx1); |
|
safe_sti(efl); |
|
317,167 → 297,13 |
return md; |
} |
|
md_t* __fastcall find_mapped_md(size_t size) |
void __fastcall free_small_md(md_t *md) |
{ |
eflags_t efl; |
|
md_t *md = NULL; |
|
count_t idx0; |
u32_t mask; |
|
ASSERT((size & 0xFFF) == 0); |
|
efl = safe_cli(); |
|
idx0 = (size>>12) - 1 < 32 ? (size>>12) - 1 : 31; |
mask = sheap.av_mapped & ( -1<<idx0 ); |
|
DBG("small av_mapped %x size %x idx0 %x mask %x\n",sheap.av_mapped, size, |
idx0, mask); |
|
if(mask) |
{ |
if(idx0 == 31) |
{ |
ASSERT( !list_empty(&sheap.mapped[31])); |
|
md_t *tmp = (md_t*)sheap.mapped[31].next; |
while((link_t*)tmp != &sheap.mapped[31]) |
{ |
if(tmp->size >= size) |
{ |
md = tmp; |
break; |
}; |
tmp = (md_t*)tmp->link.next; |
}; |
} |
else |
{ |
idx0 = _bsf(mask); |
|
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; |
addr_t frame; |
addr_t *pte; |
int i; |
|
lmd = find_large_md((size+0x3FFFFF)&~0x3FFFFF); |
|
DBG("get large md %x\n", lmd); |
|
if( !lmd) |
{ |
safe_sti(efl); |
return NULL; |
}; |
|
ASSERT(lmd->size != 0); |
ASSERT(lmd->base != 0); |
ASSERT((lmd->base & 0x3FFFFF) == 0); |
ASSERT(lmd->parent == NULL); |
|
frame = core_alloc(10); /* FIXME check */ |
|
lmd->parent = (void*)frame; |
|
pte = &((addr_t*)page_tabs)[lmd->base>>12]; /* FIXME remove */ |
|
for(i = 0; i<1024; i++) |
{ |
*pte++ = frame; |
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; |
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 */ |
|
link_initialize(&new_md->link); |
list_insert(&new_md->adj, &md->adj); |
|
new_md->base = md->base; |
new_md->size = size; |
new_md->parent = md->parent; |
|
md->base+= size; |
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 |
{ |
md_t *tmp = (md_t*)sheap.mapped[31].next; |
|
while((link_t*)tmp != &sheap.mapped[31]) |
{ |
if(md->base < tmp->base) |
break; |
tmp = (md_t*)tmp->link.next; |
} |
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); |
|
491,8 → 317,8 |
idx = (fd->size>>12) - 1 < 32 ? (fd->size>>12) - 1 : 31; |
|
list_remove((link_t*)fd); |
if(list_empty(&sheap.unmapped[idx])) |
_reset_savu(idx); |
if(list_empty(&sheap.free[idx])) |
_reset_smask(idx); |
|
md->size+= fd->size; |
md->adj.next = fd->adj.next; |
504,8 → 330,8 |
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); |
if(list_empty(&sheap.free[idx])) |
_reset_smask(idx); |
|
bk->size+= md->size; |
bk->adj.next = md->adj.next; |
519,19 → 345,19 |
|
idx = (md->size>>12) - 1 < 32 ? (md->size>>12) - 1 : 31; |
|
_set_savu(idx); |
_set_smask(idx); |
|
if( idx < 31) |
list_prepend(&md->link, &sheap.unmapped[idx]); |
list_prepend(&md->link, &sheap.free[idx]); |
else |
{ |
if( list_empty(&sheap.unmapped[31])) |
list_prepend(&md->link, &sheap.unmapped[31]); |
if( list_empty(&sheap.free[31])) |
list_prepend(&md->link, &sheap.free[31]); |
else |
{ |
md_t *tmp = (md_t*)sheap.unmapped[31].next; |
md_t *tmp = (md_t*)sheap.free[31].next; |
|
while((link_t*)tmp != &sheap.unmapped[31]) |
while((link_t*)tmp != &sheap.free[31]) |
{ |
if(md->base < tmp->base) |
break; |
545,83 → 371,60 |
|
}; |
|
void __fastcall free_mapped_md(md_t *md) |
{ |
eflags_t efl ; |
md_t *fd; |
md_t *bk; |
count_t idx; |
|
ASSERT(md->parent != NULL); |
ASSERT( ((md_t*)(md->parent))->parent != NULL); |
#define page_tabs 0xDF800000 |
|
efl = safe_cli(); |
spinlock_lock(&sheap.lock); |
|
if( !list_empty(&md->adj)) |
/* |
phismem_t* __fastcall phis_alloc(count_t count) |
{ |
bk = (md_t*)md->adj.prev; |
fd = (md_t*)md->adj.next; |
phismem_t *phm; |
count_t tmp; |
phm = (phismem_t*)slab_alloc(phm_slab, 0); |
|
if(fd->state == MD_FREE) |
phm->count = count; |
tmp = count; |
while(tmp) |
{ |
idx = (fd->size>>12) - 1 < 32 ? (fd->size>>12) - 1 : 31; |
u32_t order; |
|
list_remove((link_t*)fd); |
if(list_empty(&sheap.mapped[idx])) |
_reset_savm(idx); |
asm volatile ("bsr %0, %1":"=&r"(order):"r"(tmp):"cc"); |
asm volatile ("btr %0, %1" :"=r"(tmp):"r"(order):"cc"); |
|
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; |
phm->frames[order] = core_alloc(order); |
|
list_remove((link_t*)bk); |
if(list_empty(&sheap.mapped[idx])) |
_reset_savm(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; |
return phm; |
} |
|
idx = (md->size>>12) - 1 < 32 ? (md->size>>12) - 1 : 31; |
void map_phm(addr_t base, phismem_t *phm, u32_t mapflags) |
{ |
count_t count; |
addr_t *pte; |
|
_set_savm(idx); |
count = phm->count; |
pte = &((addr_t*)page_tabs)[base>>12]; |
|
if( idx < 31) |
list_prepend(&md->link, &sheap.mapped[idx]); |
else |
while(count) |
{ |
if( list_empty(&sheap.mapped[31])) |
list_prepend(&md->link, &sheap.mapped[31]); |
else |
{ |
md_t *tmp = (md_t*)sheap.mapped[31].next; |
u32_t order; |
addr_t frame; |
count_t size; |
|
while((link_t*)tmp != &sheap.mapped[31]) |
asm volatile ("bsr %0, %1":"=&r"(order):"r"(count):"cc"); |
asm volatile ("btr %0, %1" :"=r"(count):"r"(order):"cc"); |
|
frame = phm->frames[order] | mapflags; |
size = (1 << order); |
while(size--) |
{ |
if(md->base < tmp->base) |
break; |
tmp = (md_t*)tmp->link.next; |
*pte++ = frame; |
frame+= 4096; |
} |
list_insert(&md->link, &tmp->link); |
} |
}; |
}; |
spinlock_unlock(&sheap.lock); |
safe_sti(efl); |
}; |
*/ |
|
|
void * __fastcall mem_alloc(size_t size, u32_t flags) |
{ |
eflags_t efl; |
634,42 → 437,37 |
|
size = (size+4095)&~4095; |
|
md = find_small_md(size); |
|
if( md ) |
{ |
ASSERT(md->state == MD_USED); |
|
if( flags & PG_MAP ) |
{ |
md = find_mapped_md(size); |
count_t tmp = size >> 12; |
addr_t *pte = &((addr_t*)page_tabs)[md->base>>12]; |
|
if( !md ) |
return NULL; |
while(tmp) |
{ |
u32_t order; |
addr_t frame; |
size_t size; |
|
md_t *lmd = (md_t*)md->parent; |
asm volatile ("bsr %1, %0":"=&r"(order):"r"(tmp):"cc"); |
asm volatile ("btr %1, %0" :"=r"(tmp):"r"(order):"cc"); |
|
ASSERT( lmd != NULL); |
ASSERT( lmd->parent != NULL); |
frame = core_alloc(order) | flags; /* FIXME check */ |
|
addr_t frame = (md->base - lmd->base + (addr_t)lmd->parent)| |
(flags & 0xFFF); |
DBG("frame %x\n", frame); |
ASSERT(frame != 0); |
|
count_t tmp = size >> 12; |
addr_t *pte = &((addr_t*)page_tabs)[md->base>>12]; |
|
while(tmp--) |
size = (1 << order); |
while(size--) |
{ |
*pte++ = frame; |
frame+= 4096; |
}; |
} |
else |
md = find_unmapped_md(size); |
}; |
}; |
|
if( !md ) |
return NULL; |
|
ASSERT(md->parent != NULL); |
ASSERT(md->state == MD_USED); |
|
|
efl = safe_cli(); |
spinlock_lock(&sheap.lock); |
|
694,6 → 492,8 |
DBG("allocate: %x size %x\n\n",md->base, size); |
return (void*)md->base; |
}; |
return NULL; |
}; |
|
void __fastcall mem_free(void *mem) |
{ |
724,20 → 524,10 |
|
if( md ) |
{ |
md_t *lmd; |
|
DBG("\tmd: %x base: %x size: %x\n",md, md->base, md->size); |
|
ASSERT(md->state == MD_USED); |
|
list_remove((link_t*)md); |
|
lmd = (md_t*)md->parent; |
|
ASSERT(lmd != 0); |
|
if(lmd->parent != 0) |
{ |
count_t tmp = md->size >> 12; |
addr_t *pte = &((addr_t*)page_tabs)[md->base>>12]; |
|
746,17 → 536,17 |
*pte++ = 0; |
asm volatile ( |
"invlpg (%0)" |
::"r" (mem) ); |
: |
:"r" (mem) ); |
mem+= 4096; |
}; |
|
free_mapped_md( md ); |
list_remove((link_t*)md); |
free_small_md( md ); |
} |
else |
free_unmapped_md( md ); |
} |
else |
{ |
DBG("\tERROR: invalid base address: %x\n", mem); |
}; |
|
safe_sti(efl); |
}; |