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" ); }