static void test(void)
{
rtems_status_code sc;
rtems_task_argument i;
size_t size;
uint32_t cpu_count;
rtems_task_priority priority;
/* Get the number of processors that we are using. */
cpu_count = rtems_get_processor_count();
if (cpu_count != 4) {
printf("Test requires a minimum of 4 cores\n");
return;
}
size = sizeof(cpu_set_t);
task_data[0].id = rtems_task_self();
sc = rtems_semaphore_create(
rtems_build_name('S', 'E', 'M', '0'),
1, /* initial count = 1 */
RTEMS_LOCAL |
RTEMS_SIMPLE_BINARY_SEMAPHORE |
RTEMS_NO_INHERIT_PRIORITY |
RTEMS_NO_PRIORITY_CEILING |
RTEMS_FIFO,
0,
&task_sem
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_set_affinity(
task_data[ 0 ].id,
size,
&task_data[0].cpuset
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
/* Create and start tasks on each cpu with the appropriate affinity. */
for (i = 1; i < TASK_COUNT; i++) {
sc = rtems_task_create(
rtems_build_name('T', 'A', '0', '0'+i),
task_data[ i ].priority,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task_data[ i ].id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_set_affinity(
task_data[ i ].id,
size,
&task_data[i].cpuset
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_start( task_data[ i ].id, task, i );
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
/* spin for 10 ticks */
test_delay(10);
set_init_task();
i = TASK_COUNT - 1;
task_data[ i ].priority = 4;
sc = rtems_task_set_priority(
task_data[ i ].id,
task_data[ i ].priority,
&priority
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
test_delay(10);
while( rtems_semaphore_obtain (task_sem, RTEMS_NO_WAIT, 0) != RTEMS_SUCCESSFUL );
for (i = 0; i < TASK_COUNT; i++) {
task_data[ i ].expected_cpu = task_data[ i ].migrate_cpu;
task_data[ i ].actual_cpu = -1;
task_data[ i ].ran = false;
}
rtems_semaphore_release(task_sem);
test_delay(10);
set_init_task();
for (i = 1; i < TASK_COUNT; i++) {
sc = rtems_task_delete( task_data[ i ].id );
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
test_delay(25);
}
/* The Init operation (the Init-task) */
rtems_task Init(rtems_task_argument ignored)
{
rtems_status_code status;
#if defined(TEST_USE_ISR)
rtems_isr_entry DummyIsr;
#endif
int i;
puts( "\n\n*** TEST 35 ***" );
/* Create synchronisation semaphore for LocalHwIsr -> Test Tasks */
status = rtems_semaphore_create(
rtems_build_name ('S', 'Y', 'N', 'C'), /* name */
0, /* initial count = 0 */
RTEMS_LOCAL |
RTEMS_SIMPLE_BINARY_SEMAPHORE |
RTEMS_NO_INHERIT_PRIORITY |
RTEMS_NO_PRIORITY_CEILING |
RTEMS_FIFO,
0,
&LocalHwSync_S); /* *id */
directive_failed( status, "rtems_semaphore_create (SYNC)" );
printf( "Sync Mutex Id = 0x%08" PRIxrtems_id "\n", LocalHwSync_S );
/* Create resource semaphore for exclusive access to the local HW */
status = rtems_semaphore_create(
rtems_build_name ('R', 'E', 'S', '1'), /* name */
1, /* count */
RTEMS_PRIORITY |
RTEMS_BINARY_SEMAPHORE |
RTEMS_INHERIT_PRIORITY |
RTEMS_LOCAL, /* attribute_set */
1, /* insignificant */ /* priority_ceiling */
&LocalHwAccess_R); /* *id */
directive_failed( status, "rtems_semaphore_create (RES1)" );
printf( "Local Mutex Id = 0x%08" PRIxrtems_id "\n", LocalHwAccess_R );
/* Create resource semaphore for exclusive access to the remote HW */
status = rtems_semaphore_create(
rtems_build_name ('R', 'E', 'S', '2'), /* name */
1, /* count */
RTEMS_PRIORITY |
RTEMS_BINARY_SEMAPHORE |
RTEMS_INHERIT_PRIORITY |
RTEMS_LOCAL, /* attribute_set */
1, /* insignificant */ /* priority_ceiling */
&RemoteHwAccess_R); /* *id */
directive_failed( status, "rtems_semaphore_create (RES2)" );
printf( "Remote Mutex Id = 0x%08" PRIxrtems_id "\n", RemoteHwAccess_R );
#if defined(TEST_USE_ISR)
/* Install ISR for HW/SW synchronization, use ta 0x85 which is synchronous */
status = rtems_interrupt_catch(LocalHwIsr, 0x85 + 0x100, &DummyIsr);
directive_failed( status, "rtems_interrupt_catch" );
#endif
printf("Ending Init-task\n");
/* Create and start all tasks in the test */
/* -- Medium-prio Test Tasks --- */
for (i = 0; i < NofMediumTask_C; i++) {
#define MEDIUM_PRIORITY ((RTEMS_MAXIMUM_PRIORITY / 2u) + 1u)
status = rtems_task_create(
rtems_build_name('M','E','D','0'+i), /* Name */
MEDIUM_PRIORITY, /* Priority */
RTEMS_MINIMUM_STACK_SIZE*2, /* Stack size (8KB) */
RTEMS_DEFAULT_MODES | RTEMS_NO_ASR, /* Mode */
RTEMS_DEFAULT_ATTRIBUTES | RTEMS_FLOATING_POINT, /* Attributes */
&TaMedium[i]); /* Assigned ID */
directive_failed( status, "rtems_task_create (MEDn)" );
printf( "TaMedium[%d] Id = 0x%08" PRIxrtems_id "\n", i, TaMedium[i] );
status = rtems_task_start(
TaMedium[i],
Medium_Exec,
(rtems_task_argument) i
);
directive_failed( status, "rtems_task_start (MEDn)" );
}
/* -- High-prio Test Task --- */
#define HIGH_PRIORITY ((RTEMS_MAXIMUM_PRIORITY / 2u))
status = rtems_task_create(
rtems_build_name('H','I','G','H'), /* Name */
HIGH_PRIORITY, /* Priority */
RTEMS_MINIMUM_STACK_SIZE*2, /* Stack size (8KB) */
RTEMS_DEFAULT_MODES | RTEMS_NO_ASR, /* Mode */
RTEMS_DEFAULT_ATTRIBUTES | RTEMS_FLOATING_POINT, /* Attributes */
&TaHigh); /* Assigned ID */
directive_failed( status, "rtems_task_create (HIGH)" );
printf( "TaHigh Id = 0x%08" PRIxrtems_id "\n", TaHigh );
status = rtems_task_start(TaHigh, High_Exec, 0);
directive_failed( status, "rtems_task_start (HIGH)" );
/* -- Low-prio Test Task --- */
#define LOW_PRIORITY (RTEMS_MAXIMUM_PRIORITY - 1u)
status = rtems_task_create(
rtems_build_name('L','O','W',' '), /* Name */
LOW_PRIORITY, /* Priority */
RTEMS_MINIMUM_STACK_SIZE*2, /* Stack size (8KB) */
RTEMS_DEFAULT_MODES | RTEMS_NO_ASR, /* Mode */
RTEMS_DEFAULT_ATTRIBUTES | RTEMS_FLOATING_POINT, /* Attributes */
&TaLow); /* Assigned ID */
directive_failed( status, "rtems_task_create (LOW)" );
printf( "TaLow Id = 0x%08" PRIxrtems_id "\n", TaLow );
status = rtems_task_start(TaLow, Low_Exec, 0);
directive_failed( status, "rtems_task_start (LOW)" );
/* -- HW Simulator Task --- */
#define HWTASK_PRIORITY (RTEMS_MAXIMUM_PRIORITY - 2u)
status = rtems_task_create(
rtems_build_name('H','W','S','M'), /* Name */
HWTASK_PRIORITY, /* Priority */
RTEMS_MINIMUM_STACK_SIZE*2, /* Stack size (8KB) */
RTEMS_DEFAULT_MODES | RTEMS_NO_ASR, /* Mode */
RTEMS_DEFAULT_ATTRIBUTES | RTEMS_FLOATING_POINT, /* Attributes */
&TaHwSim); /* Assigned ID */
directive_failed( status, "rtems_task_create (HWSM)" );
printf( "TaHwSim Id = 0x%08" PRIxrtems_id "\n", TaHwSim );
status = rtems_task_start(TaHwSim, LocalHwSim_Exec, 0);
directive_failed( status, "rtems_task_start (HWSM)" );
/* Destroy the Init task (and let the ready tasks start running) */
rtems_task_delete(RTEMS_SELF);
}
rtems_task Task_1(
rtems_task_argument argument
)
{
rtems_id smid;
rtems_status_code status;
status = rtems_semaphore_ident(
Semaphore_name[ 1 ],
RTEMS_SEARCH_ALL_NODES,
&smid
);
printf( "TA1 - rtems_semaphore_ident - smid => %08" PRIxrtems_id "\n", smid );
directive_failed( status, "rtems_semaphore_ident of SM1" );
puts( "TA1 - rtems_semaphore_obtain - wait forever on SM2" );
status = rtems_semaphore_obtain(
Semaphore_id[ 2 ],
RTEMS_DEFAULT_OPTIONS,
RTEMS_NO_TIMEOUT
);
directive_failed( status, "rtems_semaphore_obtain of SM2" );
puts( "TA1 - got SM2" );
puts( "TA1 - rtems_semaphore_obtain - wait forever on SM3" );
status = rtems_semaphore_obtain(
Semaphore_id[ 3 ],
RTEMS_DEFAULT_OPTIONS,
RTEMS_NO_TIMEOUT
);
directive_failed( status, "rtems_semaphore_obtain of SM3" );
puts( "TA1 - got SM3" );
puts( "TA1 - rtems_semaphore_obtain - get SM1 - RTEMS_NO_WAIT" );
status = rtems_semaphore_obtain(
Semaphore_id[ 1 ],
RTEMS_NO_WAIT,
RTEMS_NO_TIMEOUT
);
directive_failed( status, "rtems_semaphore_obtain of SM1" );
puts( "TA1 - got SM1" );
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" );
rtems_test_pause();
puts( "TA1 - rtems_semaphore_release - release SM1" );
status = rtems_semaphore_release( Semaphore_id[ 1 ] );
directive_failed( status, "rtems_semaphore_release of SM1" );
puts(
"TA1 - rtems_semaphore_obtain - waiting for SM1 with 10 second timeout"
);
status = rtems_semaphore_obtain(
Semaphore_id[ 1 ],
RTEMS_DEFAULT_OPTIONS,
10 * rtems_clock_get_ticks_per_second()
);
directive_failed( status, "rtems_semaphore_obtain of SM1" );
puts( "TA1 - got SM1" );
puts( "TA1 - rtems_semaphore_release - release SM2" );
status = rtems_semaphore_release( Semaphore_id[ 2 ] );
directive_failed( status, "rtems_semaphore_release of SM2" );
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" );
rtems_test_pause();
puts( "TA1 - rtems_task_delete - delete TA3" );
status = rtems_task_delete( Task_id[ 3 ] );
directive_failed( status, "rtems_task_delete of TA3" );
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" );
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" );
status = rtems_task_start( Task_id[ 4 ], Task_4, 0 );
directive_failed( status, "rtems_task_start of TA4" );
status = rtems_task_start( Task_id[ 5 ], Task5, 0 );
directive_failed( status, "rtems_task_start of TA5" );
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_delete - delete TA4" );
status = rtems_task_delete( Task_id[ 4 ] );
directive_failed( status, "rtems_task_delete of TA4" );
puts( "TA1 - rtems_semaphore_release - release SM1" );
status = rtems_semaphore_release( Semaphore_id[ 1 ] );
directive_failed( status, "rtems_semaphore_release on SM1" );
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_semaphore_delete - delete SM1" );
status = rtems_semaphore_delete( Semaphore_id[ 1 ] );
directive_failed( status, "rtems_semaphore_delete of SM1" );
puts( "TA1 - rtems_semaphore_delete - delete SM3" );
status = rtems_semaphore_delete( Semaphore_id[ 3 ] );
directive_failed( status, "rtems_semaphore_delete of SM3" );
puts( "TA1 - rtems_task_delete - delete self" );
status = rtems_task_delete( RTEMS_SELF );
directive_failed( status, "rtems_task_delete of TA1" );
}
/*PAGE
*
* rtems_ftpd_start
*
* Here, we start the FTPD task which waits for FTP requests and services
* them. This procedure returns to its caller once the task is started.
*
*
* Input parameters:
*
* Output parameters:
* returns RTEMS_SUCCESSFUL on successful start of the daemon.
*/
int
rtems_initialize_ftpd(void)
{
rtems_status_code sc;
rtems_id tid;
rtems_task_priority priority;
int count;
if (rtems_ftpd_configuration.port == 0)
{
rtems_ftpd_configuration.port = FTPD_CONTROL_PORT;
}
if (rtems_ftpd_configuration.priority == 0)
{
rtems_ftpd_configuration.priority = 40;
}
priority = rtems_ftpd_configuration.priority;
ftpd_timeout = rtems_ftpd_configuration.idle;
if (ftpd_timeout < 0)
ftpd_timeout = 0;
rtems_ftpd_configuration.idle = ftpd_timeout;
ftpd_access = rtems_ftpd_configuration.access;
if (rtems_ftpd_configuration.tasks_count <= 0)
rtems_ftpd_configuration.tasks_count = 1;
count = rtems_ftpd_configuration.tasks_count;
if (!task_pool_init(count, priority))
{
syslog(LOG_ERR, "ftpd: Could not initialize task pool.");
return RTEMS_UNSATISFIED;
}
sc = rtems_task_create(rtems_build_name('F', 'T', 'P', 'D'),
priority, FTPD_STACKSIZE,
RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR |
RTEMS_INTERRUPT_LEVEL(0),
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tid);
if (sc == RTEMS_SUCCESSFUL)
{
sc = rtems_task_start(tid, daemon, 0);
if (sc != RTEMS_SUCCESSFUL)
rtems_task_delete(tid);
}
if (sc != RTEMS_SUCCESSFUL)
{
task_pool_done(count);
syslog(LOG_ERR, "ftpd: Could not create/start FTP daemon: %s",
rtems_status_text(sc));
return RTEMS_UNSATISFIED;
}
ftpd_root = "/";
if (
rtems_ftpd_configuration.root &&
rtems_ftpd_configuration.root[0] == '/'
)
ftpd_root = rtems_ftpd_configuration.root;
rtems_ftpd_configuration.root = ftpd_root;
syslog(LOG_INFO, "ftpd: FTP daemon started (%d session%s max)",
count, ((count > 1) ? "s" : ""));
return RTEMS_SUCCESSFUL;
}
static void
capture_test_1 (int argc,
char** argv,
const rtems_monitor_command_arg_t* command_arg,
bool verbose)
{
rtems_status_code sc;
rtems_name name;
rtems_id id[3];
rtems_id mutex;
int loops;
capture_CT1a_deleted = 0;
capture_CT1b_deleted = 0;
capture_CT1c_deleted = 0;
name = rtems_build_name('C', 'T', 'm', '1');
sc = rtems_semaphore_create (name, 1,
RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE |
RTEMS_INHERIT_PRIORITY,
0, &mutex);
if (sc != RTEMS_SUCCESSFUL)
{
fprintf (stdout, "error: Test 1: cannot mutex: %s\n",
rtems_status_text (sc));
return;
}
name = rtems_build_name('C', 'T', '1', 'a');
sc = rtems_task_create (name, 102, 2 * 1024,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
RTEMS_PREEMPT | RTEMS_TIMESLICE | RTEMS_NO_ASR,
&id[0]);
if (sc != RTEMS_SUCCESSFUL)
{
fprintf (stdout, "error: Test 1: cannot create CT1a: %s\n",
rtems_status_text (sc));
rtems_semaphore_delete (mutex);
return;
}
sc = rtems_task_start (id[0], capture_CT1a, (rtems_task_argument) mutex);
if (sc != RTEMS_SUCCESSFUL)
{
fprintf (stdout, "error: Test 1: cannot start CT1a: %s\n",
rtems_status_text (sc));
rtems_task_delete (id[0]);
rtems_semaphore_delete (mutex);
return;
}
capture_wait (1000);
name = rtems_build_name('C', 'T', '1', 'b');
sc = rtems_task_create (name, 101, 2 * 1024,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
RTEMS_PREEMPT | RTEMS_TIMESLICE | RTEMS_NO_ASR,
&id[1]);
if (sc != RTEMS_SUCCESSFUL)
{
fprintf (stdout, "error: Test 1: cannot create CT1b: %s\n",
rtems_status_text (sc));
rtems_task_delete (id[0]);
rtems_semaphore_delete (mutex);
return;
}
sc = rtems_task_start (id[1], capture_CT1b, 0);
if (sc != RTEMS_SUCCESSFUL)
{
fprintf (stdout, "error: Test 1: cannot start CT1b: %s\n",
rtems_status_text (sc));
rtems_task_delete (id[1]);
rtems_task_delete (id[0]);
rtems_semaphore_delete (mutex);
return;
}
capture_wait (1000);
name = rtems_build_name('C', 'T', '1', 'c');
sc = rtems_task_create (name, 100, 2 * 1024,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
RTEMS_PREEMPT | RTEMS_TIMESLICE | RTEMS_NO_ASR,
&id[2]);
if (sc != RTEMS_SUCCESSFUL)
{
fprintf (stdout, "error: Test 1: cannot create CT1c: %s\n",
rtems_status_text (sc));
rtems_task_delete (id[1]);
rtems_task_delete (id[0]);
rtems_semaphore_delete (mutex);
return;
}
sc = rtems_task_start (id[2], capture_CT1c, (rtems_task_argument) mutex);
if (sc != RTEMS_SUCCESSFUL)
{
fprintf (stdout, "error: Test 1: cannot start CT1c: %s\n",
rtems_status_text (sc));
rtems_task_delete (id[2]);
rtems_task_delete (id[1]);
rtems_task_delete (id[0]);
rtems_semaphore_delete (mutex);
return;
}
loops = 15;
while (!(capture_CT1a_deleted || capture_CT1b_deleted ||
capture_CT1c_deleted) && loops)
{
loops--;
capture_wait (1000);
}
if (!loops)
{
fprintf (stdout, "error: Test 1: test tasks did not delete\n");
rtems_task_delete (id[2]);
rtems_task_delete (id[1]);
rtems_task_delete (id[0]);
}
sc = rtems_semaphore_delete (mutex);
if (sc != RTEMS_SUCCESSFUL)
fprintf (stdout, "error: Test 1: deleting the mutex: %s\n",
rtems_status_text (sc));
}
static void
rtems_task_telnetd(void *task_argument)
{
int des_socket;
uni_sa srv;
char *devname;
char peername[16];
int i=1;
int size_adr;
struct shell_args *arg = NULL;
if ((des_socket=socket(PF_INET,SOCK_STREAM,0))<0) {
perror("telnetd:socket");
telnetd_task_id = RTEMS_ID_NONE;
rtems_task_delete(RTEMS_SELF);
};
setsockopt(des_socket,SOL_SOCKET,SO_KEEPALIVE,&i,sizeof(i));
memset(&srv,0,sizeof(srv));
srv.sin.sin_family=AF_INET;
srv.sin.sin_port=htons(23);
size_adr=sizeof(srv.sin);
if ((bind(des_socket,&srv.sa,size_adr))<0) {
perror("telnetd:bind");
close(des_socket);
telnetd_task_id = RTEMS_ID_NONE;
rtems_task_delete(RTEMS_SELF);
};
if ((listen(des_socket,5))<0) {
perror("telnetd:listen");
close(des_socket);
telnetd_task_id = RTEMS_ID_NONE;
rtems_task_delete(RTEMS_SELF);
};
/* we don't redirect stdio as this probably
* was started from the console anyways..
*/
do {
if (rtems_telnetd_config.keep_stdio) {
bool start = true;
char device_name [32];
ttyname_r( 1, device_name, sizeof( device_name));
if (rtems_telnetd_config.login_check != NULL) {
start = rtems_shell_login_prompt(
stdin,
stderr,
device_name,
rtems_telnetd_config.login_check
);
}
if (start) {
rtems_telnetd_config.command( device_name, arg->arg);
} else {
syslog(
LOG_AUTHPRIV | LOG_WARNING,
"telnetd: to many wrong passwords entered from %s",
device_name
);
}
} else {
devname = grab_a_Connection(des_socket, &srv, peername, sizeof(peername));
if ( !devname ) {
/* if something went wrong, sleep for some time */
sleep(10);
continue;
}
arg = malloc( sizeof(*arg) );
arg->devname = devname;
arg->arg = rtems_telnetd_config.arg;
strncpy(arg->peername, peername, sizeof(arg->peername));
telnetd_task_id = telnetd_spawn_task(
devname,
rtems_telnetd_config.priority,
rtems_telnetd_config.stack_size,
spawned_shell,
arg
);
if (telnetd_task_id == RTEMS_ID_NONE) {
FILE *dummy;
if ( telnetd_spawn_task != telnetd_dflt_spawn ) {
fprintf(stderr,"Telnetd: Unable to spawn child task\n");
}
/* hmm - the pty driver slot can only be
* released by opening and subsequently
* closing the PTY - this also closes
* the underlying socket. So we mock up
* a stream...
*/
if ( !(dummy=fopen(devname,"r+")) )
perror("Unable to dummy open the pty, losing a slot :-(");
release_a_Connection(devname, peername, &dummy, 1);
free(arg);
sleep(2); /* don't accept connections too fast */
}
}
} while(1);
/* TODO: how to free the connection semaphore? But then -
* stopping the daemon is probably only needed during
* development/debugging.
* Finalizer code should collect all the connection semaphore
* counts and eventually clean up...
*/
close(des_socket);
telnetd_task_id = RTEMS_ID_NONE;
}
rtems_task Init(
rtems_task_argument argument
)
{
rtems_status_code status;
puts( "\n\n*** TEST 9 ***" );
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', ' ' );
Task_name[ 7 ] = rtems_build_name( 'T', 'A', '7', ' ' );
Task_name[ 8 ] = rtems_build_name( 'T', 'A', '8', ' ' );
Task_name[ 9 ] = rtems_build_name( 'T', 'A', '9', ' ' );
Task_name[ 10 ] = rtems_build_name( 'T', 'A', 'A', ' ' );
Timer_name[ 1 ] = rtems_build_name( 'T', 'M', '1', ' ' );
Semaphore_name[ 1 ] = rtems_build_name( 'S', 'M', '1', ' ' );
Semaphore_name[ 2 ] = rtems_build_name( 'S', 'M', '2', ' ' );
Semaphore_name[ 3 ] = rtems_build_name( 'S', 'M', '3', ' ' );
Queue_name[ 1 ] = rtems_build_name( 'M', 'Q', '1', ' ' );
Queue_name[ 2 ] = rtems_build_name( 'M', 'Q', '2', ' ' );
Partition_name[ 1 ] = rtems_build_name( 'P', 'T', '1', ' ' );
Region_name[ 1 ] = rtems_build_name( 'R', 'N', '1', ' ' );
Port_name[ 1 ] = rtems_build_name( 'D', 'P', '1', ' ' );
Period_name[ 1 ] = rtems_build_name( 'T', 'M', '1', ' ' );
/* priority of 0 error */
status = rtems_task_create(
Task_name[1],
0,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[ 1 ]
);
fatal_directive_status(
status,
RTEMS_INVALID_PRIORITY,
"rtems_task_create with illegal priority"
);
puts( "INIT - rtems_task_create - priority of 0 - RTEMS_INVALID_PRIORITY" );
/* priority > 255 error */
status = rtems_task_create(
Task_name[1],
257,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[ 1 ]
);
fatal_directive_status(
status,
RTEMS_INVALID_PRIORITY,
"rtems_task_create with illegal priority"
);
puts(
"INIT - rtems_task_create - priority too high - RTEMS_INVALID_PRIORITY"
);
status = rtems_task_create(
Task_name[ 1 ],
4,
RTEMS_MINIMUM_STACK_SIZE * 3,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[ 1 ]
);
directive_failed( status, "rtems_task_create of TA1" );
status = rtems_task_restart( Task_id[ 1 ], 0 );
fatal_directive_status(
status,
RTEMS_INCORRECT_STATE,
"rtems_task_restart of DORMANT task"
);
puts( "INIT - rtems_task_restart - RTEMS_INCORRECT_STATE" );
status = rtems_task_start( Task_id[ 1 ], Task_1, 0 );
directive_failed( status, "rtems_task_start of TA1" );
status = rtems_task_delete( RTEMS_SELF );
directive_failed( status, "rtems_task_delete of RTEMS_SELF" );
}
rtems_task Init(
rtems_task_argument argument
)
{
uint32_t index;
rtems_id task_id;
rtems_status_code status;
Print_Warning();
puts( "\n\n*** TIME TEST 26 ***" );
#define FP1_PRIORITY (RTEMS_MAXIMUM_PRIORITY - 3u) /* 201, */
status = rtems_task_create(
rtems_build_name( 'F', 'P', '1', ' ' ),
FP1_PRIORITY,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_FLOATING_POINT,
&task_id
);
directive_failed( status, "rtems_task_create of FP1" );
status = rtems_task_start( task_id, Floating_point_task_1, 0 );
directive_failed( status, "rtems_task_start of FP1" );
#define FP2_PRIORITY (RTEMS_MAXIMUM_PRIORITY - 2u) /* 202, */
status = rtems_task_create(
rtems_build_name( 'F', 'P', '2', ' ' ),
FP2_PRIORITY,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_FLOATING_POINT,
&task_id
);
directive_failed( status, "rtems_task_create of FP2" );
status = rtems_task_start( task_id, Floating_point_task_2, 0 );
directive_failed( status, "rtems_task_start of FP2" );
#define LOW_PRIORITY (RTEMS_MAXIMUM_PRIORITY - 4u) /* 200, */
status = rtems_task_create(
rtems_build_name( 'L', 'O', 'W', ' ' ),
LOW_PRIORITY,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task_id
);
directive_failed( status, "rtems_task_create of LOW" );
status = rtems_task_start( task_id, Low_task, 0 );
directive_failed( status, "rtems_task_start of LOW" );
#define MIDDLE_PRIORITY (RTEMS_MAXIMUM_PRIORITY - 5u) /* 128, */
status = rtems_task_create(
rtems_build_name( 'M', 'I', 'D', ' ' ),
MIDDLE_PRIORITY,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task_id
);
directive_failed( status, "rtems_task_create of MIDDLE" );
status = rtems_task_start( task_id, Middle_task, 0 );
directive_failed( status, "rtems_task_start of MIDDLE" );
status = rtems_task_create(
rtems_build_name( 'H', 'I', 'G', 'H' ),
5,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task_id
);
directive_failed( status, "rtems_task_create of HIGH" );
status = rtems_task_start( task_id, High_task, 0 );
directive_failed( status, "rtems_task_start of HIGH" );
status = rtems_semaphore_create(
rtems_build_name( 'S', 'E', 'M', '1' ),
OPERATION_COUNT,
RTEMS_DEFAULT_ATTRIBUTES,
RTEMS_NO_PRIORITY,
&Semaphore_id
);
directive_failed( status, "rtems_semaphore_create" );
for ( index = 1 ; index <= OPERATION_COUNT ; index++ ) {
status = rtems_task_create(
rtems_build_name( 'N', 'U', 'L', 'L' ),
RTEMS_MAXIMUM_PRIORITY - 1u, /* 254, */
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task_id
);
directive_failed( status, "rtems_task_create LOOP" );
status = rtems_task_start( task_id, null_task, 0 );
directive_failed( status, "rtems_task_start LOOP" );
}
status = rtems_task_delete( RTEMS_SELF );
directive_failed( status, "rtems_task_delete of RTEMS_SELF" );
}
rtems_task Init(
rtems_task_argument ignored
)
{
rtems_id task_id;
rtems_status_code sc;
bool sb;
Heap_Information_block start;
Heap_Information_block info;
size_t stack_size;
puts( "\n\n*** TEST 18 ***" );
puts( "Init - rtems_workspace_get_information - OK" );
sb = rtems_workspace_get_information( &start );
rtems_test_assert( sb );
#if 0
printf( "Init - workspace free = %d\n", start.Free.largest );
printf( "Init - workspace free blocks = %d\n", start.Free.number );
#endif
rtems_test_assert( start.Free.number == 1 );
stack_size = start.Free.largest;
#if 0
printf( "Init - start with stack size of = %d\n", stack_size );
#endif
puts( "Init - rtems_task_create - Unsatisfied on Extensions" );
while (1) {
sc = rtems_task_create(
rtems_build_name( 'T', 'E', 'S', 'T' ),
1,
stack_size,
RTEMS_DEFAULT_MODES,
RTEMS_FLOATING_POINT,
&task_id
);
if ( sc == RTEMS_SUCCESSFUL )
break;
fatal_directive_status( sc, RTEMS_UNSATISFIED, "rtems_task_create" );
/*
* Verify heap is still in same shape if we couldn't allocate a task
*/
sb = rtems_workspace_get_information( &info );
rtems_test_assert( sb );
rtems_test_assert( info.Free.largest == start.Free.largest );
rtems_test_assert( info.Free.number == start.Free.number );
stack_size -= 8;
if ( stack_size <= RTEMS_MINIMUM_STACK_SIZE )
break;
}
if ( sc != RTEMS_SUCCESSFUL )
rtems_test_exit(0);
/*
* Verify heap is still in same shape after we free the task
*/
puts( "Init - rtems_task_delete - OK" );
sc = rtems_task_delete( task_id );
directive_failed( sc, "rtems_task_delete" );
puts( "Init - verify workspace has same memory" );
sb = rtems_workspace_get_information( &info );
rtems_test_assert( sb );
rtems_test_assert( info.Free.largest == start.Free.largest );
rtems_test_assert( info.Free.number == start.Free.number );
puts( "*** END OF TEST 18 ***" );
rtems_test_exit(0);
}
rtems_task Test_task(
rtems_task_argument argument
)
{
(void) rtems_task_delete( RTEMS_SELF );
}
static void test(void)
{
rtems_status_code sc;
rtems_id id;
master_task = rtems_task_self();
#ifdef BSP_INITIAL_EXTENSION
sc = rtems_extension_create(
rtems_build_name(' ', 'B', 'S', 'P'),
&initial_bsp,
&id
);
assert(sc == RTEMS_SUCCESSFUL);
#undef BSP_INITIAL_EXTENSION
#endif
sc = rtems_extension_create(
rtems_build_name('T', 'E', 'S', 'T'),
&initial_test,
&id
);
assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_extension_create(
rtems_build_name('2', ' ', ' ', ' '),
&two,
&id
);
assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_extension_create(
rtems_build_name('3', ' ', ' ', ' '),
&three,
&id
);
assert(sc == RTEMS_SUCCESSFUL);
active_extensions = 4;
assert(counter == 14);
counter = 16;
sc = rtems_task_create(
rtems_build_name('W', 'O', 'R', 'K'),
2,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&id
);
assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_start(id, worker, 0);
assert(sc == RTEMS_SUCCESSFUL);
wait_for_worker();
sc = rtems_task_restart(id, 0);
assert(sc == RTEMS_SUCCESSFUL);
wait_for_worker();
sc = rtems_task_delete(id);
assert(sc == RTEMS_SUCCESSFUL);
/* Process zombies to trigger delete extensions */
sc = rtems_task_create(
rtems_build_name('N', 'U', 'L', 'L'),
2,
SIZE_MAX,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&id
);
assert(sc == RTEMS_UNSATISFIED);
}
void
rtems_monitor_server_task(
rtems_task_argument monitor_flags __attribute__((unused))
)
{
rtems_monitor_server_request_t request;
rtems_monitor_server_response_t response;
rtems_status_code status;
size_t size;
for (;;)
{
status = rtems_message_queue_receive(
rtems_monitor_server_request_queue_id,
&request,
&size,
RTEMS_WAIT,
(rtems_interval) 0);
if (status != RTEMS_SUCCESSFUL)
{
rtems_error(status, "monitor server msg queue receive error");
goto failed;
}
if (size != sizeof(request))
{
rtems_error(0, "monitor server bad size on receive");
goto failed;
}
switch (request.command)
{
case RTEMS_MONITOR_SERVER_CANONICAL:
{
rtems_monitor_object_type_t object_type;
rtems_id id;
rtems_id next_id;
object_type = (rtems_monitor_object_type_t) request.argument0;
id = (rtems_id) request.argument1;
next_id = rtems_monitor_object_canonical_get(object_type,
id,
&response.payload,
&size);
response.command = RTEMS_MONITOR_SERVER_RESPONSE;
response.result0 = next_id;
response.result1 = size;
#define SERVER_OVERHEAD (offsetof(rtems_monitor_server_response_t, \
payload))
status = rtems_message_queue_send(request.return_id,
&response,
size + SERVER_OVERHEAD);
if (status != RTEMS_SUCCESSFUL)
{
rtems_error(status, "response send failed");
goto failed;
}
break;
}
default:
{
rtems_error(0, "invalid command to monitor server: %d", request.command);
goto failed;
}
}
}
failed:
rtems_task_delete(RTEMS_SELF);
}
rtems_task Task2(rtems_task_argument ignored) {
rtems_status_code status;
rtems_id period_id;
rtems_interval ticks;
status = rtems_rate_monotonic_create(
rtems_build_name( 'P', 'E', 'R', '2' ),
&period_id
);
ticks = get_ticks_for_period(50);
// the punching will start with the first hole
int hole_to_punch = 0;
// we are about to punch holes_total_count holes
int holes_total_count = 4;
int error = 0;
int done = 0;
while(1)
{
status = rtems_rate_monotonic_period( period_id, ticks );
if(status == RTEMS_TIMEOUT)
{
break; // this is the end. the system missed a deadline, which is fatal.
}
int state = read_punchpress_state();
if (state < STATE_INITIAL) break;
switch (state)
{
case STATE_READY:
plan_movement(hole_to_punch, holes_total_count);
break;
case STATE_PUNCH_READY:
punch(hole_to_punch, holes_total_count);
break;
case STATE_PUNCHING:
control_punch(&hole_to_punch);
break;
case STATE_RETRACT:
control_retract();
break;
case STATE_NAVIGATING:
break;
case STATE_DONE:
done = 1;
break;
default:
error = 1;
break;
}
if ((error + done) > 0){
break;
}
}
if (error > 0)
{
printf("ERROR! SOMETHING WENT WRONG (UNEXPECTED STATE OR DEADLINE MISSED) IN TASK CONTROLLING PUNCHING!\n");
exit(1);
}
outport_byte(OUT_PUNCH_IRQ, 0);
rtems_rate_monotonic_delete(period_id);
rtems_semaphore_delete(state_semaphore_id);
rtems_interrupt_handler_remove(5, isr, NULL);
/**
* The only way to shutdown the app is to invoke exit() before deleting the "last" task.
* Since it is not very nice and it is not used in example apps, just delete the task.
**/
rtems_task_delete(RTEMS_SELF);
}
rtems_task Task_1(
rtems_task_argument argument
)
{
rtems_id qid;
uint32_t index;
uint32_t count;
rtems_status_code status;
size_t size;
size_t queue_size;
unsigned char *cp;
status = rtems_message_queue_ident(
Queue_name[ 1 ],
RTEMS_SEARCH_ALL_NODES,
&qid
);
printf(
"TA1 - rtems_message_queue_ident - qid => %08" PRIxrtems_id "\n",
qid
);
directive_failed( status, "rtems_message_queue_ident" );
Fill_buffer( "BUFFER 1 TO Q 1", buffer );
puts( "TA1 - rtems_message_queue_send - BUFFER 1 TO Q 1" );
status = rtems_message_queue_send( Queue_id[ 1 ], buffer, MESSAGE_SIZE );
directive_failed( status, "rtems_message_queue_send" );
Fill_buffer( "BUFFER 2 TO Q 1", buffer );
puts( "TA1 - rtems_message_queue_send - BUFFER 2 TO Q 1" );
status = rtems_message_queue_send( Queue_id[ 1 ], buffer, MESSAGE_SIZE );
directive_failed( status, "rtems_message_queue_send" );
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" );
Fill_buffer( "BUFFER 3 TO Q 1", buffer );
puts( "TA1 - rtems_message_queue_send - BUFFER 3 TO Q 1" );
status = rtems_message_queue_send( Queue_id[ 1 ], buffer, MESSAGE_SIZE );
directive_failed( status, "rtems_message_queue_send" );
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" );
rtems_test_pause();
Fill_buffer( "BUFFER 1 TO Q 2", buffer );
puts( "TA1 - rtems_message_queue_send - BUFFER 1 TO Q 2" );
status = rtems_message_queue_send( Queue_id[ 2 ], buffer, MESSAGE_SIZE );
directive_failed( status, "rtems_message_queue_send" );
puts_nocr( "TA1 - rtems_message_queue_receive - receive from queue 1 - " );
puts ( "10 second timeout" );
status = rtems_message_queue_receive(
Queue_id[ 1 ],
buffer,
&size,
RTEMS_DEFAULT_OPTIONS,
10 * rtems_clock_get_ticks_per_second()
);
directive_failed( status, "rtems_message_queue_receive" );
puts_nocr( "TA1 - buffer received: " );
Put_buffer( buffer );
new_line;
puts( "TA1 - rtems_task_delete - delete TA2" );
status = rtems_task_delete( Task_id[ 2 ] );
directive_failed( status, "rtems_task_delete" );
Fill_buffer( "BUFFER 1 TO Q 3", buffer );
puts( "TA1 - rtems_message_queue_send - BUFFER 1 TO Q 3" );
status = rtems_message_queue_send( Queue_id[ 3 ], buffer, MESSAGE_SIZE );
directive_failed( status, "rtems_message_queue_send" );
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" );
rtems_test_pause();
Fill_buffer( "BUFFER 2 TO Q 3", buffer );
puts( "TA1 - rtems_message_queue_send - BUFFER 2 TO Q 3" );
status = rtems_message_queue_send( Queue_id[ 3 ], buffer, MESSAGE_SIZE );
directive_failed( status, "rtems_message_queue_send" );
Fill_buffer( "BUFFER 3 TO Q 3", buffer );
puts( "TA1 - rtems_message_queue_send - BUFFER 3 TO Q 3" );
status = rtems_message_queue_send( Queue_id[ 3 ], buffer, MESSAGE_SIZE );
directive_failed( status, "rtems_message_queue_send" );
Fill_buffer( "BUFFER 4 TO Q 3", buffer );
puts( "TA1 - rtems_message_queue_send - BUFFER 4 TO Q 3" );
status = rtems_message_queue_send( Queue_id[ 3 ], buffer, MESSAGE_SIZE );
directive_failed( status, "rtems_message_queue_send" );
Fill_buffer( "BUFFER 5 TO Q 3", buffer );
puts( "TA1 - rtems_message_queue_urgent - BUFFER 5 TO Q 3" );
status = rtems_message_queue_urgent( Queue_id[ 3 ], buffer, MESSAGE_SIZE );
directive_failed( status, "rtems_message_queue_urgent" );
for ( index = 1 ; index <= 4 ; index++ ) {
puts(
"TA1 - rtems_message_queue_receive - receive from queue 3 - "
"RTEMS_WAIT FOREVER"
);
status = rtems_message_queue_receive(
Queue_id[ 3 ],
buffer,
&size,
RTEMS_DEFAULT_OPTIONS,
RTEMS_NO_TIMEOUT
);
directive_failed( status, "rtems_message_queue_receive" );
puts_nocr( "TA1 - buffer received: " );
Put_buffer( buffer );
new_line;
}
Fill_buffer( "BUFFER 3 TO Q 2", buffer );
puts( "TA1 - rtems_message_queue_urgent - BUFFER 3 TO Q 2" );
status = rtems_message_queue_urgent( Queue_id[ 2 ], buffer, MESSAGE_SIZE );
directive_failed( status, "rtems_message_queue_urgent" );
puts(
"TA1 - rtems_message_queue_receive - receive from queue 2 - "
"RTEMS_WAIT FOREVER"
);
status = rtems_message_queue_receive(
Queue_id[ 2 ],
buffer,
&size,
RTEMS_DEFAULT_OPTIONS,
RTEMS_NO_TIMEOUT
);
directive_failed( status, "rtems_message_queue_receive" );
puts_nocr( "TA1 - buffer received: " );
Put_buffer( buffer );
new_line;
rtems_test_pause();
puts( "TA1 - rtems_message_queue_delete - delete queue 1" );
status = rtems_message_queue_delete( Queue_id[ 1 ] );
directive_failed( status, "rtems_message_queue_delete" );
Fill_buffer( "BUFFER 3 TO Q 2", buffer );
puts( "TA1 - rtems_message_queue_urgent - BUFFER 3 TO Q 2" );
status = rtems_message_queue_urgent( Queue_id[ 2 ], buffer, MESSAGE_SIZE );
directive_failed( status, "rtems_message_queue_urgent" );
puts( "TA1 - rtems_message_queue_delete - delete queue 2" );
status = rtems_message_queue_delete( Queue_id[ 2 ] );
directive_failed( status, "rtems_message_queue_delete" );
puts( "TA1 - rtems_message_queue_get_number_pending - check Q 3" );
status = rtems_message_queue_get_number_pending( Queue_id[ 3 ], &count );
directive_failed( status, "rtems_message_queue_get_number_pending" );
printf( "TA1 - %" PRIu32 " messages are pending on Q 3\n", count );
puts( "TA1 - rtems_message_queue_flush - empty Q 3" );
status = rtems_message_queue_flush( Queue_id[ 3 ], &count );
directive_failed( status, "rtems_message_queue_flush" );
printf( "TA1 - %" PRIu32 " messages were flushed from Q 3\n", count );
Fill_buffer( "BUFFER 1 TO Q 3", buffer );
puts( "TA1 - rtems_message_queue_send - BUFFER 1 TO Q 3" );
status = rtems_message_queue_send( Queue_id[ 3 ], buffer, MESSAGE_SIZE );
directive_failed( status, "rtems_message_queue_send" );
Fill_buffer( "BUFFER 2 TO Q 3", buffer );
puts( "TA1 - rtems_message_queue_send - BUFFER 2 TO Q 3" );
status = rtems_message_queue_send( Queue_id[ 3 ], buffer, MESSAGE_SIZE );
directive_failed( status, "rtems_message_queue_send" );
/* this broadcast should have no effect on the queue */
Fill_buffer( "NO BUFFER TO Q1", (long *)buffer );
puts( "TA1 - rtems_message_queue_broadcast - NO BUFFER TO Q1" );
status = rtems_message_queue_broadcast(
Queue_id[ 1 ],
(long (*)[4])buffer,
16,
&count
);
printf( "TA1 - number of tasks awakened = %" PRIu32 "\n", count );
puts( "TA1 - rtems_message_queue_get_number_pending - check Q 3" );
status = rtems_message_queue_get_number_pending( Queue_id[ 3 ], &count );
directive_failed( status, "rtems_message_queue_get_number_pending" );
printf( "TA1 - %" PRIu32 " messages are pending on Q 3\n", count );
Fill_buffer( "BUFFER 3 TO Q 3", buffer );
puts( "TA1 - rtems_message_queue_send - BUFFER 3 TO Q 3" );
status = rtems_message_queue_send( Queue_id[ 3 ], buffer, MESSAGE_SIZE );
directive_failed( status, "rtems_message_queue_send" );
puts( "TA1 - rtems_message_queue_flush - Q 3" );
status = rtems_message_queue_flush( Queue_id[ 3 ], &count );
printf( "TA1 - %" PRIu32 " messages were flushed from Q 3\n", count );
puts( "TA1 - rtems_message_queue_send until all message buffers consumed" );
while ( FOREVER ) {
status = rtems_message_queue_send( Queue_id[ 3 ], buffer, MESSAGE_SIZE );
if ( status == RTEMS_TOO_MANY ) break;
directive_failed( status, "rtems_message_queue_send loop" );
}
puts( "TA1 - all message buffers consumed" );
puts( "TA1 - rtems_message_queue_flush - Q 3" );
status = rtems_message_queue_flush( Queue_id[ 3 ], &count );
printf( "TA1 - %" PRIu32 " messages were flushed from Q 3\n", count );
rtems_test_pause();
puts( "TA1 - create message queue of 20 bytes on queue 1" );
status = rtems_message_queue_create(
Queue_name[ 1 ],
100,
20,
RTEMS_DEFAULT_ATTRIBUTES,
&Queue_id[ 1 ]
);
directive_failed( status, "rtems_message_queue_create of Q1; 20 bytes each" );
status = rtems_message_queue_send( Queue_id[ 1 ], big_send_buffer, 40 );
fatal_directive_status(status,
RTEMS_INVALID_SIZE,
"expected RTEMS_INVALID_SIZE"
);
puts( "TA1 - rtems_message_queue_delete - delete queue 1" );
status = rtems_message_queue_delete( Queue_id[ 1 ] );
directive_failed( status, "rtems_message_queue_delete" );
rtems_test_pause();
puts( "TA1 - rtems_message_queue_create - variable sizes " );
for (queue_size = 1; queue_size < 1030; queue_size++) {
status = rtems_message_queue_create(
Queue_name[ 1 ],
2, /* just 2 msgs each */
queue_size,
RTEMS_DEFAULT_ATTRIBUTES,
&Queue_id[ 1 ]
);
if (status != RTEMS_SUCCESSFUL) {
printf("TA1 - msq que size: %zu\n", queue_size);
directive_failed( status, "rtems_message_queue_create of Q1" );
}
status = rtems_message_queue_delete( Queue_id[ 1 ] );
directive_failed( status, "rtems_message_queue_delete" );
}
puts( "TA1 - rtems_message_queue_create and send - variable sizes " );
for (queue_size = 1; queue_size < 1030; queue_size++) {
status = rtems_message_queue_create(
Queue_name[ 1 ],
2, /* just 2 msgs each */
queue_size,
RTEMS_DEFAULT_ATTRIBUTES,
&Queue_id[ 1 ]
);
directive_failed( status, "rtems_message_queue_create of Q1" );
dope_buffer(big_send_buffer, sizeof(big_send_buffer), queue_size);
memset(big_receive_buffer, 'Z', sizeof(big_receive_buffer));
/* send a msg too big */
status = rtems_message_queue_send(
Queue_id[ 1 ],
big_send_buffer,
queue_size + 1
);
fatal_directive_status(
status,
RTEMS_INVALID_SIZE,
"rtems_message_queue_send too large"
);
/* send a msg that is just right */
status = rtems_message_queue_send(
Queue_id[ 1 ],
big_send_buffer,
queue_size);
directive_failed(status, "rtems_message_queue_send exact size");
/* now read and verify the message just sent */
status = rtems_message_queue_receive(
Queue_id[ 1 ],
big_receive_buffer,
&size,
RTEMS_DEFAULT_OPTIONS,
1 * rtems_clock_get_ticks_per_second()
);
directive_failed(status, "rtems_message_queue_receive exact size");
if (size != queue_size) {
puts("TA1 - exact size size match failed");
rtems_test_exit(1);
}
if (memcmp(big_send_buffer, big_receive_buffer, size) != 0) {
puts("TA1 - exact size data match failed");
rtems_test_exit(1);
}
for (cp = (big_receive_buffer + size);
cp < (big_receive_buffer + sizeof(big_receive_buffer));
cp++) {
if (*cp != 'Z') {
puts("TA1 - exact size overrun match failed");
rtems_test_exit(1);
}
}
/* all done with this one; delete it */
status = rtems_message_queue_delete( Queue_id[ 1 ] );
directive_failed( status, "rtems_message_queue_delete" );
}
TEST_END();
rtems_test_exit( 0 );
}
rtems_task Init(
rtems_task_argument argument
)
{
rtems_status_code status;
rtems_time_of_day time;
rtems_task_priority old;
puts( "\n\n*** SP73 (YIELD) TEST ***" );
time.year = 1988;
time.month = 12;
time.day = 31;
time.hour = 9;
time.minute = 0;
time.second = 0;
time.ticks = 0;
status = rtems_clock_set( &time );
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', ' ' );
status = rtems_task_create(
Task_name[ 1 ], 1, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES, &Task_id[ 1 ]
);
directive_failed( status, "create 1" );
status = rtems_task_create(
Task_name[ 2 ], 1, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES, &Task_id[ 2 ]
);
directive_failed( status, "create 2" );
status = rtems_task_create(
Task_name[ 3 ], 1, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES, &Task_id[ 3 ]
);
directive_failed( status, "create 3" );
status = rtems_task_start( Task_id[ 1 ], Test_task, 1 );
directive_failed( status, "start 1" );
rtems_task_wake_after( RTEMS_YIELD_PROCESSOR );
status = rtems_task_start( Task_id[ 2 ], Test_task, 2 );
directive_failed( status, "start 2" );
rtems_task_wake_after( RTEMS_YIELD_PROCESSOR );
status = rtems_task_start( Task_id[ 3 ], Test_task, 3 );
directive_failed( status, "start 3" );
status = rtems_task_set_priority(Task_id[1], 1, &old);
directive_failed( status, "set priority" );
status = rtems_task_wake_after( RTEMS_YIELD_PROCESSOR );
directive_failed( status, "wake after" );
status = rtems_task_delete( RTEMS_SELF );
directive_failed( status, "delete" );
}
rtems_task Init(
rtems_task_argument argument
)
{
rtems_status_code status;
rtems_id id;
TEST_BEGIN();
Extension_name[ 1 ] = rtems_build_name( 'E', 'X', 'T', '1' );
Extension_name[ 2 ] = rtems_build_name( 'E', 'X', 'T', '2' );
puts ( "rtems_extension_create - bad id pointer -- RTEMS_INVALID_ADDRESS" );
status = rtems_extension_create( 0xa5a5a5a5, &Extensions, NULL );
fatal_directive_status(
status, RTEMS_INVALID_ADDRESS, "rtems_extension_create" );
puts ( "rtems_extension_create - bad name -- RTEMS_INVALID_NAME" );
status = rtems_extension_create( 0, &Extensions, &id );
fatal_directive_status(
status, RTEMS_INVALID_NAME, "rtems_extension_create #1" );
puts( "rtems_extension_create - first one -- OK" );
status = rtems_extension_create(
Extension_name[ 1 ],
&Extensions,
&Extension_id[ 1 ]
);
directive_failed( status, "rtems_extension_create" );
puts( "rtems_extension_create - second one-- OK" );
status = rtems_extension_create(
Extension_name[ 2 ],
&Extensions,
&Extension_id[ 2 ]
);
directive_failed( status, "rtems_extension_create #2" );
puts ( "rtems_extension_create -- RTEMS_TOO_MANY" );
status = rtems_extension_create( 0xa5a5a5a5, &Extensions, &id );
fatal_directive_status( status, RTEMS_TOO_MANY, "rtems_extension_create" );
puts( "rtems_extension_delete - second one -- OK" );
status = rtems_extension_delete( Extension_id[ 2 ] );
directive_failed( status, "rtems_extension_delete #2" );
puts( "rtems_extension_delete - second one again -- RTEMS_INVALID_ID" );
status = rtems_extension_delete( Extension_id[ 2 ] );
fatal_directive_status(
status,
RTEMS_INVALID_ID,
"rtems_extension_delete #2 bad"
);
puts ( "rtems_extension_ident -- OK" );
status = rtems_extension_ident( Extension_name[1], &id );
directive_failed( status, "rtems_extension_ident" );
puts ( "rtems_extension_ident - bad name -- RTEMS_INVALID_NAME" );
status = rtems_extension_ident( Extension_name[2], &id );
fatal_directive_status( status, RTEMS_INVALID_NAME, "rtems_extension_ident" );
puts ( "rtems_extension_ident - bad name -- RTEMS_INVALID_ADDRESS" );
status = rtems_extension_ident( Extension_name[2], NULL );
fatal_directive_status(
status,
RTEMS_INVALID_ADDRESS,
"rtems_extension_ident"
);
puts( "rtems_extension_create - harmless -- OK" );
status = rtems_extension_create(
Extension_name[ 2 ],
&Harmless_extensions,
&Extension_id[ 2 ]
);
directive_failed( status, "rtems_extension_create #3" );
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', ' ' );
status = rtems_task_create(
Task_name[ 1 ],
4,
RTEMS_MINIMUM_STACK_SIZE * 2,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[ 1 ]
);
directive_failed( status, "rtems_task_create of TA1" );
assert_extension_counts( &Task_created[ 0 ], 0x2 );
status = rtems_task_create(
Task_name[ 2 ],
4,
RTEMS_MINIMUM_STACK_SIZE * 2,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[ 2 ]
);
directive_failed( status, "rtems_task_create of TA2" );
assert_extension_counts( &Task_created[ 0 ], 0x2 | 0x4 );
#define TA3_PRIORITY (RTEMS_MAXIMUM_PRIORITY - 4u)
status = rtems_task_create(
Task_name[ 3 ],
TA3_PRIORITY,
RTEMS_MINIMUM_STACK_SIZE * 2,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[ 3 ]
);
directive_failed( status, "rtems_task_create of TA3" );
assert_extension_counts( &Task_created[ 0 ], 0x2 | 0x4 | 0x8 );
#define TA4_PRIORITY (RTEMS_MAXIMUM_PRIORITY - 1u)
status = rtems_task_create(
Task_name[ 4 ],
TA4_PRIORITY,
RTEMS_MINIMUM_STACK_SIZE * 2,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[ 4 ]
);
directive_failed( status, "rtems_task_create of TA4" );
assert_extension_counts( &Task_created[ 0 ], 0x2 | 0x4 | 0x8 | 0x10 );
status = rtems_task_start( Task_id[ 1 ], Task_1, 0 );
directive_failed( status, "rtems_task_start of TA1" );
assert_extension_counts( &Task_started[ 0 ], 0x2 );
status = rtems_task_start( Task_id[ 2 ], Task_2, 0 );
directive_failed( status, "rtems_task_start of TA2" );
assert_extension_counts( &Task_started[ 0 ], 0x2 | 0x4 );
status = rtems_task_start( Task_id[ 3 ], Task_3, 0 );
directive_failed( status, "rtems_task_start of TA3" );
assert_extension_counts( &Task_started[ 0 ], 0x2 | 0x4 | 0x8 );
status = rtems_task_start( Task_id[ 4 ], Task_4, 0 );
directive_failed( status, "rtems_task_start of TA4" );
assert_extension_counts( &Task_started[ 0 ], 0x2 | 0x4 | 0x8 | 0x10 );
status = rtems_task_restart( Task_id[ 2 ], 0 );
directive_failed( status, "rtems_task_restart of TA3" );
assert_extension_counts( &Task_restarted[ 0 ], 0x0 );
status = rtems_task_delete( RTEMS_SELF );
directive_failed( status, "rtems_task_delete of RTEMS_SELF" );
}
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" );
}
}
}
rtems_task read_task( rtems_task_argument not_used )
{
int fd = 0;
int status = -1;
uint32_t released = 0;
puts( "read_task - opening /fifo in non-blocking mode" );
fd = open( "/fifo", O_RDONLY | O_NONBLOCK );
if( fd <= 0 ) {
printf( "Error opening file: (%d) :: %s\n", errno, strerror( errno ) );
rtems_test_assert( 0 );
}
puts( "read_task - attempt to read with number of writers = 0" );
status = read( fd, recvBuf, SEND_RCV_BUFSIZ );
rtems_test_assert( status == 0 );
puts( "read_task - releasing the write task" );
status = rtems_barrier_release( wBarrier, &released );
rtems_test_assert( status == 0 );
puts( "read_task - waiting at a barrier" );
status = rtems_barrier_wait( rBarrier, RTEMS_NO_TIMEOUT );
rtems_test_assert( status == RTEMS_SUCCESSFUL );
puts( "read_task - attempting to read from the fifo -- Expect EAGAIN" );
status = read( fd, recvBuf, SEND_RCV_BUFSIZ );
rtems_test_assert( status == -1 );
rtems_test_assert( errno == EAGAIN );
puts( "read_task - closing /fifo" );
status = close( fd );
rtems_test_assert( status == 0 );
puts("read_task - opening /fifo in read-only mode");
fd = open( "/fifo", O_RDONLY );
if( fd <= 0 ) {
printf( "Error opening file: (%d) :: %s\n", errno, strerror( errno ) );
rtems_test_assert( 0 );
}
puts( "read_task - releasing the write task" );
status = rtems_barrier_release( wBarrier, &released );
rtems_test_assert( status == 0 );
puts( "read_task - reading from /fifo - OK" );
status = read( fd, recvBuf, 10 );
rtems_test_assert( status == 10 );
puts( "read_task - reading from /fifo - OK" );
status = read( fd, recvBuf+10, 10 );
rtems_test_assert( status == 10 );
puts( "read_task - waiting at a barrier" );
status = rtems_barrier_wait( rBarrier, RTEMS_NO_TIMEOUT );
rtems_test_assert( status == RTEMS_SUCCESSFUL );
puts( "read_task - reading from /fifo - OK" );
status = read( fd, recvBuf+20, SEND_RCV_BUFSIZ - 20 );
rtems_test_assert( status == SEND_RCV_BUFSIZ - 20 );
if( strcmp( sendBuf, recvBuf ) ) {
puts( "Sent, received buffer do not match" );
rtems_test_assert( 0 );
}
puts( "read_task - releasing the write task" );
status = rtems_barrier_release( wBarrier, &released );
rtems_test_assert( status == 0 );
puts( "read_task - waiting at a barrier" );
status = rtems_barrier_wait( rBarrier, RTEMS_NO_TIMEOUT );
rtems_test_assert( status == RTEMS_SUCCESSFUL );
status = close( fd );
rtems_test_assert( status == 0 );
puts( "read_task - releasing the write task" );
status = rtems_barrier_release( wBarrier, &released );
rtems_test_assert( status == 0 );
rtems_task_delete( RTEMS_SELF );
}
rtems_task Init(
rtems_task_argument argument
)
{
uint32_t index;
rtems_id task_id;
rtems_status_code status;
Print_Warning();
TEST_BEGIN();
if (
_Scheduler_Table[ 0 ].Operations.initialize
!= _Scheduler_priority_Initialize
) {
puts(" Error ==> " );
puts("Test only supported for deterministic priority scheduler\n" );
TEST_END();
rtems_test_exit( 0 );
}
#define FP1_PRIORITY (RTEMS_MAXIMUM_PRIORITY - 3u) /* 201, */
status = rtems_task_create(
rtems_build_name( 'F', 'P', '1', ' ' ),
FP1_PRIORITY,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_FLOATING_POINT,
&task_id
);
directive_failed( status, "rtems_task_create of FP1" );
status = rtems_task_start( task_id, Floating_point_task_1, 0 );
directive_failed( status, "rtems_task_start of FP1" );
#define FP2_PRIORITY (RTEMS_MAXIMUM_PRIORITY - 2u) /* 202, */
status = rtems_task_create(
rtems_build_name( 'F', 'P', '2', ' ' ),
FP2_PRIORITY,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_FLOATING_POINT,
&task_id
);
directive_failed( status, "rtems_task_create of FP2" );
status = rtems_task_start( task_id, Floating_point_task_2, 0 );
directive_failed( status, "rtems_task_start of FP2" );
#define LOW_PRIORITY (RTEMS_MAXIMUM_PRIORITY - 4u) /* 200, */
status = rtems_task_create(
rtems_build_name( 'L', 'O', 'W', ' ' ),
LOW_PRIORITY,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task_id
);
directive_failed( status, "rtems_task_create of LOW" );
status = rtems_task_start( task_id, Low_task, 0 );
directive_failed( status, "rtems_task_start of LOW" );
#define MIDDLE_PRIORITY (RTEMS_MAXIMUM_PRIORITY - 5u) /* 128, */
status = rtems_task_create(
rtems_build_name( 'M', 'I', 'D', ' ' ),
MIDDLE_PRIORITY,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task_id
);
directive_failed( status, "rtems_task_create of MIDDLE" );
status = rtems_task_start( task_id, Middle_task, 0 );
directive_failed( status, "rtems_task_start of MIDDLE" );
status = rtems_task_create(
rtems_build_name( 'H', 'I', 'G', 'H' ),
5,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task_id
);
directive_failed( status, "rtems_task_create of HIGH" );
status = rtems_task_start( task_id, High_task, 0 );
directive_failed( status, "rtems_task_start of HIGH" );
status = rtems_semaphore_create(
rtems_build_name( 'S', 'E', 'M', '1' ),
OPERATION_COUNT,
RTEMS_DEFAULT_ATTRIBUTES,
RTEMS_NO_PRIORITY,
&Semaphore_id
);
directive_failed( status, "rtems_semaphore_create" );
for ( index = 1 ; index <= OPERATION_COUNT ; index++ ) {
status = rtems_task_create(
rtems_build_name( 'N', 'U', 'L', 'L' ),
RTEMS_MAXIMUM_PRIORITY - 1u, /* 254, */
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task_id
);
directive_failed( status, "rtems_task_create LOOP" );
status = rtems_task_start( task_id, null_task, 0 );
directive_failed( status, "rtems_task_start LOOP" );
}
status = rtems_task_delete( RTEMS_SELF );
directive_failed( status, "rtems_task_delete of RTEMS_SELF" );
}
rtems_task Init(
rtems_task_argument argument
)
{
rtems_time_of_day time;
uint32_t index;
rtems_status_code status;
TEST_BEGIN();
build_time( &time, 12, 31, 1988, 9, 0, 0, 0 );
status = rtems_clock_set( &time );
directive_failed( status, "rtems_clock_set" );
/* initiate with bad priority */
puts( "timer_initiate_server -- INVALID_PRIORITY" );
status = rtems_timer_initiate_server(
1000,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_ATTRIBUTES
);
fatal_directive_status(
status,
RTEMS_INVALID_PRIORITY,
"rtems_timer_initiate_server bad priority"
);
puts( "timer_initiate_server -- OK" );
status = rtems_timer_initiate_server(
RTEMS_TIMER_SERVER_DEFAULT_PRIORITY,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_ATTRIBUTES
);
directive_failed( status, "rtems_timer_initiate_server" );
puts( "timer_initiate_server -- already started" );
status = rtems_timer_initiate_server(
RTEMS_TIMER_SERVER_DEFAULT_PRIORITY,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_ATTRIBUTES
);
fatal_directive_status(
status,
RTEMS_INCORRECT_STATE,
"rtems_timer_initiate_server already started"
);
/*
* Create test tasks
*/
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', ' ' );
Timer_name[ 1 ] = rtems_build_name( 'T', 'M', '1', ' ' );
Timer_name[ 2 ] = rtems_build_name( 'T', 'M', '2', ' ' );
Timer_name[ 3 ] = rtems_build_name( 'T', 'M', '3', ' ' );
for ( index = 1 ; index <= 3 ; index++ ) {
status = rtems_task_create(
Task_name[ index ],
1,
RTEMS_MINIMUM_STACK_SIZE * 2,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[ index ]
);
directive_failed( status, "rtems_task_create loop" );
status = rtems_timer_create(
Timer_name[ index ],
&Timer_id[ index ]
);
directive_failed( status, "rtems_timer_create loop" );
}
for ( index = 1 ; index <= 3 ; index++ ) {
status = rtems_task_start( Task_id[ index ], Task_1_through_3, index );
directive_failed( status, "rtems_task_start loop" );
}
status = rtems_task_delete( RTEMS_SELF );
directive_failed( status, "rtems_task_delete of RTEMS_SELF" );
}
/*PAGE
*
* daemon
*
* This task runs forever. It waits for service requests on the FTP port
* (port 21 by default). When a request is received, it opens a new session
* to handle those requests until the connection is closed.
*
* Input parameters:
* NONE
*
* Output parameters:
* NONE
*/
static void
daemon(rtems_task_argument args __attribute__((unused)))
{
int s;
socklen_t addrLen;
struct sockaddr_in addr;
FTPD_SessionInfo_t *info = NULL;
s = socket(PF_INET, SOCK_STREAM, 0);
if (s < 0)
syslog(LOG_ERR, "ftpd: Error creating socket: %s", serr());
addr.sin_family = AF_INET;
addr.sin_port = htons(rtems_ftpd_configuration.port);
addr.sin_addr.s_addr = htonl(INADDR_ANY);
memset(addr.sin_zero, 0, sizeof(addr.sin_zero));
if (0 > bind(s, (struct sockaddr *)&addr, sizeof(addr)))
syslog(LOG_ERR, "ftpd: Error binding control socket: %s", serr());
else if (0 > listen(s, 1))
syslog(LOG_ERR, "ftpd: Error listening on control socket: %s", serr());
else while (1)
{
int ss;
addrLen = sizeof(addr);
ss = accept(s, (struct sockaddr *)&addr, &addrLen);
if (0 > ss)
syslog(LOG_ERR, "ftpd: Error accepting control connection: %s", serr());
else if(!set_socket_timeout(ss, ftpd_timeout))
close_socket(ss);
else
{
info = task_pool_obtain();
if (NULL == info)
{
close_socket(ss);
}
else
{
info->ctrl_socket = ss;
if ((info->ctrl_fp = fdopen(info->ctrl_socket, "r+")) == NULL)
{
syslog(LOG_ERR, "ftpd: fdopen() on socket failed: %s", serr());
close_stream(info);
task_pool_release(info);
}
else
{
/* Initialize corresponding SessionInfo structure */
info->def_addr = addr;
if(0 > getsockname(ss, (struct sockaddr *)&addr, &addrLen))
{
syslog(LOG_ERR, "ftpd: getsockname(): %s", serr());
close_stream(info);
task_pool_release(info);
}
else
{
info->use_default = 1;
info->ctrl_addr = addr;
info->pasv_socket = -1;
info->data_socket = -1;
info->xfer_mode = TYPE_A;
info->data_addr.sin_port =
htons(ntohs(info->ctrl_addr.sin_port) - 1);
info->idle = ftpd_timeout;
/* Wakeup the session task. The task will call task_pool_release
after it closes connection. */
rtems_event_send(info->tid, FTPD_RTEMS_EVENT);
}
}
}
}
}
rtems_task_delete(RTEMS_SELF);
}
rtems_task Middle_tasks(
rtems_task_argument argument
)
{
(void) rtems_task_delete( RTEMS_SELF );
}
rtems_task Init(
rtems_task_argument argument
)
{
rtems_id id;
uint32_t index;
rtems_status_code status;
Print_Warning();
puts( "\n\n*** TIME TEST 29 ***" );
Period_name = rtems_build_name( 'P', 'R', 'D', ' ' );
benchmark_timer_initialize();
(void) rtems_rate_monotonic_create( Period_name, &id );
end_time = benchmark_timer_read();
put_time(
"rtems_rate_monotonic_create",
end_time,
1,
0,
CALLING_OVERHEAD_RATE_MONOTONIC_CREATE
);
benchmark_timer_initialize();
(void) rtems_rate_monotonic_period( id, 10 );
end_time = benchmark_timer_read();
put_time(
"rtems_rate_monotonic_period: initiate period -- returns to caller",
end_time,
1,
0,
CALLING_OVERHEAD_RATE_MONOTONIC_PERIOD
);
benchmark_timer_initialize();
(void) rtems_rate_monotonic_period( id, RTEMS_PERIOD_STATUS );
end_time = benchmark_timer_read();
put_time(
"rtems_rate_monotonic_period: obtain status",
end_time,
1,
0,
CALLING_OVERHEAD_RATE_MONOTONIC_PERIOD
);
benchmark_timer_initialize();
(void) rtems_rate_monotonic_cancel( id );
end_time = benchmark_timer_read();
put_time(
"rtems_rate_monotonic_cancel",
end_time,
1,
0,
CALLING_OVERHEAD_RATE_MONOTONIC_CANCEL
);
benchmark_timer_initialize();
(void) rtems_rate_monotonic_delete( id );
end_time = benchmark_timer_read();
put_time(
"rtems_rate_monotonic_delete: inactive",
end_time,
1,
0,
CALLING_OVERHEAD_RATE_MONOTONIC_DELETE
);
status = rtems_rate_monotonic_create( Period_name, &id );
directive_failed( status, "rtems_rate_monotonic_create" );
status = rtems_rate_monotonic_period( id, 10 );
directive_failed( status, "rtems_rate_monotonic_period" );
benchmark_timer_initialize();
rtems_rate_monotonic_delete( id );
end_time = benchmark_timer_read();
put_time(
"rtems_rate_monotonic_delete: active",
end_time,
1,
0,
CALLING_OVERHEAD_RATE_MONOTONIC_DELETE
);
#define LOOP_TASK_PRIORITY ((RTEMS_MAXIMUM_PRIORITY / 2u) + 1u)
for ( index=1 ; index <= OPERATION_COUNT ; index++ ) {
status = rtems_task_create(
rtems_build_name( 'T', 'E', 'S', 'T' ),
LOOP_TASK_PRIORITY,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&id
);
directive_failed( status, "rtems_task_create LOOP" );
status = rtems_task_start( id, Tasks, 0 );
directive_failed( status, "rtems_task_start LOOP" );
}
#define MIDDLE_PRIORITY (RTEMS_MAXIMUM_PRIORITY - 2u)
status = rtems_task_create(
rtems_build_name( 'L', 'O', 'W', ' ' ),
MIDDLE_PRIORITY,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&id
);
directive_failed( status, "rtems_task_create LOW" );
status = rtems_task_start( id, Low_task, 0 );
directive_failed( status, "rtems_task_start LOW" );
Task_count = 0;
status = rtems_task_delete( RTEMS_SELF );
directive_failed( status, "rtems_task_delete of RTEMS_SELF" );
}
rtems_task Task_1(
rtems_task_argument argument
)
{
rtems_mode previous_mode;
rtems_status_code status;
puts( "TA1 - rtems_signal_catch - RTEMS_INTERRUPT_LEVEL( 3 )" );
status = rtems_signal_catch( Process_asr, RTEMS_INTERRUPT_LEVEL(3) );
directive_failed( status, "rtems_signal_catch" );
puts( "TA1 - rtems_signal_send - RTEMS_SIGNAL_16 to self" );
status = rtems_signal_send( RTEMS_SELF, RTEMS_SIGNAL_16 );
directive_failed( status, "rtems_signal_send" );
puts( "TA1 - rtems_signal_send - RTEMS_SIGNAL_0 to self" );
status = rtems_signal_send( RTEMS_SELF, RTEMS_SIGNAL_0 );
directive_failed( status, "rtems_signal_send" );
puts( "TA1 - rtems_signal_catch - RTEMS_NO_ASR" );
status = rtems_signal_catch( Process_asr, RTEMS_NO_ASR );
directive_failed( status, "rtems_signal_catch" );
FLUSH_OUTPUT();
rtems_test_pause();
puts( "TA1 - rtems_signal_send - RTEMS_SIGNAL_1 to self" );
status = rtems_signal_send( RTEMS_SELF, RTEMS_SIGNAL_1 );
directive_failed( status, "rtems_signal_send" );
puts( "TA1 - rtems_task_mode - disable ASRs" );
status = rtems_task_mode( RTEMS_NO_ASR, RTEMS_ASR_MASK, &previous_mode );
directive_failed( status, "rtems_task_mode" );
Timer_got_this_id = 0;
Timer_got_this_pointer = NULL;
puts( "TA1 - sending signal to RTEMS_SELF from timer" );
status = rtems_timer_fire_after(
Timer_id[ 1 ],
rtems_clock_get_ticks_per_second() / 2,
Signal_3_to_task_1,
(void *) Task_1
);
directive_failed( status, "rtems_timer_fire_after" );
puts( "TA1 - waiting for signal to arrive" );
Signals_sent = FALSE;
Asr_fired = FALSE;
while ( Signals_sent == FALSE )
;
if ( Timer_got_this_id == Timer_id[ 1 ] &&
Timer_got_this_pointer == Task_1 )
puts( "TA1 - timer routine got the correct arguments" );
else
printf(
"TA1 - timer got (0x%" PRIxrtems_id ", %p) instead of (0x%" PRIxrtems_id ", %p)!!!!\n",
Timer_got_this_id,
Timer_got_this_pointer,
Timer_id[ 1 ],
Task_1
);
puts( "TA1 - rtems_task_mode - enable ASRs" );
FLUSH_OUTPUT();
status = rtems_task_mode( RTEMS_ASR, RTEMS_ASR_MASK, &previous_mode );
directive_failed( status, "rtems_task_mode" );
status = rtems_task_wake_after(2 * rtems_clock_get_ticks_per_second());
directive_failed( status, "rtems_task_wake_after" );
puts( "TA1 - rtems_signal_catch - asraddr of NULL" );
status = rtems_signal_catch( NULL, RTEMS_DEFAULT_MODES );
directive_failed( status, "rtems_signal_catch" );
puts( "TA1 - rtems_task_delete - delete self" );
status = rtems_task_delete( RTEMS_SELF );
directive_failed( status, "rtems_task_delete of RTEMS_SELF" );
}
void Screen1()
{
uint32_t notepad_value;
rtems_name task_name;
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"
);
puts( "TA1 - rtems_task_get_note - RTEMS_INVALID_ID (no tasks in API)" );
status = rtems_task_get_note(
rtems_build_id( OBJECTS_ITRON_API, OBJECTS_ITRON_TASKS, 1, 1 ),
RTEMS_NOTEPAD_LAST,
¬epad_value
);
fatal_directive_status(
status,
RTEMS_INVALID_ID,
"rtems_task_get_note with no tasks in API"
);
puts( "TA1 - rtems_object_get_classic_name - bad ID" );
status = rtems_object_get_classic_name(
rtems_build_id( OBJECTS_ITRON_API, OBJECTS_ITRON_TASKS, 1, 1 ),
&task_name
);
fatal_directive_status( status, RTEMS_INVALID_ID,
"rtems_object_get_classic_name with no tasks in API"
);
/* 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 Init(
rtems_task_argument argument
)
{
rtems_status_code status;
printf(
"\n\n*** TEST 13 -- NODE %d ***\n",
Multiprocessing_configuration.node
);
Task_name[ 1 ] = rtems_build_name( '1', '1', '1', ' ' );
Task_name[ 2 ] = rtems_build_name( '2', '2', '2', ' ' );
Queue_name[ 1 ] = rtems_build_name( 'M', 'S', 'G', ' ' );
Semaphore_name[ 1 ] = rtems_build_name( 'S', 'E', 'M', ' ' );
if ( Multiprocessing_configuration.node == 1 ) {
puts( "Creating Message Queue (Global)" );
status = rtems_message_queue_create(
Queue_name[ 1 ],
3,
16,
RTEMS_GLOBAL,
&Queue_id[ 1 ]
);
directive_failed( status, "rtems_message_queue_create" );
puts( "Creating Semaphore (Global)" );
status = rtems_semaphore_create(
Semaphore_name[ 1 ],
1,
RTEMS_GLOBAL | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&Semaphore_id[ 1 ]
);
directive_failed( status, "rtems_semaphore_create" );
status = rtems_semaphore_obtain(
Semaphore_id[ 1 ],
RTEMS_DEFAULT_OPTIONS,
RTEMS_NO_TIMEOUT
);
directive_failed( status, "rtems_semaphore_obtain" );
}
puts( "Creating Test_task 1 (local)" );
status = rtems_task_create(
Task_name[ 1 ],
1,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_TIMESLICE,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[ 1 ]
);
directive_failed( status, "rtems_task_create" );
puts( "Starting Test_task 1 (local)" );
status = rtems_task_start( Task_id[ 1 ], Test_task1, 0 );
directive_failed( status, "rtems_task_start" );
puts( "Creating Test_task 2 (local)" );
status = rtems_task_create(
Task_name[ 2 ],
1,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_TIMESLICE,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[ 2 ]
);
directive_failed( status, "rtems_task_create" );
puts( "Starting Test_task 2 (local)" );
status = rtems_task_start( Task_id[ 2 ], Test_task2, 0 );
directive_failed( status, "rtems_task_start" );
if ( Multiprocessing_configuration.node == 1 ) {
status = rtems_task_wake_after( 5 * TICKS_PER_SECOND );
directive_failed( status, "rtems_task_wake_after" );
puts( "*** END OF TEST 13 ***" );
rtems_test_exit( 0 );
}
puts( "Deleting initialization task" );
status = rtems_task_delete( RTEMS_SELF );
directive_failed( status, "rtems_task_delete of RTEMS_SELF" );
}
rtems_task Task_1(
rtems_task_argument argument
)
{
rtems_id rnid;
void *segment_address_1;
void *segment_address_2;
void *segment_address_3;
void *segment_address_4;
rtems_status_code status;
status = rtems_region_ident( Region_name[ 1 ], &rnid );
printf( "TA1 - rtems_region_ident - rnid => %08" PRIxrtems_id "\n", rnid );
directive_failed( status, "rtems_region_ident of RN1" );
puts(
"TA1 - rtems_region_get_segment - wait on 100 byte segment from region 2"
);
status = rtems_region_get_segment(
Region_id[ 2 ],
100,
RTEMS_DEFAULT_OPTIONS,
RTEMS_NO_TIMEOUT,
&segment_address_1
);
directive_failed( status, "rtems_region_get_segment" );
puts_nocr( "TA1 - got segment from region 2 - " );
Put_address_from_area_2( segment_address_1 );
new_line;
puts( "TA1 - rtems_region_get_segment - wait on 3K segment from region 3" );
status = rtems_region_get_segment(
Region_id[ 3 ],
3072,
RTEMS_DEFAULT_OPTIONS,
RTEMS_NO_TIMEOUT,
&segment_address_2
);
directive_failed( status, "rtems_region_get_segment" );
puts_nocr( "TA1 - got segment from region 3 - " );
Put_address_from_area_3( segment_address_2 );
new_line;
puts_nocr( "TA1 - rtems_region_get_segment - get 3080 byte segment " );
puts ( "from region 1 - NO_WAIT" );
status = rtems_region_get_segment(
Region_id[ 1 ],
3080,
RTEMS_NO_WAIT,
RTEMS_NO_TIMEOUT,
&segment_address_3
);
directive_failed( status, "rtems_region_get_segment" );
puts_nocr( "TA1 - got segment from region 1 - " );
Put_address_from_area_1( segment_address_3 );
new_line;
puts( "TA1 - rtems_task_wake_after - yield processor" );
status = rtems_task_wake_after( RTEMS_YIELD_PROCESSOR );
directive_failed( status, "rtems_task_wake_after" );
rtems_test_pause();
puts_nocr(
"TA1 - rtems_region_return_segment - return segment to region 1 - "
);
Put_address_from_area_1( segment_address_3 );
status = rtems_region_return_segment( Region_id[ 1 ], segment_address_3 );
directive_failed( status, "rtems_region_return_segment" );
new_line;
puts(
"TA1 - rtems_region_get_segment - wait 10 seconds for 3K "
"segment from region 1"
);
status = rtems_region_get_segment(
Region_id[ 1 ],
3072,
RTEMS_DEFAULT_OPTIONS,
10 * rtems_clock_get_ticks_per_second(),
&segment_address_4
);
directive_failed( status, "rtems_region_get_segment" );
puts_nocr( "TA1 - got segment from region 1 - " );
Put_address_from_area_1( segment_address_4 );
new_line;
puts_nocr(
"TA1 - rtems_region_return_segment - return segment to region 2 - "
);
Put_address_from_area_2( segment_address_1 );
new_line;
status = rtems_region_return_segment( Region_id[ 2 ], segment_address_1 );
directive_failed( status, "rtems_region_return_segment" );
puts( "TA1 - rtems_task_wake_after - yield processor" );
status = rtems_task_wake_after( RTEMS_YIELD_PROCESSOR );
directive_failed( status, "rtems_task_wake_after" );
puts( "TA1 - rtems_task_delete - delete TA3" );
status = rtems_task_delete( Task_id[ 3 ] );
directive_failed( status, "rtems_task_delete of TA3" );
rtems_test_pause();
status = rtems_task_create(
Task_name[ 4 ],
BASE_PRIORITY,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[ 4 ]
);
directive_failed( status, "rtems_task_create of TA4" );
status = rtems_task_create(
Task_name[ 5 ],
BASE_PRIORITY,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[ 5 ]
);
directive_failed( status, "rtems_task_create of TA5" );
status = rtems_task_start( Task_id[ 4 ], Task_4, 0 );
directive_failed( status, "rtems_task_start of TA4" );
status = rtems_task_start( Task_id[ 5 ], Task5, 0 );
directive_failed( status, "rtems_task_start of TA5" );
puts( "TA1 - rtems_task_wake_after - yield processor" );
status = rtems_task_wake_after( 1 * rtems_clock_get_ticks_per_second() );
directive_failed( status, "rtems_task_wake_after" );
puts_nocr(
"TA1 - rtems_region_return_segment - return segment to region 1 - "
);
Put_address_from_area_1( segment_address_4 );
status = rtems_region_return_segment( Region_id[ 1 ], segment_address_4 );
directive_failed( status, "rtems_region_return_segment" );
new_line;
puts( "TA1 - rtems_task_wake_after - yield processor" );
status = rtems_task_wake_after( 1 * rtems_clock_get_ticks_per_second() );
directive_failed( status, "rtems_task_wake_after" );
puts_nocr( "TA1 - rtems_region_get_segment - wait 10 seconds for 3K " );
puts ( "segment from region 1");
status = rtems_region_get_segment(
Region_id[ 1 ],
3072,
RTEMS_DEFAULT_OPTIONS,
10 * rtems_clock_get_ticks_per_second(),
&segment_address_4
);
directive_failed( status, "rtems_region_get_segment" );
puts_nocr( "TA1 - got segment from region 1 - " );
Put_address_from_area_1( segment_address_4 );
new_line;
puts( "TA1 - rtems_task_wake_after - yield processor" );
status = rtems_task_wake_after( 1 * rtems_clock_get_ticks_per_second() );
directive_failed( status, "rtems_task_wake_after" );
puts( "TA1 - rtems_task_delete - delete TA4" );
status = rtems_task_delete( Task_id[ 4 ] );
directive_failed( status, "rtems_task_delete of TA4" );
puts_nocr(
"TA1 - rtems_region_return_segment - return segment to region 1 - "
);
Put_address_from_area_1( segment_address_4 );
status = rtems_region_return_segment( Region_id[ 1 ], segment_address_4 );
directive_failed( status, "rtems_region_return_segment" );
new_line;
puts( "TA1 - rtems_task_wake_after - yield processor" );
status = rtems_task_wake_after( RTEMS_YIELD_PROCESSOR );
puts( "TA1 - rtems_region_delete - delete region 1" );
status = rtems_region_delete( Region_id[ 1 ] );
directive_failed( status, "rtems_region_delete" );
puts( "TA1 - rtems_region_get_segment - get 3K segment from region 4" );
status = rtems_region_get_segment(
Region_id[ 4 ],
3072,
RTEMS_DEFAULT_OPTIONS,
RTEMS_NO_TIMEOUT,
&segment_address_1
);
directive_failed( status, "rtems_region_get_segment" );
puts_nocr( "TA1 - got segment from region 4 - " );
Put_address_from_area_4( segment_address_1 );
new_line;
puts(
"TA1 - rtems_region_get_segment - attempt to get 3K segment from region 4"
);
status = rtems_region_get_segment(
Region_id[ 4 ],
3072,
RTEMS_NO_WAIT,
RTEMS_NO_TIMEOUT,
&segment_address_2
);
fatal_directive_status(
status,
RTEMS_UNSATISFIED,
"rtems_region_get_segment with no memory left"
);
puts( "TA1 - rtems_region_get_segment - RTEMS_UNSATISFIED" );
puts( "TA1 - rtems_region_extend - extend region 4 by 1" );
status = rtems_region_extend(
Region_id[ 4 ],
&Area_4[4096],
1
);
fatal_directive_status(
status,
RTEMS_INVALID_ADDRESS,
"rtems_region_extend with too small memory area"
);
puts( "TA1 - rtems_region_extend - RTEMS_INVALID_ADDRESS" );
puts( "TA1 - rtems_region_extend - extend region 4 by 4K - 1" );
status = rtems_region_extend(
Region_id[ 4 ],
(char *) &Area_4[4096] + 1,
4096 - 1
);
directive_failed( status, "rtems_region_extend" );
puts(
"TA1 - rtems_region_get_segment - attempt to get 3K segment from region 4"
);
status = rtems_region_get_segment(
Region_id[ 4 ],
3072,
RTEMS_NO_WAIT,
RTEMS_NO_TIMEOUT,
&segment_address_3
);
directive_failed( status, "rtems_region_get_segment" );
puts_nocr( "TA1 - got 3K segment from region 4 - " );
Put_address_from_area_4( segment_address_3 );
new_line;
puts_nocr(
"TA1 - rtems_region_return_segment - return segment to region 4 - "
);
Put_address_from_area_4( segment_address_1 );
status = rtems_region_return_segment( Region_id[ 4 ], segment_address_1 );
directive_failed( status, "rtems_region_return_segment" );
new_line;
puts_nocr(
"TA1 - rtems_region_return_segment - return segment to region 4 - "
);
Put_address_from_area_4( segment_address_3 );
status = rtems_region_return_segment( Region_id[ 4 ], segment_address_3 );
directive_failed( status, "rtems_region_return_segment" );
new_line;
puts( "TA1 - rtems_region_delete - delete region 4" );
status = rtems_region_delete( Region_id[ 4 ] );
directive_failed( status, "rtems_region_delete" );
puts( "*** END OF TEST 16 ***" );
rtems_test_exit( 0 );
}
rtems_task Init(
rtems_task_argument argument
)
{
rtems_status_code status;
printf(
"\n\n*** TEST 10 -- NODE %d ***\n",
Multiprocessing_configuration.node
);
Task_name[ 1 ] = rtems_build_name( 'T', 'A', '1', ' ' );
Task_name[ 2 ] = rtems_build_name( 'T', 'A', '2', ' ' );
Task_name[ 3 ] = rtems_build_name( 'S', 'A', '3', ' ' );
Queue_name[ 1 ] = rtems_build_name( 'M', 'S', 'G', ' ' );
Semaphore_name[ 1 ] = rtems_build_name( 'S', 'E', 'M', ' ' );
if ( Multiprocessing_configuration.node == 1 ) {
puts( "Creating Message Queue (Global)" );
status = rtems_message_queue_create(
Queue_name[ 1 ],
3,
16,
RTEMS_GLOBAL,
&Queue_id[ 1 ]
);
directive_failed( status, "rtems_message_queue_create" );
puts( "Creating Semaphore (Global)" );
status = rtems_semaphore_create(
Semaphore_name[ 1 ],
0,
RTEMS_GLOBAL | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&Semaphore_id[ 1 ]
);
directive_failed( status, "rtems_semaphore_create" );
status = rtems_task_wake_after( 10 * TICKS_PER_SECOND );
directive_failed( status, "rtems_task_wake_after" );
} else {
puts( "Creating Test_task 1 (local)" );
status = rtems_task_create(
Task_name[ 1 ],
1,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_TIMESLICE,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[ 1 ]
);
directive_failed( status, "rtems_task_create" );
puts( "Starting Test_task 1 (local)" );
status = rtems_task_start( Task_id[ 1 ], Test_task1, 0 );
directive_failed( status, "rtems_task_start" );
puts( "Creating Test_task 2 (local)" );
status = rtems_task_create(
Task_name[ 2 ],
1,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_TIMESLICE,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[ 2 ]
);
directive_failed( status, "rtems_task_create" );
puts( "Starting Test_task 2 (local)" );
status = rtems_task_start( Task_id[ 2 ], Test_task2, 0 );
directive_failed( status, "rtems_task_start" );
puts( "Creating Test_task 3 (local)" );
status = rtems_task_create(
Task_name[ 3 ],
1,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_TIMESLICE,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[ 3 ]
);
directive_failed( status, "rtems_task_create" );
puts( "Starting Test_task 3 (local)" );
status = rtems_task_start( Task_id[ 3 ], Test_task2, 0 );
directive_failed( status, "rtems_task_start" );
puts( "Sleeping for 1 seconds ..." );
status = rtems_task_wake_after( TICKS_PER_SECOND );
directive_failed( status, "rtems_task_wake_after" );
puts( "Deleting Test_task2" );
status = rtems_task_delete( Task_id[ 2 ] );
directive_failed( status, "rtems_task_delete of Task 2" );
puts( "Deleting Test_task1" );
status = rtems_task_delete( Task_id[ 1 ] );
directive_failed( status, "rtems_task_delete of Task 1" );
puts( "Restarting Test_task3" );
status = rtems_task_restart( Task_id[ 3 ], 1 );
directive_failed( status, "rtems_task_restart of Task 3" );
}
puts( "*** END OF TEST 10 ***" );
rtems_test_exit( 0 );
}
static void test_task_get_set_scheduler(void)
{
rtems_status_code sc;
rtems_id self_id = rtems_task_self();
rtems_name name = BLUE;
rtems_id scheduler_id;
rtems_id scheduler_by_name;
rtems_id task_id;
rtems_id mtx_id;
sc = rtems_scheduler_ident(name, &scheduler_by_name);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_get_scheduler(RTEMS_SELF, NULL);
rtems_test_assert(sc == RTEMS_INVALID_ADDRESS);
sc = rtems_task_get_scheduler(invalid_id, &scheduler_id);
rtems_test_assert(sc == RTEMS_INVALID_ID);
scheduler_id = 0;
sc = rtems_task_get_scheduler(RTEMS_SELF, &scheduler_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(scheduler_id == scheduler_by_name);
scheduler_id = 0;
sc = rtems_task_get_scheduler(self_id, &scheduler_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(scheduler_id == scheduler_by_name);
sc = rtems_task_set_scheduler(invalid_id, scheduler_id, 1);
rtems_test_assert(sc == RTEMS_INVALID_ID);
sc = rtems_task_set_scheduler(self_id, invalid_id, 1);
rtems_test_assert(sc == RTEMS_INVALID_ID);
sc = rtems_task_set_scheduler(self_id, scheduler_id, UINT32_C(0x80000000));
rtems_test_assert(sc == RTEMS_INVALID_PRIORITY);
sc = rtems_task_set_scheduler(self_id, scheduler_id, 1);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_semaphore_create(
rtems_build_name(' ', 'M', 'T', 'X'),
0,
RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY,
0,
&mtx_id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_set_scheduler(self_id, scheduler_id, 1);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_semaphore_release(mtx_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(set_prio(self_id, RTEMS_CURRENT_PRIORITY) == 1);
sc = rtems_task_set_scheduler(self_id, scheduler_id, 2);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(set_prio(self_id, RTEMS_CURRENT_PRIORITY) == 2);
sc = rtems_task_set_scheduler(self_id, scheduler_id, 1);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(set_prio(self_id, RTEMS_CURRENT_PRIORITY) == 1);
sc = rtems_semaphore_delete(mtx_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_create(
rtems_build_name('T', 'A', 'S', 'K'),
2,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task_id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
scheduler_id = 0;
sc = rtems_task_get_scheduler(task_id, &scheduler_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(scheduler_id == scheduler_by_name);
sc = rtems_task_set_scheduler(task_id, scheduler_id, 2);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_start(task_id, forbidden_task, 0);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_set_scheduler(task_id, scheduler_id, 2);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_delete(task_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_create(
rtems_build_name('T', 'A', 'S', 'K'),
2,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task_id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_start(task_id, restart_task, 0);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_suspend(self_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_delete(task_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_semaphore_create(
rtems_build_name('S', 'E', 'M', 'A'),
0,
RTEMS_COUNTING_SEMAPHORE,
0,
&sema_id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_create(
rtems_build_name('T', 'A', 'S', 'K'),
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, sema_task, 0);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_wake_after(RTEMS_YIELD_PROCESSOR);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_set_scheduler(task_id, scheduler_id, 1);
rtems_test_assert(sc == RTEMS_RESOURCE_IN_USE);
sc = rtems_semaphore_delete(sema_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_delete(task_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
rtems_task Task_Periodic(
rtems_task_argument argument
)
{
rtems_id rmid;
rtems_status_code status;
time_t approved_budget, exec_time, abs_time, remaining_budget;
int start, stop, now;
rtems_cbs_server_id server_id = 0, tsid;
rtems_cbs_parameters params, tparams;
params.deadline = Period;
params.budget = Execution+1;
/* Taks 1 will be attached to a server, task 2 not. */
if ( argument == 1 ) {
printf( "Periodic task: Create server and Attach thread\n" );
if ( rtems_cbs_create_server( ¶ms, NULL, &server_id ) )
printf( "ERROR: CREATE SERVER FAILED\n" );
if ( rtems_cbs_attach_thread( server_id, Task_id ) )
printf( "ERROR: ATTACH THREAD FAILED\n" );
printf( "Periodic task: ID and Get parameters\n" );
if ( rtems_cbs_get_server_id( Task_id, &tsid ) )
printf( "ERROR: GET SERVER ID FAILED\n" );
if ( tsid != server_id )
printf( "ERROR: SERVER ID MISMATCH\n" );
if ( rtems_cbs_get_parameters( server_id, &tparams ) )
printf( "ERROR: GET PARAMETERS FAILED\n" );
if ( params.deadline != tparams.deadline ||
params.budget != tparams.budget )
printf( "ERROR: PARAMETERS MISMATCH\n" );
printf( "Periodic task: Detach thread and Destroy server\n" );
if ( rtems_cbs_detach_thread( server_id, Task_id ) )
printf( "ERROR: DETACH THREAD FAILED\n" );
if ( rtems_cbs_destroy_server( server_id ) )
printf( "ERROR: DESTROY SERVER FAILED\n" );
if ( rtems_cbs_create_server( ¶ms, NULL, &server_id ) )
printf( "ERROR: CREATE SERVER FAILED\n" );
printf( "Periodic task: Remaining budget and Execution time\n" );
if ( rtems_cbs_get_remaining_budget( server_id, &remaining_budget ) )
printf( "ERROR: GET REMAINING BUDGET FAILED\n" );
if ( remaining_budget != params.budget )
printf( "ERROR: REMAINING BUDGET MISMATCH\n" );
if ( rtems_cbs_get_execution_time( server_id, &exec_time, &abs_time ) )
printf( "ERROR: GET EXECUTION TIME FAILED\n" );
printf( "Periodic task: Set parameters\n" );
if ( rtems_cbs_attach_thread( server_id, Task_id ) )
printf( "ERROR: ATTACH THREAD FAILED\n" );
params.deadline = Period * 2;
params.budget = Execution * 2 +1;
if ( rtems_cbs_set_parameters( server_id, ¶ms ) )
printf( "ERROR: SET PARAMS FAILED\n" );
if ( rtems_cbs_get_parameters( server_id, &tparams ) )
printf( "ERROR: GET PARAMS FAILED\n" );
if ( params.deadline != tparams.deadline ||
params.budget != tparams.budget )
printf( "ERROR: PARAMS MISMATCH\n" );
params.deadline = Period;
params.budget = Execution+1;
if ( rtems_cbs_set_parameters( server_id, ¶ms ) )
printf( "ERROR: SET PARAMS FAILED\n" );
if ( rtems_cbs_get_approved_budget( server_id, &approved_budget ) )
printf( "ERROR: GET APPROVED BUDGET FAILED\n" );
printf( "Periodic task: Approved budget\n" );
if ( approved_budget != params.budget )
printf( "ERROR: APPROVED BUDGET MISMATCH\n" );
}
status = rtems_rate_monotonic_create( argument, &rmid );
directive_failed( status, "rtems_rate_monotonic_create" );
/* Starting periodic behavior of the task */
printf( "Periodic task: Starting periodic behavior\n" );
status = rtems_task_wake_after( 1 + Phase );
directive_failed( status, "rtems_task_wake_after" );
while ( FOREVER ) {
if ( rtems_rate_monotonic_period(rmid, Period) == RTEMS_TIMEOUT )
printf( "P%" PRIdPTR " - Deadline miss\n", argument );
start = rtems_clock_get_ticks_since_boot();
printf( "P%" PRIdPTR "-S ticks:%d\n", argument, start );
if ( start > 4*Period+Phase ) break; /* stop */
/* active computing */
while(FOREVER) {
now = rtems_clock_get_ticks_since_boot();
if ( now >= start + Execution ) break;
if ( server_id != 0 ) {
if ( rtems_cbs_get_execution_time( server_id, &exec_time, &abs_time ) )
printf( "ERROR: GET EXECUTION TIME FAILED\n" );
if ( rtems_cbs_get_remaining_budget( server_id, &remaining_budget) )
printf( "ERROR: GET REMAINING BUDGET FAILED\n" );
if ( (remaining_budget + exec_time) > (Execution + 1) ) {
printf( "ERROR: REMAINING BUDGET AND EXECUTION TIME MISMATCH\n" );
rtems_test_exit( 0 );
}
}
}
stop = rtems_clock_get_ticks_since_boot();
printf( "P%" PRIdPTR "-F ticks:%d\n", argument, stop );
}
/* delete period and SELF */
status = rtems_rate_monotonic_delete( rmid );
if ( status != RTEMS_SUCCESSFUL ) {
printf("rtems_rate_monotonic_delete failed with status of %d.\n", status);
rtems_test_exit( 0 );
}
printf( "Periodic task: Deleting self\n" );
status = rtems_task_delete( RTEMS_SELF );
directive_failed( status, "rtems_task_delete of RTEMS_SELF" );
}
