bool test_poison(void) { size_t size; for (size = 1; size <= 16; size++) { { umm_init(); corruption_cnt = 0; char *ptr = wrap_malloc(size); ptr[size]++; wrap_free(ptr); if (corruption_cnt == 0) { printf("corruption_cnt should not be 0, but it is\n"); return false; } } { umm_init(); corruption_cnt = 0; char *ptr = wrap_calloc(1, size); ptr[-1]++; wrap_free(ptr); if (corruption_cnt == 0) { printf("corruption_cnt should not be 0, but it is\n"); return false; } } } return true; }
bool test_oom_random(void) { umm_init(); corruption_cnt = 0; void *ptrs[OOM_PTRS_CNT]; size_t size = 100; while (1) { size_t i; for (i = 0; i < OOM_PTRS_CNT; i++) { size += rand() % 40 - 10; ptrs[i] = wrap_malloc(size); if (ptrs[i] == NULL) { goto out; } } /* free some of the blocks, so we have "holes" */ for (i = 0; i < OOM_PTRS_CNT; i++) { if ((rand() % 10) <= 2) { wrap_free(ptrs[i]); } } } out: if (corruption_cnt != 0) { printf("corruption_cnt should be 0, but it is %d\n", corruption_cnt); return false; } return true; }
static void setup_heap() { xMemoryInformationType *mit = MIS_START_ADDRESS; void *heap = mit[portCORE_ID()].phys_heap_begin; size_t heap_size = mit[portCORE_ID()].phys_heap_size - 0x10000; umm_init(heap, heap_size); }
bool test_integrity_check(void) { size_t size; for (size = 1; size <= 16; size++) { { umm_init(); corruption_cnt = 0; char *ptr = wrap_malloc(size); memset(ptr, 0xfe, size + 8 /* size of umm_block*/); /* * NOTE: we don't use wrap_free here, because we've just corrupted the * heap, and gathering of the umm info on corrupted heap can cause * segfault */ umm_free(ptr); if (corruption_cnt == 0) { printf("corruption_cnt should not be 0, but it is\n"); return false; } } { umm_init(); corruption_cnt = 0; char *ptr = wrap_calloc(1, size); ptr[-1]++; /* * NOTE: we don't use wrap_free here, because we've just corrupted the * heap, and gathering of the umm info on corrupted heap can cause * segfault */ umm_free(ptr); if (corruption_cnt == 0) { printf("corruption_cnt should not be 0, but it is\n"); return false; } } } return true; }
bool random_stress(void) { void *ptr_array[256]; size_t i; int idx; corruption_cnt = 0; printf("Size of umm_heap is %u\n", (unsigned int) sizeof(test_umm_heap)); umm_init(); umm_info(NULL, 1); for (idx = 0; idx < 256; ++idx) ptr_array[idx] = (void *) NULL; for (idx = 0; idx < 100000; ++idx) { i = rand() % 256; /* try to realloc some pointer to deliberately too large value */ { void *tmp = wrap_realloc(ptr_array[i], UMM_MALLOC_CFG__HEAP_SIZE); if (tmp != NULL) { printf("realloc to too large buffer should return NULL"); return false; } } switch (rand() % 16) { case 0: case 1: case 2: case 3: case 4: case 5: case 6: { ptr_array[i] = wrap_realloc(ptr_array[i], 0); break; } case 7: case 8: { size_t size = rand() % 40; ptr_array[i] = wrap_realloc(ptr_array[i], size); memset(ptr_array[i], 0xfe, size); break; } case 9: case 10: case 11: case 12: { size_t size = rand() % 100; ptr_array[i] = wrap_realloc(ptr_array[i], size); memset(ptr_array[i], 0xfe, size); break; } case 13: case 14: { size_t size = rand() % 200; wrap_free(ptr_array[i]); ptr_array[i] = wrap_calloc(1, size); if (ptr_array[i] != NULL) { int a; for (a = 0; a < size; a++) { if (((char *) ptr_array[i])[a] != 0x00) { printf("calloc returned non-zeroed memory\n"); return false; } } } memset(ptr_array[i], 0xfe, size); break; } default: { size_t size = rand() % 400; wrap_free(ptr_array[i]); ptr_array[i] = wrap_malloc(size); memset(ptr_array[i], 0xfe, size); break; } } } return (corruption_cnt == 0); }
void *umm_realloc( void *ptr, size_t size ) { unsigned short int blocks; unsigned short int blockSize; unsigned short int prevBlockSize = 0; unsigned short int nextBlockSize = 0; unsigned short int c; size_t curSize; if (umm_heap == NULL) { umm_init(); } /* * This code looks after the case of a NULL value for ptr. The ANSI C * standard says that if ptr is NULL and size is non-zero, then we've * got to work the same a malloc(). If size is also 0, then our version * of malloc() returns a NULL pointer, which is OK as far as the ANSI C * standard is concerned. */ if( ((void *)NULL == ptr) ) { DBGLOG_DEBUG( "realloc the NULL pointer - call malloc()\n" ); return( umm_malloc(size) ); } /* * Now we're sure that we have a non_NULL ptr, but we're not sure what * we should do with it. If the size is 0, then the ANSI C standard says that * we should operate the same as free. */ if( 0 == size ) { DBGLOG_DEBUG( "realloc to 0 size, just free the block\n" ); umm_free( ptr ); return( (void *)NULL ); } /* * Otherwise we need to actually do a reallocation. A naiive approach * would be to malloc() a new block of the correct size, copy the old data * to the new block, and then free the old block. * * While this will work, we end up doing a lot of possibly unnecessary * copying. So first, let's figure out how many blocks we'll need. */ blocks = umm_blocks( size ); /* Figure out which block we're in. Note the use of truncated division... */ c = (((char *)ptr)-(char *)(&(umm_heap[0])))/sizeof(umm_block); /* Figure out how big this block is ... the free bit is not set :-) */ blockSize = (UMM_NBLOCK(c) - c); /* Figure out how many bytes are in this block */ curSize = (blockSize*sizeof(umm_block))-(sizeof(((umm_block *)0)->header)); /* Protect the critical section... */ UMM_CRITICAL_ENTRY(); /* Now figure out if the previous and/or next blocks are free as well as * their sizes - this will help us to minimize special code later when we * decide if it's possible to use the adjacent blocks. * * We set prevBlockSize and nextBlockSize to non-zero values ONLY if they * are free! */ if ((UMM_NBLOCK(UMM_NBLOCK(c)) & UMM_FREELIST_MASK)) { nextBlockSize = (UMM_NBLOCK(UMM_NBLOCK(c)) & UMM_BLOCKNO_MASK) - UMM_NBLOCK(c); } if ((UMM_NBLOCK(UMM_PBLOCK(c)) & UMM_FREELIST_MASK)) { prevBlockSize = (c - UMM_PBLOCK(c)); } DBGLOG_DEBUG( "realloc blocks %i blockSize %i nextBlockSize %i prevBlockSize %i\n", blocks, blockSize, nextBlockSize, prevBlockSize ); /* * Ok, now that we're here we know how many blocks we want and the current * blockSize. The prevBlockSize and nextBlockSize are set and we can figure * out the best strategy for the new allocation as follows: * * 1. If the new block is the same size or smaller than the current block do * nothing. * 2. If the next block is free and adding it to the current block gives us * enough memory, assimilate the next block. * 3. If the prev block is free and adding it to the current block gives us * enough memory, remove the previous block from the free list, assimilate * it, copy to the new block. * 4. If the prev and next blocks are free and adding them to the current * block gives us enough memory, assimilate the next block, remove the * previous block from the free list, assimilate it, copy to the new block. * 5. Otherwise try to allocate an entirely new block of memory. If the * allocation works free the old block and return the new pointer. If * the allocation fails, return NULL and leave the old block intact. * * All that's left to do is decide if the fit was exact or not. If the fit * was not exact, then split the memory block so that we use only the requested * number of blocks and add what's left to the free list. */ if (blockSize >= blocks) { DBGLOG_DEBUG( "realloc the same or smaller size block - %i, do nothing\n", blocks ); /* This space intentionally left blank */ } else if ((blockSize + nextBlockSize) >= blocks) { DBGLOG_DEBUG( "realloc using next block - %i\n", blocks ); umm_assimilate_up( c ); blockSize += nextBlockSize; } else if ((prevBlockSize + blockSize) >= blocks) { DBGLOG_DEBUG( "realloc using prev block - %i\n", blocks ); umm_disconnect_from_free_list( UMM_PBLOCK(c) ); c = umm_assimilate_down(c, 0); memmove( (void *)&UMM_DATA(c), ptr, curSize ); ptr = (void *)&UMM_DATA(c); blockSize += prevBlockSize; } else if ((prevBlockSize + blockSize + nextBlockSize) >= blocks) { DBGLOG_DEBUG( "realloc using prev and next block - %i\n", blocks ); umm_assimilate_up( c ); umm_disconnect_from_free_list( UMM_PBLOCK(c) ); c = umm_assimilate_down(c, 0); memmove( (void *)&UMM_DATA(c), ptr, curSize ); ptr = (void *)&UMM_DATA(c); blockSize += (prevBlockSize + nextBlockSize); } else { DBGLOG_DEBUG( "realloc a completely new block %i\n", blocks ); void *oldptr = ptr; if( (ptr = umm_malloc( size )) ) { DBGLOG_DEBUG( "realloc %i to a bigger block %i, copy, and free the old\n", blockSize, blocks ); memcpy( ptr, oldptr, curSize ); umm_free( oldptr ); } else { DBGLOG_DEBUG( "realloc %i to a bigger block %i failed - return NULL and leave the old block!\n", blockSize, blocks ); /* This space intentionally left blnk */ } blockSize = blocks; } /* Now all we need to do is figure out if the block fit exactly or if we * need to split and free ... */ if (blockSize > blocks ) { DBGLOG_DEBUG( "split and free %i blocks from %i\n", blocks, blockSize ); umm_split_block( c, blocks, 0 ); umm_free( (void *)&UMM_DATA(c+blocks) ); } /* Release the critical section... */ UMM_CRITICAL_EXIT(); return( ptr ); }
void *umm_malloc( size_t size ) { unsigned short int blocks; unsigned short int blockSize = 0; unsigned short int bestSize; unsigned short int bestBlock; unsigned short int cf; if (umm_heap == NULL) { umm_init(); } /* * the very first thing we do is figure out if we're being asked to allocate * a size of 0 - and if we are we'll simply return a null pointer. if not * then reduce the size by 1 byte so that the subsequent calculations on * the number of blocks to allocate are easier... */ if( 0 == size ) { DBGLOG_DEBUG( "malloc a block of 0 bytes -> do nothing\n" ); return( (void *)NULL ); } /* Protect the critical section... */ UMM_CRITICAL_ENTRY(); blocks = umm_blocks( size ); /* * Now we can scan through the free list until we find a space that's big * enough to hold the number of blocks we need. * * This part may be customized to be a best-fit, worst-fit, or first-fit * algorithm */ cf = UMM_NFREE(0); bestBlock = UMM_NFREE(0); bestSize = 0x7FFF; while( cf ) { blockSize = (UMM_NBLOCK(cf) & UMM_BLOCKNO_MASK) - cf; DBGLOG_TRACE( "Looking at block %6i size %6i\n", cf, blockSize ); #if defined UMM_BEST_FIT if( (blockSize >= blocks) && (blockSize < bestSize) ) { bestBlock = cf; bestSize = blockSize; } #elif defined UMM_FIRST_FIT /* This is the first block that fits! */ if( (blockSize >= blocks) ) break; #else # error "No UMM_*_FIT is defined - check umm_malloc_cfg.h" #endif cf = UMM_NFREE(cf); } if( 0x7FFF != bestSize ) { cf = bestBlock; blockSize = bestSize; } if( UMM_NBLOCK(cf) & UMM_BLOCKNO_MASK && blockSize >= blocks ) { /* * This is an existing block in the memory heap, we just need to split off * what we need, unlink it from the free list and mark it as in use, and * link the rest of the block back into the freelist as if it was a new * block on the free list... */ if( blockSize == blocks ) { /* It's an exact fit and we don't neet to split off a block. */ DBGLOG_DEBUG( "Allocating %6i blocks starting at %6i - exact\n", blocks, cf ); /* Disconnect this block from the FREE list */ umm_disconnect_from_free_list( cf ); } else { /* It's not an exact fit and we need to split off a block. */ DBGLOG_DEBUG( "Allocating %6i blocks starting at %6i - existing\n", blocks, cf ); /* * split current free block `cf` into two blocks. The first one will be * returned to user, so it's not free, and the second one will be free. */ umm_split_block( cf, blocks, UMM_FREELIST_MASK /*new block is free*/ ); /* * `umm_split_block()` does not update the free pointers (it affects * only free flags), but effectively we've just moved beginning of the * free block from `cf` to `cf + blocks`. So we have to adjust pointers * to and from adjacent free blocks. */ /* previous free block */ UMM_NFREE( UMM_PFREE(cf) ) = cf + blocks; UMM_PFREE( cf + blocks ) = UMM_PFREE(cf); /* next free block */ UMM_PFREE( UMM_NFREE(cf) ) = cf + blocks; UMM_NFREE( cf + blocks ) = UMM_NFREE(cf); } } else { /* Out of memory */ DBGLOG_DEBUG( "Can't allocate %5i blocks\n", blocks ); /* Release the critical section... */ UMM_CRITICAL_EXIT(); return( (void *)NULL ); } /* Release the critical section... */ UMM_CRITICAL_EXIT(); return( (void *)&UMM_DATA(cf) ); }
void ICACHE_RAM_ATTR vPortInitialiseBlocks(void){ return umm_init(); }