/*
* Use a timer to execute the actions, since it runs with thread dispatching
* disabled. This is necessary to check the expected processor allocations.
*/
static void timer(rtems_id id, void *arg)
{
test_context *ctx;
rtems_status_code sc;
size_t i;
ctx = arg;
i = ctx->action_index;
if (i == 0) {
sc = rtems_task_suspend(ctx->master_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
if (i < RTEMS_ARRAY_SIZE(test_actions)) {
const test_action *action = &test_actions[i];
rtems_id task;
ctx->action_index = i + 1;
task = ctx->task_ids[action->index];
switch (action->kind) {
case KIND_SET_PRIORITY:
set_priority(task, action->data.priority);
break;
case KIND_SET_AFFINITY:
set_affinity(task, action->data.cpu_set);
break;
case KIND_BLOCK:
sc = rtems_task_suspend(task);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
break;
case KIND_UNBLOCK:
sc = rtems_task_resume(task);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
break;
default:
rtems_test_assert(action->kind == KIND_RESET);
reset(ctx);
break;
}
check_cpu_allocations(ctx, action);
sc = rtems_timer_reset(id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
} else {
sc = rtems_task_resume(ctx->master_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_event_transient_send(ctx->master_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
}
rtems_task Task_1(
rtems_task_argument argument
)
{
rtems_id tid2;
rtems_id tid3;
uint32_t pass;
rtems_status_code status;
status = rtems_task_ident( Task_name[ 2 ], 1, &tid2 );
directive_failed( status, "rtems_task_ident of TA2" );
status = rtems_task_ident( Task_name[ 3 ], 1, &tid3 );
directive_failed( status, "rtems_task_ident of TA3" );
for ( pass=1 ; pass <= 3 ; pass++ ) {
puts( "TA1 - rtems_task_wake_after - sleep 5 seconds" );
status = rtems_task_wake_after( 5*rtems_clock_get_ticks_per_second() );
directive_failed( status, "rtems_task_wake_after of TA1" );
puts( "TA1 - rtems_task_suspend - suspend TA3" );
status = rtems_task_suspend( tid3 );
if ( pass == 1 ) {
fatal_directive_status(
status,
RTEMS_ALREADY_SUSPENDED,
"rtems_task_suspend of TA3"
);
} else {
directive_failed( status, "rtems_task_suspend of TA3" );
}
puts( "TA1 - rtems_task_resume - resume TA2" );
status = rtems_task_resume( tid2 );
directive_failed( status, "rtems_task_resume of TA2" );
puts( "TA1 - rtems_task_wake_after - sleep 5 seconds" );
status = rtems_task_wake_after( 5*rtems_clock_get_ticks_per_second() );
directive_failed( status, "rtems_task_wake_after" );
puts( "TA1 - rtems_task_suspend - suspend TA2" );
status = rtems_task_suspend( tid2 );
directive_failed( status, "rtems_task_suspend of TA2" );
puts( "TA1 - rtems_task_resume - resume TA3" );
status = rtems_task_resume( tid3 );
directive_failed( status, "rtems_task_resume" );
}
TEST_END();
rtems_test_exit( 0 );
}
static void resume(rtems_id task)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_task_resume(task);
ASSERT_SC(sc);
}
static void
subTask2 (rtems_task_argument arg)
{
rtems_status_code sc;
rtems_event_set ev;
rtems_task_wake_after (ticksPerSecond * 1);
sc = rtems_event_receive(
1,
RTEMS_WAIT|RTEMS_EVENT_ANY,
RTEMS_NO_TIMEOUT,
&ev
);
if (sc != RTEMS_SUCCESSFUL) {
printf ("subTask2 - Can't receive event (%d)\n", sc);
rtems_task_suspend (RTEMS_SELF);
}
printf ("subTask2 - Task 1 suspended? - should be 0: %d\n",
isSuspended (taskId1));
rtems_task_wake_after (ticksPerSecond * 4);
printf ("subTask2 - Task 1 suspended? - should be 1: %d\n",
isSuspended (taskId1));
rtems_task_resume (taskId1);
printf ("subTask2 - Task 1 suspended? - should be 0: %d\n",
isSuspended (taskId1));
rtems_task_wake_after (ticksPerSecond * 4);
printf ("subTask2 - Task 1 suspended? - should be 1: %d\n",
isSuspended (taskId1));
puts( "*** END OF TEST 26 ***" );
rtems_test_exit( 0 );
}
/*
* Timer Service Routine
*
* If we are in an ISR, then this is a normal clock tick.
* If we are not, then it is the test case.
*/
rtems_timer_service_routine test_unblock_task(
rtems_id timer,
void *arg
)
{
bool in_isr;
rtems_status_code status;
in_isr = rtems_interrupt_is_in_progress();
status = rtems_task_is_suspended( blocked_task_id );
if ( in_isr ) {
status = rtems_timer_fire_after( timer, 1, test_unblock_task, NULL );
directive_failed( status, "timer_fire_after failed" );
return;
}
if ( (status != RTEMS_ALREADY_SUSPENDED) ) {
status = rtems_timer_fire_after( timer, 1, test_unblock_task, NULL );
directive_failed( status, "timer_fire_after failed" );
return;
}
blocked_task_status = 2;
_Thread_Disable_dispatch();
status = rtems_task_resume( blocked_task_id );
_Thread_Unnest_dispatch();
#if defined( RTEMS_SMP )
directive_failed_with_level( status, "rtems_task_resume", 1 );
#else
directive_failed( status, "rtems_task_resume" );
#endif
}
static void reset(test_context *ctx)
{
rtems_status_code sc;
size_t i;
for (i = 0; i < TASK_COUNT; ++i) {
set_priority(ctx->task_ids[i], P(i));
set_affinity(ctx->task_ids[i], A(1, 1));
}
for (i = CPU_COUNT; i < TASK_COUNT; ++i) {
sc = rtems_task_suspend(ctx->task_ids[i]);
rtems_test_assert(sc == RTEMS_SUCCESSFUL || sc == RTEMS_ALREADY_SUSPENDED);
}
for (i = 0; i < CPU_COUNT; ++i) {
sc = rtems_task_resume(ctx->task_ids[i]);
rtems_test_assert(sc == RTEMS_SUCCESSFUL || sc == RTEMS_INCORRECT_STATE);
}
/* Order the idle threads explicitly */
for (i = 0; i < CPU_COUNT; ++i) {
const Per_CPU_Control *c;
const Thread_Control *h;
c = _Per_CPU_Get_by_index(CPU_COUNT - 1 - i);
h = c->heir;
sc = rtems_task_suspend(h->Object.id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
}
static void restart_task(rtems_task_argument arg)
{
rtems_status_code sc;
if (arg == 0) {
rtems_test_assert(set_prio(RTEMS_SELF, 3) == 2);
rtems_task_restart(RTEMS_SELF, 1);
} else if (arg == 1) {
rtems_id scheduler_id;
rtems_test_assert(set_prio(RTEMS_SELF, 3) == 2);
sc = rtems_task_get_scheduler(RTEMS_SELF, &scheduler_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_set_scheduler(RTEMS_SELF, scheduler_id, 4);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(set_prio(RTEMS_SELF, 3) == 4);
rtems_task_restart(RTEMS_SELF, 2);
} else {
rtems_test_assert(set_prio(RTEMS_SELF, 3) == 4);
rtems_task_resume(master_id);
}
rtems_test_assert(0);
}
void epicsThreadResume(epicsThreadId id)
{
rtems_id tid = (rtems_id)id;
rtems_status_code sc;
sc = rtems_task_resume (tid);
if(sc != RTEMS_SUCCESSFUL)
errlogPrintf("epicsThreadResume failed: %s\n", rtems_status_text (sc));
}
rtems_task Middle_tasks(
rtems_task_argument argument
)
{
(void) rtems_task_suspend( RTEMS_SELF );
Task_index++;
(void) rtems_task_resume( Task_id[ Task_index ] );
}
rtems_timer_service_routine Delayed_resume(
rtems_id ignored_id,
void *ignored_address
)
{
rtems_status_code status;
status = rtems_task_resume( Task_id[ 1 ] );
directive_failed_with_level( status, "rtems_task_resume of self", 1 );
}
rtems_asr Process_asr_for_pass_2(
rtems_signal_set signals
)
{
rtems_status_code status;
status = rtems_task_resume( Task_id[ 3 ] );
directive_failed( status, "rtems_task_resume" );
benchmark_timer_initialize();
}
rtems_timer_service_routine Resume_task(
rtems_id timer_id,
void *ignored_address
)
{
rtems_id task_to_resume;
rtems_status_code status;
task_to_resume = Task_id[ rtems_object_id_get_index( timer_id ) ];
status = rtems_task_resume( task_to_resume );
directive_failed( status, "rtems_task_resume" );
}
rtems_task Task01( rtems_task_argument ignored )
{
/* Start up TA02, get preempted */
status = rtems_task_start( Task_id[1], Task02, 0);
directive_failed( status, "rtems_task_start of TA02");
tswitch_overhead = benchmark_timer_read();
benchmark_timer_initialize();
/* Benchmark code */
for ( count1 = 0; count1 < BENCHMARKS; count1++ ) {
rtems_task_resume( Task_id[1] ); /* Awaken TA02, preemption occurs */
}
/* Should never reach here */
rtems_test_assert( false );
}
rtems_task Low_task(
rtems_task_argument argument
)
{
end_time = benchmark_timer_read();
put_time(
"rtems_task_suspend: calling task",
end_time,
operation_count,
0,
CALLING_OVERHEAD_TASK_SUSPEND
);
Task_index = 1;
benchmark_timer_initialize();
(void) rtems_task_resume( Task_id[ Task_index ] );
}
static void task_low(rtems_task_argument arg)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *bd = NULL;
printk("L: try access: 0\n");
sc = rtems_bdbuf_get(dd, 0, &bd);
ASSERT_SC(sc);
printk("L: access: 0\n");
sc = rtems_task_resume(task_id_high);
ASSERT_SC(sc);
sc = rtems_bdbuf_sync(bd);
ASSERT_SC(sc);
printk("L: sync done: 0\n");
rtems_test_assert(false);
}
static void task_resume(rtems_task_argument arg)
{
while (true) {
bool do_resume = false;
switch (resume) {
case RESUME_IMMEDIATE:
print(2, "RI\n");
do_resume = true;
break;
case RESUME_FINISH:
print(2, "RF\n");
do_resume = finish_low && finish_high;
break;
default:
rtems_test_assert(false);
break;
}
if (do_resume) {
rtems_task_resume(task_id_init);
}
}
}
void ObtainRelease( bool suspendIdle )
{
rtems_status_code status;
if (suspendIdle) {
puts( "INIT - Suspend Idle Task");
status = rtems_task_suspend( Idle_id );
directive_failed( status, "rtems_task_suspend idle" );
}
puts( "INIT - Obtain priority ceiling semaphore - priority increases" );
status= rtems_semaphore_obtain( Semaphore_id[1], RTEMS_DEFAULT_OPTIONS, 0 );
directive_failed( status, "rtems_semaphore_obtain" );
puts( "INIT - Obtain priority ceiling semaphore - priority decreases" );
status = rtems_semaphore_release( Semaphore_id[1] );
directive_failed( status, "rtems_semaphore_release" );
if (suspendIdle) {
puts( "INIT - Resume Idle Task");
status = rtems_task_resume( Idle_id );
directive_failed( status, "rtems_task_resume idle" );
}
}
rtems_task Tasks_Aperiodic(
rtems_task_argument argument
)
{
rtems_status_code status;
int start;
int stop;
int now;
put_name( Task_name[ argument ], FALSE );
status = rtems_task_wake_after( 2 + Phases[argument] );
directive_failed( status, "rtems_task_wake_after" );
if ( argument == 6 ) {
rtems_task_suspend( Task_id[5] );
rtems_task_resume( Task_id[5] );
}
rtems_clock_get(RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &start);
printf("AT%" PRIdPTR "-S ticks:%d\n", argument, start);
/* active computing */
while(FOREVER) {
rtems_clock_get(RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &now);
if (now >= start + Execution[argument]) break;
}
rtems_clock_get(RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &stop);
printf("P%" PRIdPTR "-F ticks:%d\n", argument, stop);
/* delete SELF */
fflush(stdout);
printf( "Killing task %" PRIdPTR "\n", argument);
status = rtems_task_delete(RTEMS_SELF);
directive_failed(status, "rtems_task_delete of RTEMS_SELF");
}
void Screen1()
{
uint32_t notepad_value;
rtems_id self_id;
rtems_task_priority previous_priority;
rtems_status_code status;
/* bad Id */
status = rtems_task_is_suspended( 100 );
fatal_directive_status(
status,
RTEMS_INVALID_ID,
"rtems_task_set_priority with illegal id"
);
puts( "TA1 - rtems_task_is_suspended - RTEMS_INVALID_ID" );
/* bad Id */
status = rtems_task_delete( 100 );
fatal_directive_status(
status,
RTEMS_INVALID_ID,
"rtems_task_delete with illegal id"
);
puts( "TA1 - rtems_task_delete - RTEMS_INVALID_ID" );
/* NULL return */
status = rtems_task_get_note( RTEMS_SELF, RTEMS_NOTEPAD_FIRST, NULL );
fatal_directive_status(
status,
RTEMS_INVALID_ADDRESS,
"rtems_task_get_note with NULL param"
);
puts( "TA1 - rtems_task_get_note - RTEMS_INVALID_ADDRESS" );
/* note too high */
status = rtems_task_get_note( RTEMS_SELF, 100, ¬epad_value );
fatal_directive_status(
status,
RTEMS_INVALID_NUMBER,
"rtems_task_get_note with illegal notepad"
);
puts( "TA1 - rtems_task_get_note - RTEMS_INVALID_NUMBER" );
/* bad Id */
status = rtems_task_get_note( 100, RTEMS_NOTEPAD_LAST, ¬epad_value );
fatal_directive_status(
status,
RTEMS_INVALID_ID,
"rtems_task_get_note with illegal id"
);
puts( "TA1 - rtems_task_get_note - RTEMS_INVALID_ID" );
/* unused Id so invalid now */
status = rtems_task_get_note(
_RTEMS_tasks_Information.maximum_id,
RTEMS_NOTEPAD_LAST,
¬epad_value
);
fatal_directive_status(
status,
RTEMS_INVALID_ID,
"rtems_task_get_note with illegal id"
);
puts( "TA1 - rtems_task_get_note - RTEMS_INVALID_ID" );
status = rtems_task_get_note(
_RTEMS_tasks_Information.minimum_id + (3L<<OBJECTS_API_START_BIT),
RTEMS_NOTEPAD_LAST,
¬epad_value
);
fatal_directive_status(
status,
RTEMS_INVALID_ID,
"rtems_task_get_note with illegal id"
);
status = rtems_task_get_note(
rtems_build_id( OBJECTS_CLASSIC_API, 2, 1, 1 ),
RTEMS_NOTEPAD_LAST,
¬epad_value
);
fatal_directive_status(
status,
RTEMS_INVALID_ID,
"rtems_task_get_note with non-task ID"
);
/* NULL param */
status = rtems_task_ident( RTEMS_SELF, RTEMS_SEARCH_ALL_NODES, NULL );
fatal_directive_status(
status,
RTEMS_INVALID_ADDRESS,
"rtems_task_ident NULL param"
);
puts( "TA1 - rtems_task_ident - RTEMS_INVALID_ADDRESS" );
/* OK */
status = rtems_task_ident( RTEMS_SELF, RTEMS_SEARCH_ALL_NODES, &self_id );
directive_failed( status, "rtems_task_ident of self" );
if ( self_id != Task_id[ 1 ] ) {
puts( "ERROR - rtems_task_ident - incorrect ID returned!" );
}
puts( "TA1 - rtems_task_ident - current task RTEMS_SUCCESSFUL" );
status = rtems_task_ident( 100, RTEMS_SEARCH_ALL_NODES, &Junk_id );
fatal_directive_status(
status,
RTEMS_INVALID_NAME,
"rtems_task_ident with illegal name (local)"
);
puts( "TA1 - rtems_task_ident - global RTEMS_INVALID_NAME" );
status = rtems_task_ident( 100, 1, &Junk_id );
fatal_directive_status(
status,
RTEMS_INVALID_NAME,
"rtems_task_ident with illegal name (global)"
);
puts( "TA1 - rtems_task_ident - local RTEMS_INVALID_NAME" );
/*
* This one case is different if MP is enabled/disabled.
*/
status = rtems_task_ident( 100, 2, &Junk_id );
#if defined(RTEMS_MULTIPROCESSING)
fatal_directive_status(
status,
RTEMS_INVALID_NODE,
"rtems_task_ident with illegal node"
);
#else
fatal_directive_status(
status,
RTEMS_INVALID_NAME,
"rtems_task_ident with illegal node"
);
#endif
puts( "TA1 - rtems_task_ident - RTEMS_INVALID_NODE" );
status = rtems_task_restart( 100, 0 );
fatal_directive_status(
status,
RTEMS_INVALID_ID,
"rtems_task_restart with illegal id"
);
puts( "TA1 - rtems_task_restart - RTEMS_INVALID_ID" );
status = rtems_task_resume( 100 );
fatal_directive_status(
status,
RTEMS_INVALID_ID,
"rtems_task_resume with illegal id"
);
puts( "TA1 - rtems_task_resume - RTEMS_INVALID_ID" );
status = rtems_task_resume( RTEMS_SELF );
fatal_directive_status(
status,
RTEMS_INCORRECT_STATE,
"rtems_task_resume of ready task"
);
puts( "TA1 - rtems_task_resume - RTEMS_INCORRECT_STATE" );
/* NULL param */
status = rtems_task_set_priority( RTEMS_SELF, RTEMS_CURRENT_PRIORITY, NULL );
fatal_directive_status(
status,
RTEMS_INVALID_ADDRESS,
"rtems_task_set_priority with NULL param"
);
puts( "TA1 - rtems_task_set_priority - RTEMS_INVALID_ADDRESS" );
/* bad priority */
status = rtems_task_set_priority( RTEMS_SELF, 512, &previous_priority );
fatal_directive_status(
status,
RTEMS_INVALID_PRIORITY,
"rtems_task_set_priority with illegal priority"
);
puts( "TA1 - rtems_task_set_priority - RTEMS_INVALID_PRIORITY" );
/* bad Id */
status = rtems_task_set_priority( 100, 8, &previous_priority );
fatal_directive_status(
status,
RTEMS_INVALID_ID,
"rtems_task_set_priority with illegal id"
);
puts( "TA1 - rtems_task_set_priority - RTEMS_INVALID_ID" );
status = rtems_task_set_note(
RTEMS_SELF,
RTEMS_NOTEPAD_LAST+10,
notepad_value
);
fatal_directive_status(
status,
RTEMS_INVALID_NUMBER,
"rtems_task_set_note with illegal notepad"
);
puts( "TA1 - rtems_task_set_note - RTEMS_INVALID_NUMBER" );
status = rtems_task_set_note( 100, RTEMS_NOTEPAD_LAST, notepad_value );
fatal_directive_status(
status,
RTEMS_INVALID_ID,
"rtems_task_set_note with illegal id"
);
puts( "TA1 - rtems_task_set_note - RTEMS_INVALID_ID" );
status = rtems_task_start( 100, Task_1, 0 );
fatal_directive_status(
status,
RTEMS_INVALID_ID,
"rtems_task_start with illegal id"
);
puts( "TA1 - rtems_task_start - RTEMS_INVALID_ID" );
/* already started */
status = rtems_task_start( RTEMS_SELF, Task_1, 0 );
fatal_directive_status(
status,
RTEMS_INCORRECT_STATE,
"rtems_task_start of ready task"
);
puts( "TA1 - rtems_task_start - RTEMS_INCORRECT_STATE" );
/* bad Id */
status = rtems_task_suspend( 100 );
fatal_directive_status(
status,
RTEMS_INVALID_ID,
"rtems_task_suspend with illegal id"
);
puts( "TA1 - rtems_task_suspend - RTEMS_INVALID_ID" );
/* NULL param */
status = rtems_task_mode( RTEMS_SELF, 0, NULL );
fatal_directive_status(
status,
RTEMS_INVALID_ADDRESS,
"rtems_task_mode with NULL param"
);
puts( "TA1 - rtems_task_mode - RTEMS_INVALID_ADDRESS" );
}
rtems_task Task_1(
rtems_task_argument argument
)
{
rtems_name name RTEMS_GCC_NOWARN_UNUSED;
uint32_t index RTEMS_GCC_NOWARN_UNUSED;
rtems_id id RTEMS_GCC_NOWARN_UNUSED;
rtems_task_priority in_priority RTEMS_GCC_NOWARN_UNUSED;
rtems_task_priority out_priority RTEMS_GCC_NOWARN_UNUSED;
rtems_mode in_mode RTEMS_GCC_NOWARN_UNUSED;
rtems_mode mask RTEMS_GCC_NOWARN_UNUSED;
rtems_mode out_mode RTEMS_GCC_NOWARN_UNUSED;
rtems_time_of_day time RTEMS_GCC_NOWARN_UNUSED;
rtems_interval timeout RTEMS_GCC_NOWARN_UNUSED;
rtems_signal_set signals RTEMS_GCC_NOWARN_UNUSED;
void *address_1 RTEMS_GCC_NOWARN_UNUSED;
rtems_event_set events RTEMS_GCC_NOWARN_UNUSED;
long buffer[ 4 ] RTEMS_GCC_NOWARN_UNUSED;
uint32_t count RTEMS_GCC_NOWARN_UNUSED;
rtems_device_major_number major RTEMS_GCC_NOWARN_UNUSED;
rtems_device_minor_number minor RTEMS_GCC_NOWARN_UNUSED;
uint32_t io_result RTEMS_GCC_NOWARN_UNUSED;
uint32_t error RTEMS_GCC_NOWARN_UNUSED;
rtems_clock_get_options options RTEMS_GCC_NOWARN_UNUSED;
name = rtems_build_name( 'N', 'A', 'M', 'E' );
in_priority = 250;
in_mode = RTEMS_NO_PREEMPT;
mask = RTEMS_PREEMPT_MASK;
timeout = 100;
signals = RTEMS_SIGNAL_1 | RTEMS_SIGNAL_3;
major = 10;
minor = 0;
error = 100;
options = 0;
/* rtems_shutdown_executive */
benchmark_timer_initialize();
for ( index=1 ; index <= OPERATION_COUNT ; index++ )
(void) rtems_shutdown_executive( error );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_shutdown_executive",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_task_create */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_task_create(
name,
in_priority,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&id
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_task_create",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_task_ident */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_task_ident( name, RTEMS_SEARCH_ALL_NODES, id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_task_ident",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_task_start */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_task_start( id, Task_1, 0 );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_task_start",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_task_restart */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_task_restart( id, 0 );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_task_restart",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_task_delete */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_task_delete( id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_task_delete",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_task_suspend */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_task_suspend( id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_task_suspend",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_task_resume */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_task_resume( id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_task_resume",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_task_set_priority */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_task_set_priority( id, in_priority, &out_priority );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_task_set_priority",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_task_mode */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_task_mode( in_mode, mask, &out_mode );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_task_mode",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_task_wake_when */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_task_wake_when( time );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_task_wake_when",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_task_wake_after */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_task_wake_after( timeout );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_task_wake_after",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_interrupt_catch */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_interrupt_catch( Isr_handler, 5, address_1 );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_interrupt_catch",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_clock_get */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_clock_get( options, time );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_clock_get",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_clock_set */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_clock_set( time );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_clock_set",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_clock_tick */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_clock_tick();
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_clock_tick",
end_time,
OPERATION_COUNT,
overhead,
0
);
rtems_test_pause();
/* rtems_timer_create */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_timer_create( name, &id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_timer_create",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_timer_delete */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_timer_delete( id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_timer_delete",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_timer_ident */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_timer_ident( name, id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_timer_ident",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_timer_fire_after */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_timer_fire_after(
id,
timeout,
Timer_handler,
NULL
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_timer_fire_after",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_timer_fire_when */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_timer_fire_when(
id,
time,
Timer_handler,
NULL
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_timer_fire_when",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_timer_reset */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_timer_reset( id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_timer_reset",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_timer_cancel */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_timer_cancel( id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_timer_cancel",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_semaphore_create */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_semaphore_create(
name,
128,
RTEMS_DEFAULT_ATTRIBUTES,
RTEMS_NO_PRIORITY,
&id
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_semaphore_create",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_semaphore_delete */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_semaphore_delete( id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_semaphore_delete",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_semaphore_ident */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_semaphore_ident( name, RTEMS_SEARCH_ALL_NODES, id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_semaphore_ident",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_semaphore_obtain */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_semaphore_obtain( id, RTEMS_DEFAULT_OPTIONS, timeout );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_semaphore_obtain",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_semaphore_release */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_semaphore_release( id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_semaphore_release",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_message_queue_create */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_message_queue_create(
name,
128,
RTEMS_DEFAULT_ATTRIBUTES,
&id
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_message_queue_create",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_message_queue_ident */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_message_queue_ident(
name,
RTEMS_SEARCH_ALL_NODES,
id
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_message_queue_ident",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_message_queue_delete */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_message_queue_delete( id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_message_queue_delete",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_message_queue_send */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_message_queue_send( id, (long (*)[4])buffer );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_message_queue_send",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_message_queue_urgent */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_message_queue_urgent( id, (long (*)[4])buffer );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_message_queue_urgent",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_message_queue_broadcast */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_message_queue_broadcast(
id,
(long (*)[4])buffer,
&count
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_message_queue_broadcast",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_message_queue_receive */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_message_queue_receive(
id,
(long (*)[4])buffer,
RTEMS_DEFAULT_OPTIONS,
timeout
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_message_queue_receive",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_message_queue_flush */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_message_queue_flush( id, &count );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_message_queue_flush",
end_time,
OPERATION_COUNT,
overhead,
0
);
rtems_test_pause();
/* rtems_event_send */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_event_send( id, events );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_event_send",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_event_receive */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_event_receive(
RTEMS_EVENT_16,
RTEMS_DEFAULT_OPTIONS,
timeout,
&events
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_event_receive",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_signal_catch */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_signal_catch( Asr_handler, RTEMS_DEFAULT_MODES );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_signal_catch",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_signal_send */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_signal_send( id, signals );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_signal_send",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_partition_create */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_partition_create(
name,
Memory_area,
2048,
128,
RTEMS_DEFAULT_ATTRIBUTES,
&id
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_partition_create",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_partition_ident */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_partition_ident( name, RTEMS_SEARCH_ALL_NODES, id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_partition_ident",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_partition_delete */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_partition_delete( id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_partition_delete",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_partition_get_buffer */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_partition_get_buffer( id, address_1 );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_partition_get_buffer",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_partition_return_buffer */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_partition_return_buffer( id, address_1 );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_partition_return_buffer",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_region_create */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_region_create(
name,
Memory_area,
2048,
128,
RTEMS_DEFAULT_ATTRIBUTES,
&id
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_region_create",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_region_ident */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_region_ident( name, id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_region_ident",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_region_delete */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_region_delete( id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_region_delete",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_region_get_segment */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_region_get_segment(
id,
243,
RTEMS_DEFAULT_OPTIONS,
timeout,
&address_1
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_region_get_segment",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_region_return_segment */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_region_return_segment( id, address_1 );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_region_return_segment",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_port_create */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_port_create(
name,
Internal_port_area,
External_port_area,
0xff,
&id
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_port_create",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_port_ident */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_port_ident( name, id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_port_ident",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_port_delete */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_port_delete( id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_port_delete",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_port_external_to_internal */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_port_external_to_internal(
id,
&External_port_area[ 7 ],
address_1
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_port_external_to_internal",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_port_internal_to_external */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_port_internal_to_external(
id,
&Internal_port_area[ 7 ],
address_1
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_port_internal_to_external",
end_time,
OPERATION_COUNT,
overhead,
0
);
rtems_test_pause();
/* rtems_io_initialize */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_io_initialize(
major,
minor,
address_1,
&io_result
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_io_initialize",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_io_open */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_io_open(
major,
minor,
address_1,
&io_result
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_io_open",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_io_close */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_io_close(
major,
minor,
address_1,
&io_result
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_io_close",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_io_read */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_io_read(
major,
minor,
address_1,
&io_result
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_io_read",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_io_write */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_io_write(
major,
minor,
address_1,
&io_result
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_io_write",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_io_control */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_io_control(
major,
minor,
address_1,
&io_result
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_io_control",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_fatal_error_occurred */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_fatal_error_occurred( error );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_fatal_error_occurred",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_rate_monotonic_create */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_rate_monotonic_create( name, &id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_rate_monotonic_create",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_rate_monotonic_ident */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_rate_monotonic_ident( name, id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_rate_monotonic_ident",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_rate_monotonic_delete */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_rate_monotonic_delete( id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_rate_monotonic_delete",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_rate_monotonic_cancel */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_rate_monotonic_cancel( id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_rate_monotonic_cancel",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_rate_monotonic_period */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_rate_monotonic_period( id, timeout );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_rate_monotonic_period",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_multiprocessing_announce */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_multiprocessing_announce();
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_multiprocessing_announce",
end_time,
OPERATION_COUNT,
overhead,
0
);
TEST_END();
rtems_test_exit( 0 );
}
static void execute_test(unsigned i)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *bd = NULL;
bool suspend = false;
print(
1,
"[%05u]T(%c,%c,%s,%c)L(%c,%s,%c)H(%c,%s,%c)\n",
i,
trig_style_desc [trig],
get_type_desc [trig_get],
blk_kind_desc [trig_blk],
rel_type_desc [trig_rel],
get_type_desc [low_get],
blk_kind_desc [low_blk],
rel_type_desc [low_rel],
get_type_desc [high_get],
blk_kind_desc [high_blk],
rel_type_desc [high_rel]
);
set_task_prio(task_id_low, PRIORITY_LOW);
finish_low = false;
finish_high = false;
sc = rtems_task_resume(task_id_low);
ASSERT_SC(sc);
sc = rtems_task_resume(task_id_high);
ASSERT_SC(sc);
sc = rtems_bdbuf_get(dd_b, 0, &bd);
rtems_test_assert(sc == RTEMS_SUCCESSFUL && bd->dd == dd_b && bd->block == 0);
sc = rtems_bdbuf_release(bd);
ASSERT_SC(sc);
switch (trig) {
case SUSP:
suspend = true;
break;
case CONT:
suspend = false;
break;
default:
rtems_test_assert(false);
break;
}
print(2, "TG\n");
bd = get(trig_get, trig_blk);
if (suspend) {
print(2, "S\n");
resume = RESUME_IMMEDIATE;
sc = rtems_task_suspend(RTEMS_SELF);
ASSERT_SC(sc);
}
resume = RESUME_FINISH;
print(2, "TR\n");
rel(bd, trig_rel);
sc = rtems_task_suspend(RTEMS_SELF);
ASSERT_SC(sc);
print(2, "F\n");
sc = rtems_bdbuf_syncdev(dd_a);
ASSERT_SC(sc);
sc = rtems_bdbuf_syncdev(dd_b);
ASSERT_SC(sc);
}
void _RTEMS_tasks_MP_Process_packet (
rtems_packet_prefix *the_packet_prefix
)
{
RTEMS_tasks_MP_Packet *the_packet;
Thread_Control *the_thread;
bool ignored;
the_packet = (RTEMS_tasks_MP_Packet *) the_packet_prefix;
switch ( the_packet->operation ) {
case RTEMS_TASKS_MP_ANNOUNCE_CREATE:
ignored = _Objects_MP_Allocate_and_open(
&_RTEMS_tasks_Information.Objects,
the_packet->name,
the_packet->Prefix.id,
true
);
_MPCI_Return_packet( the_packet_prefix );
break;
case RTEMS_TASKS_MP_ANNOUNCE_DELETE:
_Objects_MP_Close(
&_RTEMS_tasks_Information.Objects,
the_packet->Prefix.id
);
_MPCI_Return_packet( the_packet_prefix );
break;
case RTEMS_TASKS_MP_SUSPEND_REQUEST:
the_packet->Prefix.return_code = rtems_task_suspend(
the_packet->Prefix.id
);
_RTEMS_tasks_MP_Send_response_packet(
RTEMS_TASKS_MP_SUSPEND_RESPONSE,
_Thread_Executing
);
break;
case RTEMS_TASKS_MP_SUSPEND_RESPONSE:
case RTEMS_TASKS_MP_RESUME_RESPONSE:
case RTEMS_TASKS_MP_SET_NOTE_RESPONSE:
the_thread = _MPCI_Process_response( the_packet_prefix );
_MPCI_Return_packet( the_packet_prefix );
break;
case RTEMS_TASKS_MP_RESUME_REQUEST:
the_packet->Prefix.return_code = rtems_task_resume(
the_packet->Prefix.id
);
_RTEMS_tasks_MP_Send_response_packet(
RTEMS_TASKS_MP_RESUME_RESPONSE,
_Thread_Executing
);
break;
case RTEMS_TASKS_MP_SET_PRIORITY_REQUEST:
the_packet->Prefix.return_code = rtems_task_set_priority(
the_packet->Prefix.id,
the_packet->the_priority,
&the_packet->the_priority
);
_RTEMS_tasks_MP_Send_response_packet(
RTEMS_TASKS_MP_SET_PRIORITY_RESPONSE,
_Thread_Executing
);
break;
case RTEMS_TASKS_MP_SET_PRIORITY_RESPONSE:
the_thread = _MPCI_Process_response( the_packet_prefix );
*(rtems_task_priority *)the_thread->Wait.return_argument =
the_packet->the_priority;
_MPCI_Return_packet( the_packet_prefix );
break;
case RTEMS_TASKS_MP_GET_NOTE_REQUEST:
the_packet->Prefix.return_code = rtems_task_get_note(
the_packet->Prefix.id,
the_packet->notepad,
&the_packet->note
);
_RTEMS_tasks_MP_Send_response_packet(
RTEMS_TASKS_MP_GET_NOTE_RESPONSE,
_Thread_Executing
);
break;
case RTEMS_TASKS_MP_GET_NOTE_RESPONSE:
the_thread = _MPCI_Process_response( the_packet_prefix );
*(uint32_t *)the_thread->Wait.return_argument = the_packet->note;
_MPCI_Return_packet( the_packet_prefix );
break;
case RTEMS_TASKS_MP_SET_NOTE_REQUEST:
the_packet->Prefix.return_code = rtems_task_set_note(
the_packet->Prefix.id,
the_packet->notepad,
the_packet->note
);
_RTEMS_tasks_MP_Send_response_packet(
RTEMS_TASKS_MP_SET_NOTE_RESPONSE,
_Thread_Executing
);
break;
}
}
rtems_task Task_1(
rtems_task_argument argument
)
{
rtems_id self_id;
rtems_task_priority previous_priority;
rtems_status_code status;
/* bad Id */
status = rtems_task_is_suspended( 100 );
fatal_directive_status(
status,
RTEMS_INVALID_ID,
"rtems_task_set_priority with illegal id"
);
puts( "TA1 - rtems_task_is_suspended - RTEMS_INVALID_ID" );
/* bad Id */
status = rtems_task_delete( 100 );
fatal_directive_status(
status,
RTEMS_INVALID_ID,
"rtems_task_delete with illegal id"
);
puts( "TA1 - rtems_task_delete - RTEMS_INVALID_ID" );
/* NULL param */
status = rtems_task_ident( RTEMS_SELF, RTEMS_SEARCH_ALL_NODES, NULL );
fatal_directive_status(
status,
RTEMS_INVALID_ADDRESS,
"rtems_task_ident NULL param"
);
puts( "TA1 - rtems_task_ident - RTEMS_INVALID_ADDRESS" );
/* OK */
status = rtems_task_ident( RTEMS_SELF, RTEMS_SEARCH_ALL_NODES, &self_id );
directive_failed( status, "rtems_task_ident of self" );
if ( self_id != Task_id[ 1 ] ) {
puts( "ERROR - rtems_task_ident - incorrect ID returned!" );
}
puts( "TA1 - rtems_task_ident - current task RTEMS_SUCCESSFUL" );
status = rtems_task_ident( 100, RTEMS_SEARCH_ALL_NODES, &Junk_id );
fatal_directive_status(
status,
RTEMS_INVALID_NAME,
"rtems_task_ident with illegal name (local)"
);
puts( "TA1 - rtems_task_ident - global RTEMS_INVALID_NAME" );
status = rtems_task_ident( 100, 1, &Junk_id );
fatal_directive_status(
status,
RTEMS_INVALID_NAME,
"rtems_task_ident with illegal name (global)"
);
puts( "TA1 - rtems_task_ident - local RTEMS_INVALID_NAME" );
/*
* This one case is different if MP is enabled/disabled.
*/
status = rtems_task_ident( 100, 2, &Junk_id );
#if defined(RTEMS_MULTIPROCESSING)
fatal_directive_status(
status,
RTEMS_INVALID_NODE,
"rtems_task_ident with illegal node"
);
#else
fatal_directive_status(
status,
RTEMS_INVALID_NAME,
"rtems_task_ident with illegal node"
);
#endif
puts( "TA1 - rtems_task_ident - RTEMS_INVALID_NODE" );
status = rtems_task_restart( 100, 0 );
fatal_directive_status(
status,
RTEMS_INVALID_ID,
"rtems_task_restart with illegal id"
);
puts( "TA1 - rtems_task_restart - RTEMS_INVALID_ID" );
status = rtems_task_resume( 100 );
fatal_directive_status(
status,
RTEMS_INVALID_ID,
"rtems_task_resume with illegal id"
);
puts( "TA1 - rtems_task_resume - RTEMS_INVALID_ID" );
status = rtems_task_resume( RTEMS_SELF );
fatal_directive_status(
status,
RTEMS_INCORRECT_STATE,
"rtems_task_resume of ready task"
);
puts( "TA1 - rtems_task_resume - RTEMS_INCORRECT_STATE" );
/* NULL param */
status = rtems_task_set_priority( RTEMS_SELF, RTEMS_CURRENT_PRIORITY, NULL );
fatal_directive_status(
status,
RTEMS_INVALID_ADDRESS,
"rtems_task_set_priority with NULL param"
);
puts( "TA1 - rtems_task_set_priority - RTEMS_INVALID_ADDRESS" );
/* bad priority */
status = rtems_task_set_priority(
RTEMS_SELF,
UINT32_C(0x80000000),
&previous_priority
);
fatal_directive_status(
status,
RTEMS_INVALID_PRIORITY,
"rtems_task_set_priority with illegal priority"
);
puts( "TA1 - rtems_task_set_priority - RTEMS_INVALID_PRIORITY" );
/* bad Id */
status = rtems_task_set_priority( 100, 8, &previous_priority );
fatal_directive_status(
status,
RTEMS_INVALID_ID,
"rtems_task_set_priority with illegal id"
);
puts( "TA1 - rtems_task_set_priority - RTEMS_INVALID_ID" );
status = rtems_task_start( 100, Task_1, 0 );
fatal_directive_status(
status,
RTEMS_INVALID_ID,
"rtems_task_start with illegal id"
);
puts( "TA1 - rtems_task_start - RTEMS_INVALID_ID" );
/* already started */
status = rtems_task_start( RTEMS_SELF, Task_1, 0 );
fatal_directive_status(
status,
RTEMS_INCORRECT_STATE,
"rtems_task_start of ready task"
);
puts( "TA1 - rtems_task_start - RTEMS_INCORRECT_STATE" );
/* bad Id */
status = rtems_task_suspend( 100 );
fatal_directive_status(
status,
RTEMS_INVALID_ID,
"rtems_task_suspend with illegal id"
);
puts( "TA1 - rtems_task_suspend - RTEMS_INVALID_ID" );
/* NULL param */
status = rtems_task_mode( RTEMS_SELF, 0, NULL );
fatal_directive_status(
status,
RTEMS_INVALID_ADDRESS,
"rtems_task_mode with NULL param"
);
puts( "TA1 - rtems_task_mode - RTEMS_INVALID_ADDRESS" );
TEST_END();
rtems_test_exit( 0 );
}
rtems_task Task_1(
rtems_task_argument argument
)
{
uint32_t seconds;
uint32_t old_seconds;
rtems_mode previous_mode;
rtems_time_of_day time;
rtems_status_code status;
uint32_t start_time;
uint32_t end_time;
puts( "TA1 - rtems_task_suspend - on Task 2" );
status = rtems_task_suspend( Task_id[ 2 ] );
directive_failed( status, "rtems_task_suspend of TA2" );
puts( "TA1 - rtems_task_suspend - on Task 3" );
status = rtems_task_suspend( Task_id[ 3 ] );
directive_failed( status, "rtems_task_suspend of TA3" );
status = rtems_clock_get_seconds_since_epoch( &start_time );
directive_failed( status, "rtems_clock_get_seconds_since_epoch" );
puts( "TA1 - killing time" );
for ( ; ; ) {
status = rtems_clock_get_seconds_since_epoch( &end_time );
directive_failed( status, "rtems_clock_get_seconds_since_epoch" );
if ( end_time > (start_time + 2) )
break;
}
puts( "TA1 - rtems_task_resume - on Task 2" );
status = rtems_task_resume( Task_id[ 2 ] );
directive_failed( status, "rtems_task_resume of TA2" );
puts( "TA1 - rtems_task_resume - on Task 3" );
status = rtems_task_resume( Task_id[ 3 ] );
directive_failed( status, "rtems_task_resume of TA3" );
while ( FOREVER ) {
if ( Run_count[ 1 ] >= 3 ) {
puts( "TA1 - rtems_task_mode - change mode to NO RTEMS_PREEMPT" );
status = rtems_task_mode(
RTEMS_NO_PREEMPT,
RTEMS_PREEMPT_MASK,
&previous_mode
);
directive_failed( status, "rtems_task_mode" );
status = rtems_clock_get_tod( &time );
directive_failed( status, "rtems_clock_get_tod" );
old_seconds = time.second;
for ( seconds = 0 ; seconds < 6 ; ) {
status = rtems_clock_get_tod( &time );
directive_failed( status, "rtems_clock_get_tod" );
if ( time.second != old_seconds ) {
old_seconds = time.second;
seconds++;
print_time( "TA1 - ", &time, "\n" );
}
}
puts( "TA1 - rtems_task_mode - change mode to RTEMS_PREEMPT" );
status = rtems_task_mode(
RTEMS_PREEMPT,
RTEMS_PREEMPT_MASK,
&previous_mode
);
directive_failed( status, "rtems_task_mode" );
while ( !testsFinished );
showTaskSwitches ();
puts( "TA1 - rtems_extension_delete - successful" );
status = rtems_extension_delete( Extension_id[1] );
directive_failed( status, "rtems_extension_delete" );
puts( "*** END OF TEST 4 ***" );
rtems_test_exit (0);
}
}
}
static void resume(size_t i)
{
rtems_status_code sc = rtems_task_resume(task_ids[i]);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
void Screen3()
{
rtems_name task_name;
rtems_status_code status;
bool skipUnsatisfied;
/* task create bad name */
task_name = 1;
status = rtems_task_create(
0,
1,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&Junk_id
);
fatal_directive_status(
status,
RTEMS_INVALID_NAME,
"rtems_task_create with illegal name"
);
puts( "TA1 - rtems_task_create - RTEMS_INVALID_NAME" );
/* null ID */
status = rtems_task_create(
Task_name[ 1 ],
4,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
NULL
);
fatal_directive_status(
status,
RTEMS_INVALID_ADDRESS,
"rtems_task_create with NULL ID param"
);
puts( "TA1 - rtems_task_create - RTEMS_INVALID_ADDRESS" );
/*
* If the bsp provides its own stack allocator, then
* skip the test that tries to allocate a stack that is too big.
*
* If on the m32c, we can't even ask for enough memory to trip this
* error.
*/
skipUnsatisfied = false;
if (rtems_configuration_get_stack_allocate_hook())
skipUnsatisfied = true;
#if defined(__m32c__)
skipUnsatisfied = true;
#endif
if ( skipUnsatisfied ) {
puts(
"TA1 - rtems_task_create - stack size - RTEMS_UNSATISFIED -- SKIPPED"
);
} else {
status = rtems_task_create(
task_name,
1,
rtems_configuration_get_work_space_size(),
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&Junk_id
);
fatal_directive_status(
status,
RTEMS_UNSATISFIED,
"rtems_task_create with a stack size larger than the workspace"
);
puts( "TA1 - rtems_task_create - stack size - RTEMS_UNSATISFIED" );
}
status = rtems_task_create(
Task_name[ 2 ],
4,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[ 2 ]
);
directive_failed( status, "rtems_task_create of TA2" );
puts( "TA1 - rtems_task_create - TA2 created - RTEMS_SUCCESSFUL" );
status = rtems_task_suspend( Task_id[ 2 ] );
directive_failed( status, "rtems_task_suspend of TA2" );
puts( "TA1 - rtems_task_suspend - suspend TA2 - RTEMS_SUCCESSFUL" );
status = rtems_task_suspend( Task_id[ 2 ] );
fatal_directive_status(
status,
RTEMS_ALREADY_SUSPENDED,
"rtems_task_suspend of suspended TA2"
);
puts( "TA1 - rtems_task_suspend - suspend TA2 - RTEMS_ALREADY_SUSPENDED" );
status = rtems_task_resume( Task_id[ 2 ] );
directive_failed( status, "rtems_task_resume of TA2" );
puts( "TA1 - rtems_task_resume - TA2 resumed - RTEMS_SUCCESSFUL" );
status = rtems_task_create(
Task_name[ 3 ],
4,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[ 3 ]
);
directive_failed( status, "rtems_task_create of TA3" );
puts( "TA1 - rtems_task_create - TA3 created - RTEMS_SUCCESSFUL" );
status = rtems_task_create(
Task_name[ 4 ],
4,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[ 4 ]
);
directive_failed( status, "rtems_task_create of TA4" );
puts( "TA1 - rtems_task_create - 4 created - RTEMS_SUCCESSFUL" );
status = rtems_task_create(
Task_name[ 5 ],
4,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[ 5 ]
);
directive_failed( status, "rtems_task_create of TA5" );
puts( "TA1 - rtems_task_create - 5 created - RTEMS_SUCCESSFUL" );
status = rtems_task_create(
Task_name[ 6 ],
4,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[ 6 ]
);
directive_failed( status, "rtems_task_create of TA6" );
puts( "TA1 - rtems_task_create - 6 created - RTEMS_SUCCESSFUL" );
status = rtems_task_create(
Task_name[ 7 ],
4,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[ 7 ]
);
directive_failed( status, "rtems_task_create of TA7" );
puts( "TA1 - rtems_task_create - 7 created - RTEMS_SUCCESSFUL" );
status = rtems_task_create(
Task_name[ 8 ],
4,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[ 8 ]
);
directive_failed( status, "rtems_task_create of TA8" );
puts( "TA1 - rtems_task_create - 8 created - RTEMS_SUCCESSFUL" );
status = rtems_task_create(
Task_name[ 9 ],
4,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[ 9 ]
);
directive_failed( status, "rtems_task_create of TA9" );
puts( "TA1 - rtems_task_create - 9 created - RTEMS_SUCCESSFUL" );
status = rtems_task_create(
Task_name[ 10 ],
4,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[ 10 ]
);
directive_failed( status, "rtems_task_create of TA10" );
puts( "TA1 - rtems_task_create - 10 created - RTEMS_SUCCESSFUL" );
status = rtems_task_create(
task_name,
4,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&Junk_id
);
fatal_directive_status(
status,
RTEMS_TOO_MANY,
"rtems_task_create for too many tasks"
);
puts( "TA1 - rtems_task_create - 11 - RTEMS_TOO_MANY" );
/*
* The check for an object being global is only made if
* multiprocessing is enabled.
*/
#if defined(RTEMS_MULTIPROCESSING)
status = rtems_task_create(
task_name,
4,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_GLOBAL,
&Junk_id
);
fatal_directive_status(
status,
RTEMS_MP_NOT_CONFIGURED,
"rtems_task_create of global task in a single cpu system"
);
#endif
puts( "TA1 - rtems_task_create - RTEMS_MP_NOT_CONFIGURED" );
}
void Test_Task_Support(
uint32_t node
)
{
rtems_event_set events;
rtems_status_code status;
if ( Multiprocessing_configuration.node == node ) {
for ( ; ; ) {
status = rtems_event_receive(
RTEMS_EVENT_16,
RTEMS_NO_WAIT,
RTEMS_NO_TIMEOUT,
&events
);
if ( status == RTEMS_SUCCESSFUL )
break;
fatal_directive_status(status, RTEMS_UNSATISFIED, "rtems_event_receive");
status = rtems_task_wake_after( 2 * rtems_clock_get_ticks_per_second() );
directive_failed( status, "rtems_task_wake_after" );
put_name( Task_name[ node ], FALSE );
puts( " - Suspending remote task" );
status = rtems_task_suspend( remote_tid );
directive_failed( status, "rtems_task_suspend" );
status = rtems_task_wake_after( 2 * rtems_clock_get_ticks_per_second() );
directive_failed( status, "rtems_task_wake_after" );
put_name( Task_name[ node ], FALSE );
puts( " - Resuming remote task" );
status = rtems_task_resume( remote_tid ) ;
directive_failed( status, "rtems_task_resume" );
}
} else {
for ( ; ; ) {
status = rtems_event_receive(
RTEMS_EVENT_16,
RTEMS_NO_WAIT,
RTEMS_NO_TIMEOUT,
&events
);
if ( status == RTEMS_SUCCESSFUL )
break;
fatal_directive_status(status, RTEMS_UNSATISFIED, "rtems_event_receive");
put_name( Task_name[ remote_node ], FALSE );
puts( " - have I been suspended???" );
status = rtems_task_wake_after( rtems_clock_get_ticks_per_second() / 2 );
directive_failed( status, "rtems_task_wake_after" );
}
}
}
void Priority_test_driver(
rtems_task_priority priority_base
)
{
rtems_task_priority previous_priority;
uint32_t index;
rtems_status_code status;
for ( index = 1 ; index <= 5 ; index++ ) {
switch ( index ) {
case 1:
case 2:
case 3:
Task_priority[ index ] = priority_base + index;
break;
default:
Task_priority[ index ] = priority_base + 3;
break;
}
status = rtems_task_create(
Priority_task_name[ index ],
Task_priority[ index ],
RTEMS_MINIMUM_STACK_SIZE * 2,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&Priority_task_id[ index ]
);
directive_failed( status, "rtems_task_create loop" );
}
if ( priority_base == 0 ) {
for ( index = 1 ; index <= 5 ; index++ ) {
status = rtems_task_start(
Priority_task_id[ index ],
Priority_task,
index
);
directive_failed( status, "rtems_task_start loop" );
}
} else {
for ( index = 5 ; index >= 1 ; index-- ) {
status = rtems_task_start(
Priority_task_id[ index ],
Priority_task,
index
);
directive_failed( status, "rtems_task_start loop" );
status = rtems_task_wake_after( rtems_clock_get_ticks_per_second() );
directive_failed( status, "rtems_task_wake_after loop" );
if ( priority_base == PRIORITY_INHERIT_BASE_PRIORITY ) {
if ( index == 4 ) {
status = rtems_task_set_priority(
Priority_task_id[ 5 ],
priority_base + 4,
&previous_priority
);
printf( "PDRV - change priority of PRI5 from %" PRIdrtems_task_priority " to %" PRIdrtems_task_priority "\n",
previous_priority,
priority_base + 4
);
directive_failed( status, "PDRV rtems_task_set_priority" );
}
status = rtems_task_set_priority(
Priority_task_id[ 5 ],
RTEMS_CURRENT_PRIORITY,
&previous_priority
);
directive_failed( status, "PDRV rtems_task_set_priority CURRENT" );
printf( "PDRV - priority of PRI5 is %" PRIdrtems_task_priority "\n", previous_priority );
}
}
}
status = rtems_task_wake_after( rtems_clock_get_ticks_per_second() );
directive_failed( status, "rtems_task_wake_after after loop" );
if ( priority_base == 0 ) {
for ( index = 1 ; index <= 5 ; index++ ) {
status = rtems_semaphore_release( Semaphore_id[ 2 ] );
directive_failed( status, "rtems_semaphore_release loop" );
}
}
if ( priority_base == PRIORITY_INHERIT_BASE_PRIORITY ) {
puts( "PDRV - rtems_task_resume - PRI5" );
status = rtems_task_resume( Priority_task_id[ 5 ] );
directive_failed( status, "rtems_task_resume" );
status = rtems_task_wake_after( rtems_clock_get_ticks_per_second() );
directive_failed( status, "rtems_task_wake_after so PRI5 can run" );
status = rtems_task_delete( Priority_task_id[ 5 ] );
directive_failed( status, "rtems_task_delete of PRI5" );
} else {
for ( index = 1 ; index <= 5 ; index++ ) {
status = rtems_task_delete( Priority_task_id[ index ] );
directive_failed( status, "rtems_task_delete loop" );
}
}
}
static rtems_task Init(rtems_task_argument argument)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_task_priority cur_prio = 0;
rtems_bdbuf_buffer *bd = NULL;
dev_t dev = 0;
rtems_test_begink();
sc = rtems_disk_io_initialize();
ASSERT_SC(sc);
sc = ramdisk_register(BLOCK_SIZE_A, BLOCK_COUNT, false, "/dev/rda", &dev);
ASSERT_SC(sc);
dd = rtems_disk_obtain(dev);
rtems_test_assert(dd != NULL);
sc = rtems_task_create(
rtems_build_name(' ', 'L', 'O', 'W'),
PRIORITY_LOW,
0,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task_id_low
);
ASSERT_SC(sc);
sc = rtems_task_start(task_id_low, task_low, 0);
ASSERT_SC(sc);
sc = rtems_task_create(
rtems_build_name(' ', 'M', 'I', 'D'),
PRIORITY_MID,
0,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task_id_mid
);
ASSERT_SC(sc);
sc = rtems_task_start(task_id_mid, task_mid, 0);
ASSERT_SC(sc);
sc = rtems_task_create(
rtems_build_name('H', 'I', 'G', 'H'),
PRIORITY_HIGH,
0,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task_id_high
);
ASSERT_SC(sc);
sc = rtems_task_start(task_id_high, task_high, 0);
ASSERT_SC(sc);
sc = rtems_task_suspend(task_id_mid);
ASSERT_SC(sc);
sc = rtems_task_suspend(task_id_high);
ASSERT_SC(sc);
sc = rtems_bdbuf_get(dd, 1, &bd);
ASSERT_SC(sc);
sc = rtems_bdbuf_release(bd);
ASSERT_SC(sc);
printk("I: try access: 0\n");
sc = rtems_bdbuf_get(dd, 0, &bd);
ASSERT_SC(sc);
printk("I: access: 0\n");
sc = rtems_task_set_priority(RTEMS_SELF, PRIORITY_IDLE, &cur_prio);
ASSERT_SC(sc);
sc = rtems_task_resume(task_id_high);
ASSERT_SC(sc);
sc = rtems_task_resume(task_id_mid);
ASSERT_SC(sc);
sc = rtems_task_set_priority(RTEMS_SELF, PRIORITY_INIT, &cur_prio);
ASSERT_SC(sc);
printk("I: release: 0\n");
sc = rtems_bdbuf_release(bd);
ASSERT_SC(sc);
printk("I: release done: 0\n");
rtems_task_delete(RTEMS_SELF);
}
