rtems_task Task01( rtems_task_argument ignored )
{
rtems_status_code status;
/* Start up TA02, yield so it can run */
if ( sem_exe == 0 ) {
status = rtems_task_start( Task_id[1], Task02, 0 );
directive_failed( status, "rtems_task_start of TA02" );
} else {
status = rtems_task_restart( Task_id[1], 0 );
directive_failed( status, "rtems_task_restart of TA02" );
}
rtems_task_wake_after( RTEMS_YIELD_PROCESSOR );
/* Benchmark code */
for ( ; count < BENCHMARKS ; ) {
if ( sem_exe == 1 ) {
rtems_semaphore_obtain( sem_id, RTEMS_WAIT, 0 );
}
rtems_task_wake_after( RTEMS_YIELD_PROCESSOR );
if ( sem_exe == 1 ) {
rtems_semaphore_release( sem_id );
}
rtems_task_wake_after( RTEMS_YIELD_PROCESSOR );
}
/* Should never reach here */
rtems_test_assert( false );
}
void test_init(void)
{
rtems_status_code status;
rtems_task_entry task_entry;
rtems_task_priority priority;
uint32_t index;
priority = RTEMS_MAXIMUM_PRIORITY - 1;
if ( OPERATION_COUNT > RTEMS_MAXIMUM_PRIORITY - 2 )
operation_count = RTEMS_MAXIMUM_PRIORITY - 2;
for( index = 0; index <= operation_count ; index++ ) {
status = rtems_task_create(
rtems_build_name( 'T', 'I', 'M', 'E' ),
priority,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[ index ]
);
directive_failed( status, "rtems_task_create loop" );
priority--;
if ( index==0 ) task_entry = Low_task;
else if ( index==operation_count ) task_entry = High_task;
else task_entry = Middle_tasks;
status = rtems_task_start( Task_id[ index ], task_entry, 0 );
directive_failed( status, "rtems_task_start loop" );
}
}
static void Init(rtems_task_argument arg)
{
uint32_t self = rtems_get_current_processor();
uint32_t cpu_count = rtems_get_processor_count();
rtems_test_begink();
main_cpu = self;
if (cpu_count >= CPU_COUNT) {
rtems_status_code sc;
rtems_id id;
sc = rtems_task_create(
rtems_build_name( 'W', 'A', 'I', 'T' ),
1,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&id
);
assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_start(id, acquire_giant_and_fatal_task, 0);
assert(sc == RTEMS_SUCCESSFUL);
wait_for_giant();
} else {
rtems_test_endk();
exit(0);
}
}
void test_init(void)
{
rtems_id id;
rtems_task_entry task_entry;
uint32_t index;
rtems_status_code status;
for ( index = 0 ; index <= OPERATION_COUNT ; index++ ) {
status = rtems_task_create(
rtems_build_name( 'T', 'I', 'M', 'E' ),
(RTEMS_MAXIMUM_PRIORITY / 2u) + 1u,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&id
);
directive_failed( status, "rtems_task_create loop" );
if ( index == OPERATION_COUNT ) task_entry = Last_task;
else if ( index == 0 ) task_entry = First_task;
else task_entry = Middle_tasks;
status = rtems_task_start( id, task_entry, 0 );
directive_failed( status, "rtems_task_start loop" );
}
}
static void start_validate_task(
rtems_id *id,
uintptr_t pattern,
rtems_task_priority priority,
bool fp_unit
)
{
rtems_status_code sc;
rtems_attribute fpu_state;
fpu_state = fp_unit ? RTEMS_FLOATING_POINT : RTEMS_DEFAULT_ATTRIBUTES;
sc = rtems_task_create(
rtems_build_name('V', 'A', 'L', 'I'),
priority,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
fpu_state,
id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_start(*id, validate_task, pattern);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
void test_delete_as_side_effect(void)
{
rtems_status_code sc;
rtems_id deleter_task;
test_dtor_ran = 0;
sc = rtems_task_create(rtems_build_name ('O', 'T', 'H', 'R'),
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,
&deleter_task
);
directive_failed( sc, "task create deleter" );
sc = rtems_task_start(deleter_task, Task_variable_deleter, 0);
directive_failed( sc, "task start deleter" );
rtems_task_wake_after( 100 );
if ( test_dtor_ran != 2 ) {
printf(
"Test dtor ran %" PRIu32 " times not 2 times as expected\n",
test_dtor_ran
);
rtems_test_exit(0);
}
}
rtems_task Init(
rtems_task_argument argument
)
{
rtems_status_code status;
printf(
"\n\n*** TEST 4 -- NODE %" PRId32 " ***\n",
Multiprocessing_configuration.node
);
Task_name[ 1 ] = rtems_build_name( '1', '1', '1', ' ' );
Task_name[ 2 ] = rtems_build_name( '2', '2', '2', ' ' );
puts( "Creating Test_task (Global)" );
status = rtems_task_create(
Task_name[ Multiprocessing_configuration.node ],
Multiprocessing_configuration.node,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_GLOBAL,
&Task_id[ 1 ]
);
directive_failed( status, "rtems_task_create" );
puts( "Starting Test_task (Global)" );
status = rtems_task_start( Task_id[ 1 ], Test_task, 0 );
directive_failed( status, "rtems_task_start" );
puts( "Deleting initialization task" );
status = rtems_task_delete( RTEMS_SELF );
directive_failed( status, "rtems_task_delete of RTEMS_SELF" );
}
static rtems_id create_task(
char name,
rtems_task_entry entry,
uart_bridge_master_control *control
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_id task = RTEMS_ID_NONE;
char index = (char) ('0' + control->type - INTERCOM_TYPE_UART_0);
sc = rtems_task_create(
rtems_build_name('U', 'B', name, index),
QORIQ_UART_BRIDGE_TASK_PRIORITY,
0,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task
);
assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_start(
task,
entry,
(rtems_task_argument) control
);
assert(sc == RTEMS_SUCCESSFUL);
return task;
}
rtems_task Init(
rtems_task_argument argument
)
{
rtems_status_code status;
puts( "\n\n*** TEST 21 ***" );
Task_name[ 1 ] = rtems_build_name( 'T', 'A', '1', ' ' );
status = rtems_task_create(
Task_name[ 1 ],
1,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[ 1 ]
);
directive_failed( status, "rtems_task_create of TA1" );
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 ignored
)
{
rtems_status_code status;
rtems_id task_id;
puts( "\n\n*** TEST 57 ***" );
puts( "Init - rtems_task_create - delay task - OK" );
status = rtems_task_create(
rtems_build_name( 'T', 'A', '1', ' ' ),
1,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_OPTIONS,
RTEMS_DEFAULT_ATTRIBUTES,
&task_id
);
directive_failed( status, "rtems_task_create" );
puts( "Init - rtems_task_start - delay task - OK" );
status = rtems_task_start( task_id, Delay_task, 0 );
directive_failed( status, "rtems_task_start" );
puts( "Init - rtems_task_wake_after - let delay task block - OK" );
status = rtems_task_wake_after( RTEMS_MILLISECONDS_TO_TICKS(1000) );
directive_failed( status, "rtems_task_wake_after" );
puts( "Init - rtems_task_restart - delay task - OK" );
status = rtems_task_restart( task_id, 0 );
directive_failed( status, "rtems_task_restart" );
puts( "*** END OF TEST 57 ***" );
rtems_test_exit(0);
}
static void start_task(rtems_id id, rtems_task_entry entry)
{
rtems_status_code sc;
sc = rtems_task_start(id, entry, 0);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
static void test_with_request_server(void)
{
rtems_status_code sc;
rtems_id id;
request req;
sc = rtems_event_transient_receive(RTEMS_NO_WAIT, 0);
rtems_test_assert(sc == RTEMS_UNSATISFIED);
req.client = rtems_task_self();
req.complete = false;
sc = rtems_task_create(
rtems_build_name('S', 'E', 'R', 'V'),
1,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_start(id, server_task, (rtems_task_argument) &req);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_event_transient_receive(RTEMS_WAIT, RTEMS_NO_TIMEOUT);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(req.complete);
}
/* Task01 starts with priority 36 */
rtems_task Task01(rtems_task_argument ignored)
{
rtems_status_code status;
printf("TA01: started with priority %d\n", getprio());
status = rtems_semaphore_obtain( sem_id[0], RTEMS_WAIT, 0 );
directive_failed( status, "rtems_semaphore_obtain of S0\n");
printf("TA01: priority %d, holding S0\n", getprio());
status = rtems_semaphore_obtain( sem_id[1], RTEMS_WAIT, 0 );
directive_failed( status, "rtems_semaphore_obtain of S1");
printf("TA01: priority %d, holding S0, S1\n", getprio());
/* Start Task 2 (TA02) with priority 34. It will run immediately. */
status = rtems_task_start( Task_id[1], Task02, 0);
directive_failed( status, "rtems_task_start of TA02\n");
status = rtems_semaphore_release(sem_id[1]);
directive_failed( status, "rtems_semaphore_release of S1\n");
printf("TA01: priority %d, holding S0\n", getprio());
status = rtems_semaphore_release(sem_id[0]);
directive_failed( status, "rtems_semaphore_release of S0\n");
printf("TA01: priority %d\n", getprio());
printf("TA01: exiting\n");
printf("*** END OF SEM01 ***\n");
status = rtems_task_delete( RTEMS_SELF);
directive_failed( status, "rtems_task_delete TA01");
}
static void
setThreadInfo(rtems_id tid, const char *name, EPICSTHREADFUNC funptr,
void *parm)
{
struct taskVar *v;
uint32_t note;
rtems_status_code sc;
v = mallocMustSucceed (sizeof *v, "epicsThreadCreate_vars");
v->name = epicsStrDup(name);
v->id = tid;
v->funptr = funptr;
v->parm = parm;
v->threadVariableCapacity = 0;
v->threadVariables = NULL;
note = (uint32_t)v;
rtems_task_set_note (tid, RTEMS_NOTEPAD_TASKVAR, note);
taskVarLock ();
v->forw = taskVarHead;
v->back = NULL;
if (v->forw)
v->forw->back = v;
taskVarHead = v;
taskVarUnlock ();
if (funptr) {
sc = rtems_task_start (tid, threadWrapper, (rtems_task_argument)v);
if (sc != RTEMS_SUCCESSFUL)
errlogPrintf ("setThreadInfo: Can't start %s: %s\n",
name, rtems_status_text(sc));
}
}
rtems_task init_task(
rtems_task_argument ignored
)
{
rtems_id tid;
rtems_status_code status;
rtems_name name;
name = rtems_build_name( ’A’, ’P’, ’P’, ’1’ )
status = rtems_task_create(
name, 1, RTEMS_MINIMUM_STACK_SIZE,
RTEMS_NO_PREEMPT, RTEMS_FLOATING_POINT, &tid
);
if ( status != RTEMS_STATUS_SUCCESSFUL ) {
printf( "rtems_task_create failed with status of %d.\n", status );
exit( 1 );
}
status = rtems_task_start( tid, user_application, 0 );
if ( status != RTEMS_STATUS_SUCCESSFUL ) {
printf( "rtems_task_start failed with status of %d.\n", status );
exit( 1 );
}
status = rtems_task_delete( SELF );
/* should not return */
printf( "rtems_task_delete returned with status of %d.\n", status );
exit( 1 );
}
static void start_task(
test_context *ctx,
task_id id,
rtems_task_entry entry,
rtems_task_priority prio,
rtems_name scheduler
)
{
rtems_status_code sc;
rtems_id scheduler_id;
sc = rtems_task_create(
rtems_build_name('T', 'A', 'S', 'K'),
prio,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&ctx->tasks[id]
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_scheduler_ident(scheduler, &scheduler_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_set_scheduler(ctx->tasks[id], scheduler_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_start(ctx->tasks[id], entry, id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
void Init(
rtems_task_argument argument
)
{
rtems_status_code status;
rtems_id id;
Print_Warning();
puts( "\n\n*** TIME TEST 13 ***" );
status = rtems_task_create(
1,
RTEMS_MAXIMUM_PRIORITY - 1u,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&id
);
directive_failed( status, "rtems_task_create" );
status = rtems_task_start( id, test_init, 0 );
directive_failed( status, "rtems_task_start" );
status = rtems_task_delete( RTEMS_SELF );
directive_failed( status, "rtems_task_delete of RTEMS_SELF" );
}
rtems_task Init(
rtems_task_argument argument
)
{
rtems_status_code status;
rtems_id task_id;
puts( "\n\n*** TEST @UPPER@ ***" );
status = rtems_task_create(
rtems_build_name( 'T', 'E', 'S', 'T' ),
1,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task_id
);
directive_failed( status, "rtems_task_create" );
status = rtems_task_start( task_id, Test_task, 0 );
directive_failed( status, "rtems_task_start" );
puts( "*** END OF TEST @UPPER@ ***" );
rtems_test_exit(0);
}
rtems_task Init(
rtems_task_argument argument
)
{
rtems_status_code status;
rtems_id task_id;
Print_Warning();
TEST_BEGIN();
status = rtems_task_create(
rtems_build_name( 'T', 'A', '1', ' ' ),
RTEMS_MAXIMUM_PRIORITY - 1u,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task_id
);
directive_failed( status, "rtems_task_create of test_init" );
status = rtems_task_start( task_id, test_init, 0 );
directive_failed( status, "rtems_task_start of test_init" );
status = rtems_task_delete( RTEMS_SELF );
directive_failed( status, "rtems_task_delete of RTEMS_SELF" );
}
int rtems_pppd_initialize(void)
{
int iReturn = (int)-1;
rtems_task_priority priority = 100;
rtems_status_code status;
rtems_name taskName;
/* determine priority value */
if ( rtems_bsdnet_config.network_task_priority ) {
priority = rtems_bsdnet_config.network_task_priority;
}
/* initialize the exit hook */
rtems_pppd_exitfp = (rtems_pppd_hookfunction)0;
/* create the rtems task */
taskName = rtems_build_name( 'p', 'p', 'p', 'd' );
status = rtems_task_create(taskName, priority, 8192,
(RTEMS_PREEMPT|RTEMS_NO_TIMESLICE|RTEMS_NO_ASR|RTEMS_INTERRUPT_LEVEL(0)),
RTEMS_NO_FLOATING_POINT|RTEMS_LOCAL,
&rtems_pppd_taskid);
if ( status == RTEMS_SUCCESSFUL ) {
status = rtems_task_start(rtems_pppd_taskid, pppTask, 0);
if ( status == RTEMS_SUCCESSFUL ) {
iReturn = rtems_pppd_reset_options();
}
}
return ( iReturn );
}
static void test_smp_cache_manager( void )
{
rtems_status_code sc;
size_t worker_index;
uint32_t cpu_count = rtems_get_processor_count();
for (worker_index = 1; worker_index < cpu_count; ++worker_index) {
rtems_id worker_id;
sc = rtems_task_create(
rtems_build_name('W', 'R', 'K', '0'+worker_index),
WORKER_PRIORITY,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&worker_id
);
rtems_test_assert( sc == RTEMS_SUCCESSFUL );
sc = rtems_task_start( worker_id, worker_task, 0 );
rtems_test_assert( sc == RTEMS_SUCCESSFUL );
}
all_tests();
}
/*
* Main -- entry point from RTEMS
*/
int rtems_initialize_webserver(void)
{
rtems_status_code sc;
rtems_id tid;
int priority;
/***********************************************************************
* Default HTTPD priority.
**********************************************************************/
priority = 40;
sc = rtems_task_create(rtems_build_name('H', 'T', 'P', 'D'),
priority, 8*1024,
RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR |
RTEMS_INTERRUPT_LEVEL(0),
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tid);
if (sc != RTEMS_SUCCESSFUL)
{
return(RTEMS_UNSATISFIED);
}
sc = rtems_task_start(tid, rtems_httpd_daemon, 0);
if (sc != RTEMS_SUCCESSFUL)
{
return(RTEMS_UNSATISFIED);
}
return(RTEMS_SUCCESSFUL);
}
void test_delete_from_other_task(void)
{
rtems_status_code sc;
test_dtor_ran = 0;
sc = rtems_task_ident( RTEMS_SELF, 0, &main_task );
directive_failed( sc, "task ident" );
sc = rtems_task_variable_add(RTEMS_SELF, (void **)&taskvar1, test_dtor);
directive_failed( sc, "add for other task case" );
sc = rtems_task_create(rtems_build_name ('O', 'T', 'H', 'R'),
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,
&other_task
);
directive_failed( sc, "task create other" );
sc = rtems_task_start(other_task, Other_Task, 0);
directive_failed( sc, "task start other" );
rtems_task_wake_after( 100 );
if ( test_dtor_ran != 1 ) {
printf(
"Test dtor ran %" PRIu32 " times not 1 times as expected\n",
test_dtor_ran
);
rtems_test_exit(0);
}
}
rtems_task Init(
rtems_task_argument argument
)
{
rtems_status_code status;
Print_Warning();
TEST_BEGIN();
status = rtems_task_create(
1,
(RTEMS_MAXIMUM_PRIORITY / 2u) + 1u,
RTEMS_MINIMUM_STACK_SIZE * 2,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[ 1 ]
);
directive_failed( status, "rtems_task_create" );
status = rtems_task_start( Task_id[ 1 ], Test_task, 0 );
directive_failed( status, "rtems_task_start" );
status = rtems_task_delete( RTEMS_SELF );
directive_failed( status, "rtems_task_delete of RTEMS_SELF" );
}
rtems_task Init(
rtems_task_argument argument
)
{
rtems_status_code status;
Print_Warning();
puts( "\n\n*** TIME TEST 1 ***" );
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 ],
(RTEMS_MAXIMUM_PRIORITY / 2u) + 1u,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[ 1 ]
);
directive_failed( status, "rtems_task_create of TA1" );
status = rtems_task_start( Task_id[ 1 ], Test_task, 0 );
directive_failed( status, "rtems_task_start of TA1" );
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;
rtems_id scheduler_b_id;
rtems_id task_id;
sc = rtems_scheduler_ident(SCHEDULER_B, &scheduler_b_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_create(
SCHEDULER_B,
1,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task_id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_set_scheduler(task_id, scheduler_b_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_start(task_id, timer_task, (rtems_task_argument) ctx);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
delay_clock_tick(ctx);
sc = rtems_task_delete(task_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
static bool
bdbuf_tests_create_task (bdbuf_task_control* tc,
rtems_task_priority priority,
rtems_task_entry entry_point)
{
rtems_status_code sc;
bdbuf_test_printf ("creating task: %s: priority: %d: ",
tc->name, priority);
sc = rtems_task_create (rtems_build_name (tc->name[0], tc->name[1],
tc->name[2], tc->name[3]),
priority,
BDBUF_TEST_STACK_SIZE,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR,
&tc->task);
if (!bdbuf_test_print_sc (sc, true))
return false;
bdbuf_test_printf ("starting task: %s: ", tc->name);
sc = rtems_task_start (tc->task, entry_point, (rtems_task_argument) tc);
return bdbuf_test_print_sc (sc, true);
}
rtems_id
telnetd_dflt_spawn(const char *name, unsigned int priority, unsigned int stackSize, void (*fn)(void *), void* fnarg)
{
rtems_status_code sc;
rtems_id task_id = RTEMS_ID_NONE;
char nm[4] = {'X','X','X','X' };
struct wrap_delete_args *pwa = malloc(sizeof(*pwa));
strncpy(nm, name, 4);
if ( !pwa ) {
perror("Telnetd: no memory\n");
return RTEMS_ID_NONE;
}
pwa->t = fn;
pwa->a = fnarg;
if ((sc=rtems_task_create(
rtems_build_name(nm[0], nm[1], nm[2], nm[3]),
(rtems_task_priority)priority,
stackSize,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES | RTEMS_FLOATING_POINT,
&task_id)) ||
(sc=rtems_task_start(
task_id,
wrap_delete,
(rtems_task_argument)pwa))) {
free(pwa);
rtems_error(sc,"Telnetd: spawning task failed");
return RTEMS_ID_NONE;
}
return task_id;
}
rtems_task Init(
rtems_task_argument argument
)
{
rtems_status_code status;
rtems_id id;
puts( "\n\n*** SP74 (YIELD) TEST ***" );
puts( "Create TA1 at higher priority task" );
status = rtems_task_create(
rtems_build_name( 'T', 'A', '1', ' ' ),
1,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&id
);
directive_failed( status, "create 1" );
status = rtems_task_start( id, Test_task, 1 );
directive_failed( status, "start 1" );
puts( "Yield to TA1" );
status = rtems_task_wake_after( RTEMS_YIELD_PROCESSOR );
directive_failed( status, "yield" );
puts( "*** should now get here ***" );
}
rtems_task Init(rtems_task_argument argument)
{
rtems_status_code sc;
sc = rtems_shell_init(
"SHLL",
RTEMS_MINIMUM_STACK_SIZE * 8,
1, /* We want it to work */
"/dev/console",
false,
false,
NULL
);
if(sc != RTEMS_SUCCESSFUL)
printf("Unable to start shell (error code %d)\n", sc);
/* FIXME:
* alarm() should work anyway in gethostbyname().(for TIMEOUT in libcurl)
* in the meantime we have a workaround,
* make sure the gethostbyname() finished in 15 seconds
*/
_res.retry = 2;
/* FIXME: can this be moved into the initialization table? */
memcard_register();
/*start_memcard();*/
mkdir("/ssd", 0777);
mount("/dev/flash5", "/ssd", "yaffs", RTEMS_FILESYSTEM_READ_WRITE, "");
/*
* Older versions of RTEMS-YAFFS created the file system with the
* (persistent) root inode set to 0666. RTEMS didn't check permissions
* at that time but does now, causing most operations to fail (EACCES)
* on file systems created before the transition.
*
* The "chmod" below transparently updates the permission of /ssd files
* systems.
*/
chmod("/ssd", YAFFS_ROOT_MODE);
init_version();
load_usb_firmware();
init_videoinreconf();
sysconfig_load();
rtems_bsdnet_initialize_network();
rtems_initialize_ftpd();
rtems_telnetd_initialize();
curl_global_init(CURL_GLOBAL_ALL);
sc = rtems_task_create(rtems_build_name('G', 'U', 'I', ' '), 9, 1024*1024,
RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR,
0, &gui_task_id);
assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_start(gui_task_id, gui_task, 0);
assert(sc == RTEMS_SUCCESSFUL);
rtems_task_delete(RTEMS_SELF);
}
