/*
* Spawn a task
*/
static void spawnTask(rtems_task_entry entryPoint, rtems_task_priority priority, rtems_task_argument arg)
{
rtems_status_code sc;
rtems_id tid;
sc = rtems_task_create(rtems_build_name('t','a','s','k'),
priority,
RTEMS_MINIMUM_STACK_SIZE+(8*1024),
RTEMS_PREEMPT|RTEMS_TIMESLICE|RTEMS_NO_ASR|RTEMS_INTERRUPT_LEVEL(0),
RTEMS_FLOATING_POINT|RTEMS_LOCAL,
&tid);
if (sc != RTEMS_SUCCESSFUL)
rtems_panic("Can't create task: %s", rtems_status_text(sc));
sc = rtems_task_start(tid, entryPoint, arg);
if (sc != RTEMS_SUCCESSFUL)
rtems_panic("Can't start task: %s", rtems_status_text(sc));
}
static rtems_status_code bsp_interrupt_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (_System_state_Is_up(_System_state_Get())) {
if (bsp_interrupt_mutex == RTEMS_ID_NONE) {
rtems_id mutex = RTEMS_ID_NONE;
rtems_interrupt_level level;
/* Create a mutex */
sc = rtems_semaphore_create (
rtems_build_name('I', 'N', 'T', 'R'),
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
0,
&mutex
);
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
/* Assign the mutex */
rtems_interrupt_disable(level);
if (bsp_interrupt_mutex == RTEMS_ID_NONE) {
/* Nobody else assigned the mutex in the meantime */
bsp_interrupt_mutex = mutex;
rtems_interrupt_enable(level);
} else {
/* Somebody else won */
rtems_interrupt_enable(level);
sc = rtems_semaphore_delete(mutex);
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
}
}
return rtems_semaphore_obtain(
bsp_interrupt_mutex,
RTEMS_WAIT,
RTEMS_NO_TIMEOUT
);
} else {
return RTEMS_SUCCESSFUL;
}
}
rtems_task Init(
rtems_task_argument argument
)
{
uint32_t i;
char ch;
uint32_t cpu_num;
rtems_id id;
rtems_status_code status;
TEST_BEGIN();
locked_print_initialize();
for ( killtime=0; killtime<1000000; killtime++ )
;
for ( i=0; i<rtems_get_processor_count() -1; i++ ) {
ch = '1' + i;
status = rtems_task_create(
rtems_build_name( 'T', 'A', ch, ' ' ),
1,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&id
);
directive_failed( status, "task create" );
cpu_num = rtems_get_current_processor();
locked_printf(" CPU %" PRIu32 " start task TA%c\n", cpu_num, ch);
status = rtems_task_start( id, Test_task, i+1 );
directive_failed( status, "task start" );
}
locked_printf(" kill 10 clock ticks\n" );
while ( rtems_clock_get_ticks_since_boot() < 10 )
;
rtems_cpu_usage_report();
TEST_END();
rtems_test_exit(0);
}
/*
* RTEMS Startup Task
*/
rtems_task
Init (rtems_task_argument ignored)
{
rtems_status_code sc;
rtems_print_printer_printf(&rtems_test_printer);
rtems_test_begin();
sc = rtems_semaphore_create(rtems_build_name('P','m','t','x'),
1,
RTEMS_PRIORITY|RTEMS_BINARY_SEMAPHORE|RTEMS_INHERIT_PRIORITY|
RTEMS_NO_PRIORITY_CEILING|RTEMS_LOCAL,
0,
&printMutex);
if (sc != RTEMS_SUCCESSFUL)
rtems_panic("Can't create printf mutex:", rtems_status_text(sc));
printf("\"Network\" initializing!\n");
rtems_bsdnet_initialize_network();
printf("\"Network\" initialized!\n");
printf("Try running client with no server present.\n");
printf("Should fail with `connection refused'.\n");
clientWorker(0);
printf("\nStart server.\n");
spawnTask(serverTask, 150, 0);
printf("\nTry running client with server present.\n");
spawnTask(clientTask, 120, 1);
rtems_task_wake_after(500);
printf("\nTry running two clients.\n");
spawnTask(clientTask, 120, 2);
spawnTask(clientTask, 120, 3);
rtems_task_wake_after(500);
printf("\nTry running three clients.\n");
spawnTask(clientTask, 120, 4);
spawnTask(clientTask, 120, 5);
spawnTask(clientTask, 120, 6);
rtems_task_wake_after(500);
rtems_test_end();
exit( 0 );
}
static rtems_device_driver graes_initialize(
rtems_device_major_number major,
rtems_device_minor_number unused,
void *arg
)
{
/* Device Semaphore created with count = 1 */
if ( rtems_semaphore_create(rtems_build_name('G', 'R', 'P', 'R'),
1,
RTEMS_FIFO|RTEMS_NO_INHERIT_PRIORITY|RTEMS_LOCAL|RTEMS_NO_PRIORITY_CEILING,
0,
&graes_dev_sem) != RTEMS_SUCCESSFUL ) {
return RTEMS_INTERNAL_ERROR;
}
return RTEMS_SUCCESSFUL;
}
rtems_task Init(
rtems_task_argument argument
)
{
int i;
char ch;
int cpu_num;
rtems_id id;
rtems_status_code status;
locked_print_initialize();
locked_printf( "\n\n*** TEST SMP09 ***\n" );
for ( killtime=0; killtime<1000000; killtime++ )
;
for ( i=0; i<rtems_smp_get_number_of_processors() -1; i++ ) {
ch = '1' + i;
status = rtems_task_create(
rtems_build_name( 'T', 'A', ch, ' ' ),
1,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&id
);
directive_failed( status, "task create" );
cpu_num = bsp_smp_processor_id();
locked_printf(" CPU %d start task TA%c\n", cpu_num, ch);
status = rtems_task_start( id, Test_task, i+1 );
directive_failed( status, "task start" );
}
locked_printf(" kill 10 clock ticks\n" );
while ( rtems_clock_get_ticks_since_boot() < 10 )
;
rtems_cpu_usage_report();
locked_printf( "*** END OF TEST SMP09 ***" );
rtems_test_exit(0);
}
static void test_mrsp_set_priority(void)
{
rtems_status_code sc;
rtems_id id;
rtems_id scheduler_id;
rtems_task_priority prio;
puts("test MrsP set priority");
sc = rtems_task_get_scheduler(RTEMS_SELF, &scheduler_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_semaphore_create(
rtems_build_name('M', 'R', 'S', 'P'),
1,
RTEMS_MULTIPROCESSOR_RESOURCE_SHARING
| RTEMS_BINARY_SEMAPHORE,
1,
&id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
prio = RTEMS_CURRENT_PRIORITY;
sc = rtems_semaphore_set_priority(id, scheduler_id, prio, &prio);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(prio == 1);
prio = 1;
sc = rtems_semaphore_set_priority(id, scheduler_id, prio, &prio);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(prio == 1);
prio = 2;
sc = rtems_semaphore_set_priority(id, scheduler_id, prio, &prio);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(prio == 1);
prio = RTEMS_CURRENT_PRIORITY;
sc = rtems_semaphore_set_priority(id, scheduler_id, prio, &prio);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(prio == 2);
sc = rtems_semaphore_delete(id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
rtems_task Init(
rtems_task_argument argument
)
{
rtems_status_code sc;
rtems_id timer1;
struct timespec uptime;
TEST_BEGIN();
sc = rtems_timer_initiate_server(
1,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_ATTRIBUTES
);
directive_failed( sc, "rtems_timer_initiate_server" );
sc = rtems_timer_create(rtems_build_name( 'T', 'M', 'R', '1' ), &timer1);
directive_failed( sc, "rtems_timer_create" );
Fired = 0;
timerRan = false;
Timer_Routine(timer1, NULL);
while (1) {
sc = rtems_task_wake_after( 10 );
directive_failed( sc, "rtems_task_wake_after" );
if ( timerRan == true ) {
timerRan = false;
sc = rtems_clock_get_uptime( &uptime );
directive_failed( sc, "rtems_clock_get_uptime" );
printf( "Timer fired at %" PRIdtime_t "\n", uptime.tv_sec );
}
if ( Fired >= 10 ) {
TEST_END();
rtems_test_exit( 0 );
}
/* technically the following is a critical section */
}
}
rtems_task Init(
rtems_task_argument argument
)
{
rtems_status_code status;
rtems_id task_id;
puts( "\n\n*** TEST 46 ***" );
/*
* Initialize Tasks
*/
puts( "INIT - rtems_task_create - creating task 1" );
status = rtems_task_create(
rtems_build_name( 'T', 'A', '1', ' ' ),
1,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task_id
);
directive_failed( status, "rtems_task_create of TA1" );
puts( "INIT - rtems_task_start - TA1 " );
status = rtems_task_start( task_id, Periodic_Task, 0 );
directive_failed( status, "rtems_task_start of TA1" );
while ( !partial_loop ) {
status = rtems_task_wake_after( 2 );
directive_failed( status, "rtems_task_wake_after" );
}
rtems_cpu_usage_reset();
status = rtems_task_wake_after( rtems_clock_get_ticks_per_second() );
directive_failed( status, "rtems_task_wake_after" );
/*
* Exit test
*/
puts( "*** END OF TEST 46 *** " );
rtems_test_exit( 0 );
}
rtems_task Init(
rtems_task_argument argument
)
{
int error;
uint32_t index;
rtems_status_code status;
rtems_printer_task_set_priority( &printer_task, 254 );
rtems_printer_task_set_file_descriptor( &printer_task, 1 );
rtems_printer_task_set_buffer_table( &printer_task, &buffers[ 0 ][ 0 ] );
rtems_printer_task_set_buffer_count( &printer_task, BUFFER_COUNT );
rtems_printer_task_set_buffer_size( &printer_task, BUFFER_SIZE );
error = rtems_print_printer_task( &rtems_test_printer, &printer_task );
rtems_test_assert( error == 0 );
TEST_BEGIN();
Task_name[ 1 ] = rtems_build_name( 'T', 'A', '1', ' ' );
Task_name[ 2 ] = rtems_build_name( 'T', 'A', '2', ' ' );
Task_name[ 3 ] = rtems_build_name( 'T', 'A', '3', ' ' );
Task_name[ 4 ] = rtems_build_name( 'T', 'A', '4', ' ' );
Task_name[ 5 ] = rtems_build_name( 'T', 'A', '5', ' ' );
Task_name[ 6 ] = rtems_build_name( 'T', 'A', '6', ' ' );
for ( index = 1 ; index <= 6 ; index++ ) {
status = rtems_task_create(
Task_name[ index ],
Priorities[ index ],
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_FLOATING_POINT,
&Task_id[ index ]
);
directive_failed( status, "rtems_task_create loop" );
}
for ( index = 1 ; index <= 6 ; index++ ) {
status = rtems_task_start( Task_id[ index ], Task_1_through_6, index );
directive_failed( status, "rtems_task_start loop" );
}
Count.count[ 1 ] = 0;
Count.count[ 2 ] = 0;
Count.count[ 3 ] = 0;
Count.count[ 4 ] = 0;
Count.count[ 5 ] = 0;
Count.count[ 6 ] = 0;
status = rtems_task_delete( RTEMS_SELF );
directive_failed( status, "rtems_task_delete of RTEMS_SELF" );
}
int vt100_init(FILE *out_stream){
if ( !out_stream ){
stream = stdout;
}else{
stream = out_stream;
}
rtems_semaphore_create(
rtems_build_name('V', 'T', 'L', 'K'),
1,
RTEMS_FIFO | RTEMS_COUNTING_SEMAPHORE | RTEMS_NO_INHERIT_PRIORITY | \
RTEMS_NO_PRIORITY_CEILING,
0,
&(vt100_lock));
vt100_reset();
return 0;
}
void
starttask (int arg)
{
rtems_id tid;
rtems_status_code sc;
sc = rtems_task_create(rtems_build_name ('S', 'R', 'V', arg + 'A'),
RTEMS_MAXIMUM_PRIORITY - 1u,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_PREEMPT|RTEMS_NO_TIMESLICE|RTEMS_NO_ASR|RTEMS_INTERRUPT_LEVEL(0),
RTEMS_NO_FLOATING_POINT|RTEMS_LOCAL,
&tid
);
directive_failed( sc, "task create" );
sc = rtems_task_start(tid, subtask, arg);
directive_failed( sc, "task start" );
}
int
rtems_rfs_mutex_create (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_create (rtems_build_name ('R', 'F', 'S', 'm'),
1, RTEMS_RFS_MUTEX_ATTRIBS, 0,
mutex);
if (sc != RTEMS_SUCCESSFUL)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
printf ("rtems-rfs: mutex: open failed: %s\n",
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
}
rtems_task Init(
rtems_task_argument argument
)
{
uint32_t index;
rtems_status_code status;
rtems_id rmid;
rtems_name period;
TEST_BEGIN();
period = rtems_build_name( 'I', 'G', 'N', 'R' );
status = rtems_rate_monotonic_create( period, &rmid );
directive_failed( status, "rtems_rate_monotonic_create" );
printf(
"INIT - rtems_rate_monotonic_create id = 0x%08" PRIxrtems_id " (stays inactive)\n",
rmid
);
Task_name[ 1 ] = rtems_build_name( 'T', 'A', '1', ' ' );
Task_name[ 2 ] = rtems_build_name( 'T', 'A', '2', ' ' );
Task_name[ 3 ] = rtems_build_name( 'T', 'A', '3', ' ' );
Task_name[ 4 ] = rtems_build_name( 'T', 'A', '4', ' ' );
Task_name[ 5 ] = rtems_build_name( 'T', 'A', '5', ' ' );
for ( index = 1 ; index <= 5 ; index++ ) {
status = rtems_task_create(
Task_name[ index ],
Priorities[ index ],
RTEMS_MINIMUM_STACK_SIZE * 4,
RTEMS_DEFAULT_MODES,
(index == 5) ? RTEMS_FLOATING_POINT : RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[ index ]
);
directive_failed( status, "rtems_task_create loop" );
}
for ( index = 1 ; index <= 5 ; index++ ) {
status = rtems_task_start( Task_id[ index ], Task_1_through_5, index );
directive_failed( status, "rtems_task_start loop" );
}
Count.count[ 1 ] = 0;
Count.count[ 2 ] = 0;
Count.count[ 3 ] = 0;
Count.count[ 4 ] = 0;
Count.count[ 5 ] = 0;
status = rtems_task_suspend( RTEMS_SELF );
directive_failed( status, "rtems_task_suspend of RTEMS_SELF" );
}
static int
lock_create(rtems_bsd_rc_conf* rc_conf)
{
rtems_status_code sc;
sc = rtems_semaphore_create(rtems_build_name('B', 'S', 'D', 'r'),
1,
RTEMS_FIFO | RTEMS_BINARY_SEMAPHORE |
RTEMS_NO_INHERIT_PRIORITY | RTEMS_NO_PRIORITY_CEILING |
RTEMS_LOCAL,
0,
&rc_conf->lock);
if (sc != RTEMS_SUCCESSFUL) {
fprintf(stderr, "error: rc_conf: cannot create lock: %s", rtems_status_text(sc));
errno = EIO;
return -1;
}
return 0;
}
rtems_task Init(rtems_task_argument arg)
{
rtems_status_code sc;
rtems_id task_id;
int status;
void *retval;
puts( "*** START OF CLASSIC API TEST OF POSIX 01 ***" );
sc = rtems_task_create(
rtems_build_name('T','E','S','T'),
1,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task_id
);
rtems_test_assert( sc == RTEMS_SUCCESSFUL );
sc = rtems_task_start( task_id, test_task, 0 );
rtems_test_assert( sc == RTEMS_SUCCESSFUL );
puts( "Init - pthread_equal on Classic Ids" );
status = pthread_equal( task_id, task_id );
rtems_test_assert( status != 0 );
puts( "Init - pthread_cancel on Classic Task" );
status = pthread_cancel( task_id );
rtems_test_assert( status == 0 );
status = pthread_detach( task_id );
rtems_test_assert( status == 0 );
status = pthread_join( task_id, &retval );
if ( status != EINVAL ) printf( "JOIN %s\n", strerror( status ) );
rtems_test_assert( status == EINVAL );
status = pthread_kill( task_id, SIGUSR1 );
rtems_test_assert( status == 0 );
puts( "*** END OF CLASSIC API TEST OF POSIX 01 ***" );
exit(0);
}
static void test_mrsp_set_priority_errors(void)
{
rtems_status_code sc;
rtems_id id;
rtems_id scheduler_id;
rtems_task_priority prio;
puts("test MrsP set priority errors");
sc = rtems_task_get_scheduler(RTEMS_SELF, &scheduler_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_semaphore_create(
rtems_build_name('C', 'O', 'N', 'T'),
0,
RTEMS_COUNTING_SEMAPHORE,
0,
&id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
prio = 1;
sc = rtems_semaphore_set_priority(RTEMS_ID_NONE, scheduler_id, prio, &prio);
rtems_test_assert(sc == RTEMS_INVALID_ID);
prio = 1;
sc = rtems_semaphore_set_priority(id, RTEMS_ID_NONE, prio, &prio);
rtems_test_assert(sc == RTEMS_INVALID_ID);
prio = 0xffffffff;
sc = rtems_semaphore_set_priority(id, scheduler_id, prio, &prio);
rtems_test_assert(sc == RTEMS_INVALID_PRIORITY);
prio = 1;
sc = rtems_semaphore_set_priority(id, scheduler_id, prio, NULL);
rtems_test_assert(sc == RTEMS_INVALID_ADDRESS);
prio = 1;
sc = rtems_semaphore_set_priority(id, scheduler_id, prio, &prio);
rtems_test_assert(sc == RTEMS_NOT_DEFINED);
sc = rtems_semaphore_delete(id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
rtems_task Init(
rtems_task_argument ignored
)
{
rtems_status_code sc;
int resets;
puts( "\n\n*** TEST INTERRUPT CRITICAL SECTION " TEST_NAME " ***" );
puts( "Init - Trying to generate timer fire from ISR while firing" );
puts( "Init - Variation is: " TEST_STRING );
puts( "Init - There is no way for the test to know if it hits the case" );
#if defined(SERVER_FIRE_AFTER)
/* initiate timer server */
sc = rtems_timer_initiate_server(
RTEMS_MINIMUM_PRIORITY,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_ATTRIBUTES
);
directive_failed( sc, "rtems_timer_initiate_server" );
#endif
puts( "Init - rtems_timer_create - OK" );
sc = rtems_timer_create( rtems_build_name( 'P', 'E', 'R', '1' ), &Timer);
directive_failed( sc, "rtems_timer_create" );
Main_task = rtems_task_self();
interrupt_critical_section_test_support_initialize( test_release_from_isr );
for (resets=0 ; resets<10 ;) {
if ( interrupt_critical_section_test_support_delay() )
resets++;
sc = TEST_DIRECTIVE( Timer, 10, TimerMethod, NULL );
directive_failed( sc, "rtems_timer_fire_after");
}
puts( "*** END OF TEST INTERRUPT CRITICAL SECTION " TEST_NAME " ***" );
rtems_test_exit(0);
}
rtems_status_code rtems_media_server_initialize(
rtems_task_priority priority,
size_t stack_size,
rtems_mode modes,
rtems_attribute attributes
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (server_id == RTEMS_ID_NONE) {
sc = rtems_media_initialize();
if (sc != RTEMS_SUCCESSFUL) {
goto error;
}
sc = rtems_task_create(
rtems_build_name('M', 'D', 'I', 'A'),
priority,
stack_size,
modes,
attributes,
&server_id
);
if (sc != RTEMS_SUCCESSFUL) {
goto error;
}
sc = rtems_task_start(server_id, media_server, 0);
if (sc != RTEMS_SUCCESSFUL) {
goto error;
}
}
return RTEMS_SUCCESSFUL;
error:
if (server_id != RTEMS_ID_NONE) {
rtems_task_delete(server_id);
}
return RTEMS_NO_MEMORY;
}
rtems_task Init( rtems_task_argument ignored )
{
rtems_id thread;
rtems_status_code rc;
int sc;
struct timespec delay_request;
TEST_BEGIN();
puts( "Init - pthread key create with destructor - OK" );
sc = pthread_key_create( &key, destructor );
rtems_test_assert( !sc );
puts( "Init - thread create - OK" );
rc = rtems_task_create(
rtems_build_name( 'T', 'E', 'S', 'T' ),
1,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&thread
);
rtems_test_assert( rc == RTEMS_SUCCESSFUL );
rc = rtems_task_start( thread, Test_Thread, (rtems_task_argument)Data_array );
rtems_test_assert( rc == RTEMS_SUCCESSFUL );
puts( "Init - sleep - let thread run - OK" );
delay_request.tv_sec = 0;
delay_request.tv_nsec = 8 * 100000000;
sc = nanosleep( &delay_request, NULL );
rtems_test_assert( !sc );
puts( "Init - verify destructor run - OK" );
rtems_test_assert( destructor_ran == true );
puts( "Init - pthread key delete - OK" );
sc = pthread_key_delete( key );
rtems_test_assert( sc == 0 );
TEST_END();
rtems_test_exit(0);
}
static void Init(rtems_task_argument arg)
{
test_context *ctx = &test_instance;
rtems_status_code sc;
int rv;
TEST_BEGIN();
ctx->main_task = rtems_task_self();
sc = rtems_task_create(
rtems_build_name('C', 'L', 'O', 'S'),
2,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&ctx->close_task
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_start(
ctx->close_task,
close_task,
(rtems_task_argument) ctx
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rv = rtems_bsdnet_initialize_network();
rtems_test_assert(rv == 0);
test_sync();
test_accept_and_close(ctx);
test_connect_and_close(ctx);
test_recv_and_close(ctx);
test_select_and_close(ctx);
sc = rtems_task_delete(ctx->close_task);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
TEST_END();
rtems_test_exit(0);
}
epicsShareFunc epicsMessageQueueId epicsShareAPI
epicsMessageQueueCreate(unsigned int capacity, unsigned int maximumMessageSize)
{
rtems_status_code sc;
epicsMessageQueueId id = (epicsMessageQueueId)callocMustSucceed(1, sizeof(*id), "epicsMessageQueueCreate");
rtems_interrupt_level level;
static char c1 = 'a';
static char c2 = 'a';
static char c3 = 'a';
sc = rtems_message_queue_create (rtems_build_name ('Q', c3, c2, c1),
capacity,
maximumMessageSize,
RTEMS_FIFO|RTEMS_LOCAL,
&id->id);
if (sc != RTEMS_SUCCESSFUL) {
errlogPrintf ("Can't create message queue: %s\n", rtems_status_text (sc));
return NULL;
}
id->maxSize = maximumMessageSize;
id->localBuf = NULL;
rtems_interrupt_disable (level);
if (c1 == 'z') {
if (c2 == 'z') {
if (c3 == 'z') {
c3 = 'a';
}
else {
c3++;
}
c2 = 'a';
}
else {
c2++;
}
c1 = 'a';
}
else {
c1++;
}
rtems_interrupt_enable (level);
return id;
}
/*
* Create a simple binary semaphore
*/
epicsEventId
epicsEventCreate(epicsEventInitialState initialState)
{
rtems_status_code sc;
rtems_id sid;
rtems_interrupt_level level;
static char c1 = 'a';
static char c2 = 'a';
static char c3 = 'a';
sc = rtems_semaphore_create (rtems_build_name ('B', c3, c2, c1),
initialState,
RTEMS_FIFO | RTEMS_SIMPLE_BINARY_SEMAPHORE |
RTEMS_NO_INHERIT_PRIORITY | RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL,
0,
&sid);
if (sc != RTEMS_SUCCESSFUL) {
errlogPrintf ("Can't create binary semaphore: %s\n", rtems_status_text (sc));
return NULL;
}
rtems_interrupt_disable (level);
if (c1 == 'z') {
if (c2 == 'z') {
if (c3 == 'z') {
c3 = 'a';
}
else {
c3++;
}
c2 = 'a';
}
else {
c2++;
}
c1 = 'a';
}
else {
c1++;
}
rtems_interrupt_enable (level);
return (epicsEventId)sid;
}
static void test(void)
{
test_context *ctx = &ctx_instance;
rtems_status_code sc;
rtems_mode mode;
ctx->consumer = rtems_task_self();
ctx->consumer_processor = rtems_get_current_processor();
sc = rtems_signal_catch(signal_handler, RTEMS_DEFAULT_MODES);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_create(
rtems_build_name('P', 'R', 'O', 'D'),
RTEMS_MINIMUM_PRIORITY,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&ctx->producer
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_start(ctx->producer, producer, (rtems_task_argument) ctx);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
check_consumer_processor(ctx);
wait_for_state(ctx, SIG_0_SENT);
change_state(ctx, SIG_0_ENABLE);
sc = rtems_task_mode(RTEMS_ASR, RTEMS_ASR_MASK, &mode);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
wait_for_state(ctx, SIG_0_PROCESSED);
check_consumer_processor(ctx);
change_state(ctx, SIG_1_READY);
wait_for_state(ctx, SIG_1_PROCESSED);
check_consumer_processor(ctx);
}
rtems_status_code
rtems_disk_io_initialize(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number size = DISKTAB_INITIAL_SIZE;
if (disktab_size > 0) {
return RTEMS_SUCCESSFUL;
}
disktab = calloc(size, sizeof(rtems_disk_device_table));
if (disktab == NULL) {
return RTEMS_NO_MEMORY;
}
diskdevs_protected = false;
sc = rtems_semaphore_create(
rtems_build_name('D', 'D', 'E', 'V'),
1,
RTEMS_FIFO | RTEMS_BINARY_SEMAPHORE | RTEMS_NO_INHERIT_PRIORITY
| RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL,
0,
&diskdevs_mutex
);
if (sc != RTEMS_SUCCESSFUL) {
free(disktab);
return RTEMS_NO_MEMORY;
}
sc = rtems_bdbuf_init();
if (sc != RTEMS_SUCCESSFUL) {
rtems_semaphore_delete(diskdevs_mutex);
free(disktab);
return RTEMS_UNSATISFIED;
}
disktab_size = size;
return RTEMS_SUCCESSFUL;
}
rtems_task Init(
rtems_task_argument argument
)
{
rtems_status_code status;
rtems_id Task_id;
Print_Warning();
TEST_BEGIN();
if (
_Scheduler_Table[ 0 ].Operations.initialize
!= _Scheduler_priority_Initialize
) {
puts( " Error ==> " );
puts( "Test only supported for deterministic priority scheduler\n" );
rtems_test_exit( 0 );
}
#define LOW_PRIORITY (RTEMS_MAXIMUM_PRIORITY - 1u)
status = rtems_task_create(
rtems_build_name( 'T', 'A', '1', ' ' ),
LOW_PRIORITY,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id
);
directive_failed( status, "rtems_task_create Task_1" );
status = rtems_task_start( Task_id, Task_1, 0 );
directive_failed( status, "rtems_task_start Task_1" );
benchmark_timer_initialize();
benchmark_timer_read();
benchmark_timer_initialize();
timer_overhead = benchmark_timer_read();
status = rtems_task_delete( RTEMS_SELF );
directive_failed( status, "rtems_task_delete of RTEMS_SELF" );
}
static void test(void)
{
test_context *ctx = &test_instance;
rtems_status_code sc;
int rv;
rtems_resource_snapshot snapshot;
ctx->main_task_id = rtems_task_self();
rtems_resource_snapshot_take(&snapshot);
rv = IMFS_make_generic_node(
&file_path[0],
S_IFCHR | S_IRWXU | S_IRWXG | S_IRWXO,
&node_control,
NULL
);
rtems_test_assert(rv == 0);
sc = rtems_task_create(
rtems_build_name('W', 'O', 'R', 'K'),
2,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&ctx->worker_task_id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_start(ctx->worker_task_id, worker_task, 0);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
wait();
sc = rtems_task_delete(ctx->worker_task_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rv = unlink(&file_path[0]);
rtems_test_assert(rv == 0);
rtems_test_assert(rtems_resource_snapshot_check(&snapshot));
}
rtems_task
tone_task(rtems_task_argument ignored)
{
rtems_name period_name;
rtems_id period;
rtems_status_code status;
int last_good_cnt, last_bad_cnt;
period_name = rtems_build_name ('T', 'N', 'P', 'D');
status = rtems_rate_monotonic_create (period_name, &period);
if (status != RTEMS_SUCCESSFUL)
{
printf ("tone_task: rate_monotonic_create failed with status %d\n",
status);
return;
}
last_good_cnt = tone_good_cnt;
last_bad_cnt = tone_bad_cnt;
while (1)
{
if (rtems_rate_monotonic_period (period, ticks_per_sec/50) ==
RTEMS_TIMEOUT)
{
/* I'd like to do a printf here, but that would make us miss
our next timeout, until the end of time... */
tone_task_timeouts++;
}
if ((last_good_cnt == tone_good_cnt) &&
(last_bad_cnt == tone_bad_cnt)) {
/* Haven't heard anything for 20ms - no tone. */
tone_good = 0;
tone_good_cnt = 0;
tone_bad_cnt = 0;
}
last_good_cnt = tone_good_cnt;
last_bad_cnt = tone_bad_cnt;
}
}
/*
* Initialization of FIFO/pipe module.
*/
void rtems_pipe_initialize (void)
{
if (!rtems_pipe_configured)
return;
if (rtems_pipe_semaphore)
return;
rtems_status_code sc;
sc = rtems_semaphore_create(
rtems_build_name ('P', 'I', 'P', 'E'), 1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY, &rtems_pipe_semaphore);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interval now;
now = rtems_clock_get_ticks_since_boot();
rtems_pipe_no = now;
}
rtems_status_code
bspExtInit(void)
{
rtems_status_code rval=RTEMS_SUCCESSFUL;
rtems_name n=rtems_build_name('B','E','L','K');
if (__bspExtLock) return rval; /* already initialized */
if (RTEMS_SUCCESSFUL!=(rval = rtems_semaphore_create(n,1,
RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY,
0,
&__bspExtLock)))
return rval;
#ifdef __PPC__
_bspExtMemProbeInit();
#endif
return rval;
}
