static void test_heap_cases_1(void)
{
void *p1, *p2, *p3;
uintptr_t u1, u2;
Heap_Resize_status rsc;
/*
* Another odd case. What we are trying to do from Sergei
*
* 32-bit CPU when CPU_ALIGNMENT = 4 (most targets have 8) with the
* code like this:
*/
test_heap_default_init();
p1 = _Heap_Allocate( &TestHeap, 12 );
p2 = _Heap_Allocate( &TestHeap, 32 );
p3 = _Heap_Allocate( &TestHeap, 32 );
test_free( p2 );
p2 = _Heap_Allocate_aligned( &TestHeap, 8, 28 );
test_free( p1 );
test_free( p2 );
test_free( p3 );
/*
* Odd case in resizing a block. Again test case outline per Sergei
*/
test_heap_default_init();
p1 = _Heap_Allocate( &TestHeap, 32 );
p2 = _Heap_Allocate( &TestHeap, 8 );
p3 = _Heap_Allocate( &TestHeap, 32 );
test_free( p2 );
rsc = _Heap_Resize_block( &TestHeap, p1, 41, &u1, &u2 );
/* XXX what should we expect */
test_free( p3 );
test_free( p1 );
/*
* To tackle a special case of resizing a block in order to cover the
* code in heapresizeblock.c
*
* Re-initialise the heap, so that the blocks created from now on
* are contiguous.
*/
test_heap_default_init();
puts( "Heap Initialized" );
p1 = _Heap_Allocate( &TestHeap, 400 );
rtems_test_assert( p1 != NULL );
p2 = _Heap_Allocate( &TestHeap, 496 );
rtems_test_assert( p2 != NULL );
rsc = _Heap_Resize_block( &TestHeap, p1, 256, &u1, &u2 );
rtems_test_assert( rsc == HEAP_RESIZE_SUCCESSFUL );
test_free( p1 );
test_free( p2 );
}
/*
* Exercise case in heapresize.c around line 125 when new_block_size
* < min_block_size
*/
void test_case_one(void)
{
uint32_t heap_size;
void *ptr1;
uintptr_t old;
uintptr_t avail;
Heap_Resize_status hc;
puts( "Init - _Heap_Initialize (for test one) - OK" );
heap_size = _Heap_Initialize( &Heap, Memory, sizeof(Memory), 8 );
printf( "Init - Heap size=%" PRIu32 "\n", heap_size );
rtems_test_assert( heap_size );
puts( "Init - _Heap_Allocate - too large size (overflow)- not OK");
ptr1 = _Heap_Allocate( &Heap, UINTPTR_MAX );
rtems_test_assert( !ptr1 );
puts( "Init - _Heap_Allocate_aligned - OK");
ptr1 = _Heap_Allocate_aligned( &Heap, 64, 32 );
rtems_test_assert( ptr1 );
puts( "Init - _Heap_Resize_block - OK");
hc = _Heap_Resize_block( &Heap, ptr1, 4, &old, &avail );
rtems_test_assert( !hc );
}
boolean _Protected_heap_Resize_block(
Heap_Control *the_heap,
void *starting_address,
size_t size
)
{
Heap_Resize_status status;
uint32_t old_mem_size;
uint32_t avail_mem_size;
_RTEMS_Lock_allocator();
status = _Heap_Resize_block(
the_heap, starting_address, size, &old_mem_size, &avail_mem_size );
_RTEMS_Unlock_allocator();
return (status == HEAP_RESIZE_SUCCESSFUL);
}
static void test_simple_resize_block(
void *alloc_pointer,
uintptr_t new_alloc_size,
Heap_Resize_status expected_status
)
{
uintptr_t old_size = 0;
uintptr_t new_size = 0;
Heap_Resize_status status = _Heap_Resize_block(
&TestHeap,
alloc_pointer,
new_alloc_size,
&old_size,
&new_size
);
rtems_test_assert( status == expected_status );
}
/*
* Exercise case in heapresize.c around line 140 when next_is_used AND
* free_block_size < min_block_size.
*/
void test_case_two(void)
{
uint32_t heap_size;
void *ptr1;
uintptr_t old;
uintptr_t avail;
Heap_Resize_status hc;
puts( "\nInit - _Heap_Initialize (for test two) - OK" );
heap_size = _Heap_Initialize( &Heap, Memory, sizeof(Memory), 8 );
printf( "Init - Heap size=%" PRIu32 "\n", heap_size );
rtems_test_assert( heap_size );
puts( "Init - _Heap_Allocate_aligned - OK");
ptr1 = _Heap_Allocate_aligned( &Heap, 64, 4 );
rtems_test_assert( ptr1 );
puts( "Init - _Heap_Resize_block - OK");
hc = _Heap_Resize_block( &Heap, ptr1, 56, &old, &avail );
rtems_test_assert( !hc );
}
rtems_status_code rtems_region_resize_segment(
rtems_id id,
void *segment,
uintptr_t size,
uintptr_t *old_size
)
{
uintptr_t avail_size;
Objects_Locations location;
uintptr_t osize;
rtems_status_code return_status;
Heap_Resize_status status;
register Region_Control *the_region;
if ( !old_size )
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
the_region = _Region_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_Region_Debug_Walk( the_region, 7 );
status = _Heap_Resize_block(
&the_region->Memory,
segment,
(uint32_t) size,
&osize,
&avail_size
);
*old_size = (uint32_t) osize;
_Region_Debug_Walk( the_region, 8 );
if ( status == HEAP_RESIZE_SUCCESSFUL )
_Region_Process_queue( the_region ); /* unlocks allocator */
else
_RTEMS_Unlock_allocator();
if (status == HEAP_RESIZE_SUCCESSFUL)
return RTEMS_SUCCESSFUL;
if (status == HEAP_RESIZE_UNSATISFIED)
return RTEMS_UNSATISFIED;
return RTEMS_INVALID_ADDRESS;
break;
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* this error cannot be returned */
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}