void free_list_free(int handle, void *region){
info_p handler = &MemAllocs[handle];
if(handler->free_list == NULL){
handler->free_list = region;
print_free_list(handler); //debug print
return;
}
if(region < handler->free_list){
//Freed memory belongs at the beginning of free list
printf("Freeing Region: %p; Current Free List: %p\n", region, handler->free_list);
*(long **)region = handler->free_list;
handler->free_list = region;
printf("New Free Pointer: %p\n", handler->free_list);
}else{
//Freed memory belongs inside the queue
long *prev = NULL;
long *curr = handler->free_list;
while(curr != NULL && (long *)curr < (long *)region){ //traverse free list
prev = curr;
curr = *(long**)curr;
}
//Modify Free List (add in new free node)
*(long **)prev = (long *)region;
*(long **)region = (long *) curr;
}
coalesce_free_list(handler);
print_free_list(handler); //debug print
}
void exhaustion_test2 () {
container ptrs;
init_heap ();
std::cout << "Growing exhaustion tests" << std::endl;
// Delete in allocation order
ptrs = alloc_series ( 32, 1.5 );
std::cout << "Allocated " << ptrs.size () << " { 32, 48, 72, 108, 162 ... } byte chunks" << std::endl;
print_free_list ();
for ( container::iterator iter = ptrs.begin (); iter != ptrs.end (); ++iter )
fallback_free ( *iter );
print_free_list ();
std::cout << "----" << std::endl;
// Delete in reverse order
print_free_list ();
ptrs = alloc_series ( 32, 1.5 );
std::cout << "Allocated " << ptrs.size () << " { 32, 48, 72, 108, 162 ... } byte chunks" << std::endl;
for ( container::reverse_iterator iter = ptrs.rbegin (); iter != ptrs.rend (); ++iter )
fallback_free ( *iter );
print_free_list ();
std::cout << "----" << std::endl;
// Alternate deletions
ptrs = alloc_series ( 32, 1.5 );
std::cout << "Allocated " << ptrs.size () << " { 32, 48, 72, 108, 162 ... } byte chunks" << std::endl;
while ( ptrs.size () > 0 )
fallback_free ( pop ( ptrs, ptrs.size () % 1 == 1 ));
print_free_list ();
}
void exhaustion_test3 () {
const size_t allocs [] = { 124, 60, 252, 60, 4 };
container ptrs;
init_heap ();
std::cout << "Complete exhaustion tests" << std::endl;
// Delete in allocation order
ptrs = alloc_series ( allocs, sizeof ( allocs ) / sizeof ( allocs[0] ));
std::cout << "Allocated " << ptrs.size () << " chunks" << std::endl;
print_free_list ();
for ( container::iterator iter = ptrs.begin (); iter != ptrs.end (); ++iter )
fallback_free ( *iter );
print_free_list ();
std::cout << "----" << std::endl;
// Delete in reverse order
print_free_list ();
ptrs = alloc_series ( allocs, sizeof ( allocs ) / sizeof ( allocs[0] ));
std::cout << "Allocated " << ptrs.size () << " chunks" << std::endl;
for ( container::reverse_iterator iter = ptrs.rbegin (); iter != ptrs.rend (); ++iter )
fallback_free ( *iter );
print_free_list ();
std::cout << "----" << std::endl;
// Alternate deletions
ptrs = alloc_series ( allocs, sizeof ( allocs ) / sizeof ( allocs[0] ));
std::cout << "Allocated " << ptrs.size () << " chunks" << std::endl;
while ( ptrs.size () > 0 )
fallback_free ( pop ( ptrs, ptrs.size () % 1 == 1 ));
print_free_list ();
}
void *remove_from_free_list(void *bp) {
// printf("Removing %p from free list\n",bp);
unsigned int payload_dwords = (GET_SIZE(HDRP(bp))-DSIZE) >> 4;
int array_pos = get_array_position_malloc(payload_dwords);
void *prev = NULL;
void *cur = free_lists[array_pos] ;
while((cur != NULL) && (cur != bp)) {
prev = cur;
cur = NEXT_FREE_BLKP(cur);
}
if (cur == NULL) {
printf("bp: %p\n",bp);
print_free_list();
return NULL;
}
if (prev != NULL) {
//somewhere later in the list
*(void **)prev = NEXT_FREE_BLKP(cur);
} else {
//remove from head
free_lists[array_pos] = NEXT_FREE_BLKP(cur);
}
return cur;
}
int main ( int argc, char *argv [] ) {
print_free_list ();
char *p = (char *) fallback_malloc ( 1024 ); // too big!
std::cout << "fallback_malloc ( 1024 ) --> " << (unsigned long ) p << std::endl;
print_free_list ();
p = (char *) fallback_malloc ( 32 );
std::cout << "fallback_malloc ( 32 ) --> " << (unsigned long) (p - heap) << std::endl;
if ( !is_fallback_ptr ( p ))
std::cout << "### p is not a fallback pointer!!" << std::endl;
print_free_list ();
fallback_free ( p );
print_free_list ();
std::cout << std::endl;
exhaustion_test1 (); std::cout << std::endl;
exhaustion_test2 (); std::cout << std::endl;
exhaustion_test3 (); std::cout << std::endl;
return 0;
}
/*****************************************************************************
*Name :
*Description :receive testcase num from echo command
*Parameter :
*Return :
*Note :
*****************************************************************************/
static ssize_t nand_test_store(struct kobject *kobject,struct attribute *attr, const char *buf, size_t count)
{
int ret;
int argnum = 0;
char cmd[32] = {0};
unsigned int param0 = 0;
unsigned int param1 = 0;
unsigned int param2 = 0;
struct nand_kobject* nand_kobj;
nand_kobj = (struct nand_kobject*)kobject;
argnum = sscanf(buf, "%s %u %u %u ", cmd, ¶m0, ¶m1, ¶m2);
printk("argnum=%i, cmd=%s, param0=%u, param1=%u, param2=%u\n", argnum, cmd, param0, param1, param2);
if (-1 == argnum)
{
printk("cmd format err!");
goto NAND_TEST_STORE_EXIT;
}
if(strcmp(cmd,"help") == 0)
{
printk("nand debug cmd:\n");
printk(" help \n");
}
else if(strcmp(cmd,"flush") == 0)
{
printk("nand debug cmd:\n");
printk(" flush \n");
mutex_lock(nand_kobj->nftl_blk->blk_lock);
ret = nand_kobj->nftl_blk->flush_write_cache(nand_kobj->nftl_blk,param0);
mutex_unlock(nand_kobj->nftl_blk->blk_lock);
goto NAND_TEST_STORE_EXIT;
}
else if(strcmp(cmd,"gcall") == 0)
{
printk("nand debug cmd:\n");
printk(" gcall \n");
mutex_lock(nand_kobj->nftl_blk->blk_lock);
ret = gc_all(nand_kobj->nftl_blk->nftl_zone);
mutex_unlock(nand_kobj->nftl_blk->blk_lock);
goto NAND_TEST_STORE_EXIT;
}
else if(strcmp(cmd,"gcone") == 0)
{
printk("nand debug cmd:\n");
printk(" gcone \n");
mutex_lock(nand_kobj->nftl_blk->blk_lock);
ret = gc_one(nand_kobj->nftl_blk->nftl_zone);
mutex_unlock(nand_kobj->nftl_blk->blk_lock);
goto NAND_TEST_STORE_EXIT;
}
else if(strcmp(cmd,"test") == 0)
{
printk("nand debug cmd:\n");
printk(" test \n");
mutex_lock(nand_kobj->nftl_blk->blk_lock);
ret = nftl_set_zone_test((void*)nand_kobj->nftl_blk->nftl_zone,param0);
mutex_unlock(nand_kobj->nftl_blk->blk_lock);
goto NAND_TEST_STORE_EXIT;
}
else if(strcmp(cmd,"showall") == 0)
{
printk("nand debug cmd:\n");
printk(" show all \n");
print_free_list(nand_kobj->nftl_blk->nftl_zone);
print_block_invalid_list(nand_kobj->nftl_blk->nftl_zone);
print_nftl_zone(nand_kobj->nftl_blk->nftl_zone);
goto NAND_TEST_STORE_EXIT;
}
else
{
printk("err, nand debug undefined cmd: %s\n", cmd);
}
NAND_TEST_STORE_EXIT:
return count;
}