static void switch_priorities(test_context *self) { rtems_status_code sc; size_t index = self->task_index; size_t next = (index + 1) & 0x1; size_t task_high = index; size_t task_low = next; rtems_task_priority priority; self->task_index = next; sc = rtems_task_set_priority( self->validate_tasks[task_high], PRIORITY_HIGH, &priority ); rtems_test_assert(sc == RTEMS_SUCCESSFUL); sc = rtems_task_set_priority( self->validate_tasks[task_low], PRIORITY_LOW, &priority ); rtems_test_assert(sc == RTEMS_SUCCESSFUL); }
rtems_task BlockingTasks(rtems_task_argument arg) { rtems_status_code status; rtems_task_priority opri; rtems_task_priority npri; status = rtems_task_set_priority(RTEMS_SELF, RTEMS_CURRENT_PRIORITY, &opri); directive_failed( status, "rtems_task_set_priority" ); printf( "semaphore_obtain -- BlockingTask %" PRIdrtems_task_argument " @ pri=%" PRIdrtems_task_priority ") blocks\n", arg, opri ); status = rtems_semaphore_obtain(Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); directive_failed( status, "rtems_semaphore_obtain" ); /* priority should have changed while blocked */ status = rtems_task_set_priority(RTEMS_SELF, RTEMS_CURRENT_PRIORITY, &npri); directive_failed( status, "rtems_task_set_priority" ); printf( "semaphore_obtain -- BlockingTask %" PRIdrtems_task_argument " @ pri=%" PRIdrtems_task_priority ") returns\n", arg, npri ); (void) rtems_task_delete( RTEMS_SELF ); }
static void test_create_initially_locked_prio_inherit_sema(void) { rtems_status_code sc; rtems_id id; rtems_task_priority prio_a; rtems_task_priority prio_b; rtems_task_priority prio_ceiling = 0; sc = rtems_task_set_priority(RTEMS_SELF, RTEMS_CURRENT_PRIORITY, &prio_a); rtems_test_assert(sc == RTEMS_SUCCESSFUL); rtems_test_assert(prio_a != prio_ceiling); sc = rtems_semaphore_create( rtems_build_name( 'S', 'E', 'M', 'A' ), 0, RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY, prio_ceiling, &id ); rtems_test_assert(sc == RTEMS_SUCCESSFUL); sc = rtems_task_set_priority(RTEMS_SELF, RTEMS_CURRENT_PRIORITY, &prio_b); rtems_test_assert(sc == RTEMS_SUCCESSFUL); rtems_test_assert(prio_a == prio_b); sc = rtems_semaphore_release(id); rtems_test_assert(sc == RTEMS_SUCCESSFUL); sc = rtems_semaphore_delete(id); rtems_test_assert(sc == RTEMS_SUCCESSFUL); }
/* * Test verifies priority, * Changes priority by obtaining a higher priority semaphore * Releases semaphore to return priority */ static void test(void) { rtems_status_code sc; rtems_task_priority priority; rtems_id task_sem; sc = rtems_semaphore_create( rtems_build_name('S', 'E', 'M', '0'), 1, RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_PRIORITY_CEILING, 5, &task_sem ); rtems_test_assert(sc == RTEMS_SUCCESSFUL); rtems_task_set_priority(RTEMS_SELF, RTEMS_CURRENT_PRIORITY, &priority); printf("Init: priority %d expected %d\n",(int)priority, TASK_PRIORITY ); rtems_test_assert( priority == TASK_PRIORITY ); printf("Init: Obtain Semaphore\n"); sc = rtems_semaphore_obtain (task_sem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); rtems_test_assert(sc == RTEMS_SUCCESSFUL); rtems_task_set_priority(RTEMS_SELF, RTEMS_CURRENT_PRIORITY, &priority); printf("Init: priority %d expected %d\n",(int)priority, SEM_PRIORITY ); rtems_test_assert( priority == SEM_PRIORITY ); printf("Init: Release Semaphore\n"); rtems_semaphore_release(task_sem); rtems_task_set_priority(RTEMS_SELF, RTEMS_CURRENT_PRIORITY, &priority); printf("Init: priority %d expected %d\n",(int)priority, TASK_PRIORITY ); rtems_test_assert( priority == TASK_PRIORITY ); }
rtems_task Task_2( rtems_task_argument argument ) { rtems_status_code status; rtems_task_priority the_priority; rtems_task_priority previous_priority; while( FOREVER ) { status = rtems_task_get_note( RTEMS_SELF, RTEMS_NOTEPAD_8, &the_priority ); directive_failed( status, "rtems_task_get_note" ); printf( "TA2 - rtems_task_get_note - get RTEMS_NOTEPAD_8 - current priority: %02" PRIdrtems_task_priority "\n", the_priority ); if ( --the_priority == 0 ) { puts( "TA2 - rtems_task_suspend - suspend TA1" ); status = rtems_task_suspend( Task_id[ 1 ] ); directive_failed( status, "rtems_task_suspend" ); puts( "TA2 - rtems_task_set_priority - set priority of TA1 ( blocked )" ); status = rtems_task_set_priority( Task_id[ 1 ], 5, &previous_priority ); directive_failed( status, "rtems_task_set_priority" ); status = rtems_task_delete( Task_id[ 1 ] ); /* TA1 is blocked */ directive_failed( status, "rtems_task_delete of TA1" ); status = rtems_task_delete( Task_id[ 3 ] ); /* TA3 is ready */ directive_failed( status, "rtems_task_delete of TA3" ); status = rtems_task_delete( RTEMS_SELF ); directive_failed( status, "rtems_task_delete of SELD" ); } else { printf( "TA2 - rtems_task_set_note - set TA1's RTEMS_NOTEPAD_8: %02" PRIdrtems_task_priority "\n", the_priority ); status = rtems_task_set_note(Task_id[ 1 ], RTEMS_NOTEPAD_8, the_priority); directive_failed( status, "rtems_task_set_note" ); printf( "TA2 - rtems_task_set_priority - set TA1's priority: %02" PRIdrtems_task_priority "\n", the_priority ); status = rtems_task_set_priority( Task_id[ 1 ], the_priority, &previous_priority ); directive_failed( status, "rtems_task_set_priority" ); } } }
rtems_task Task_1( rtems_task_argument argument ) { rtems_status_code status; rtems_task_priority the_priority; rtems_task_priority previous_priority; rtems_test_pause(); status = rtems_task_set_priority( RTEMS_SELF, RTEMS_CURRENT_PRIORITY, &the_priority ); directive_failed( status, "rtems_task_set_priority" ); printf( "TA1 - rtems_task_set_priority - get initial " "priority of self: %02" PRIdrtems_task_priority "\n", the_priority ); while( FOREVER ) { if ( --the_priority == 0 ) { puts( "TA1 - rtems_task_suspend - suspend TA2" ); status = rtems_task_suspend( Task_id[ 2 ] ); directive_failed( status, "rtems_task_suspend" ); puts( "TA1 - rtems_task_set_priority - set priority of TA2 ( blocked )" ); status = rtems_task_set_priority( Task_id[ 2 ], 5, &previous_priority ); directive_failed( status, "rtems_task_set_priority" ); status = rtems_task_delete( Task_id[ 2 ] ); directive_failed( status, "rtems_task_delete of TA2" ); status = rtems_task_delete( RTEMS_SELF ); directive_failed( status, "rtems_task_delete of RTEMS_SELF" ); } printf( "TA1 - rtems_task_set_priority - set TA2's priority: " "%02" PRIdrtems_task_priority "\n", the_priority ); status = rtems_task_set_priority( Task_id[ 2 ], the_priority, &previous_priority ); directive_failed( status, "rtems_task_set_priority" ); } }
rtems_task Init( rtems_task_argument argument ) { rtems_status_code status; rtems_task_priority previous_priority; TEST_BEGIN(); Task_name[ 1 ] = rtems_build_name( 'T', 'A', '1', ' ' ); Task_name[ 2 ] = rtems_build_name( 'T', 'A', '2', ' ' ); Task_name[ 3 ] = rtems_build_name( 'T', 'A', '3', ' ' ); Argument = 0; Restart_argument = 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_create( Task_name[ 2 ], 1, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &Task_id[ 2 ] ); directive_failed( status, "rtems_task_create of TA2" ); status = rtems_task_create( Task_name[ 3 ], 10, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &Task_id[ 3 ] ); directive_failed( status, "rtems_task_create of TA3" ); status = rtems_task_start( Task_id[ 1 ], Task_1, 0 ); directive_failed( status, "rtems_task_start of TA1" ); status = rtems_task_start( Task_id[ 2 ], Task_2, Argument ); directive_failed( status, "rtems_task_start of TA2" ); status = rtems_task_start( Task_id[ 3 ], Task_3, Argument ); directive_failed( status, "rtems_task_start of TA3" ); status = rtems_task_set_priority( Task_id[ 3 ], 5, &previous_priority ); status = rtems_task_delete( RTEMS_SELF ); directive_failed( status, "rtems_task_delete of RTEMS_SELF" ); }
static void initialize_ftpfs(void) { rtems_status_code sc = RTEMS_SUCCESSFUL; int rv = 0; struct timeval to = { .tv_sec = 10, .tv_usec = 0 }; const char *target = RTEMS_FTPFS_MOUNT_POINT_DEFAULT; rv = mount_and_make_target_path( NULL, target, RTEMS_FILESYSTEM_TYPE_FTPFS, RTEMS_FILESYSTEM_READ_WRITE, NULL ); rtems_test_assert(rv == 0); sc = rtems_ftpfs_set_verbose(target, true); rtems_test_assert(sc == RTEMS_SUCCESSFUL); sc = rtems_ftpfs_set_timeout(target, &to); rtems_test_assert(sc == RTEMS_SUCCESSFUL); } static void change_self_priority(void) { rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_task_priority cur = 0; sc = rtems_task_set_priority(RTEMS_SUCCESSFUL, 110, &cur); rtems_test_assert(sc == RTEMS_SUCCESSFUL); }
rtems_task Init( rtems_task_argument ignored ) { rtems_task_priority old_priority; rtems_mode old_mode; uint32_t task; /* lower the task priority to allow created tasks to execute */ rtems_task_set_priority( RTEMS_SELF, RTEMS_MAXIMUM_PRIORITY - 1, &old_priority); rtems_task_mode(RTEMS_PREEMPT, RTEMS_PREEMPT_MASK, &old_mode); printf( "\n*** UNLIMITED TASK TEST ***\n" ); /* * Invalid state if the task id is 0 */ for (task = 0; task < MAX_TASKS; task++) task_id[task] = 0; test1(); test2(); test3(); printf( "\n*** END OF UNLIMITED TASK TEST ***\n" ); exit( 0 ); }
/* * Server Task */ static rtems_task serverTask(rtems_task_argument arg) { int s, s1; socklen_t addrlen; struct sockaddr_in myAddr, farAddr; rtems_task_priority myPriority; printf("Create socket.\n"); s = socket(AF_INET, SOCK_STREAM, 0); if (s < 0) rtems_panic("Can't create socket: %s\n", strerror(errno)); memset(&myAddr, 0, sizeof myAddr); myAddr.sin_family = AF_INET; myAddr.sin_port = htons(1234); myAddr.sin_addr.s_addr = htonl(INADDR_ANY); printf("Bind socket.\n"); if (bind(s, (struct sockaddr *)&myAddr, sizeof myAddr) < 0) rtems_panic("Can't bind socket: %s\n", strerror(errno)); if (listen(s, 5) < 0) printf("Can't listen on socket: %s\n", strerror(errno)); rtems_task_set_priority(RTEMS_SELF, RTEMS_CURRENT_PRIORITY, &myPriority); for(;;) { addrlen = sizeof farAddr; s1 = accept(s, (struct sockaddr *)&farAddr, &addrlen); if (s1 < 0) if (errno == ENXIO) rtems_task_delete(RTEMS_SELF); else rtems_panic("Can't accept connection: %s", strerror(errno)); else printf("ACCEPTED:%lX\n", ntohl(farAddr.sin_addr.s_addr)); spawnTask(workerTask, myPriority, s1); } }
static void set_priority(rtems_id id, rtems_task_priority prio) { rtems_status_code sc; sc = rtems_task_set_priority(id, prio, &prio); rtems_test_assert(sc == RTEMS_SUCCESSFUL); }
static void change_prio(rtems_id task, rtems_task_priority prio) { rtems_status_code sc; rtems_task_priority unused; sc = rtems_task_set_priority(task, prio, &unused); rtems_test_assert(sc == RTEMS_SUCCESSFUL); }
static void set_task_prio(rtems_id task, rtems_task_priority prio) { rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_task_priority cur = 0; sc = rtems_task_set_priority(task, prio, &cur); ASSERT_SC(sc); }
static void assert_prio(rtems_id task_id, rtems_task_priority expected_prio) { rtems_status_code sc; rtems_task_priority prio; sc = rtems_task_set_priority(task_id, RTEMS_CURRENT_PRIORITY, &prio); rtems_test_assert(sc == RTEMS_SUCCESSFUL); rtems_test_assert(prio == expected_prio); }
rtems_task_priority Get_current_pri(void) { rtems_status_code status; rtems_task_priority pri; status = rtems_task_set_priority(RTEMS_SELF, RTEMS_CURRENT_PRIORITY, &pri); directive_failed( status, " rtems_task_set_priority "); return pri; }
static int getprio(void) { rtems_status_code status; rtems_task_priority pri; status = rtems_task_set_priority(RTEMS_SELF, RTEMS_CURRENT_PRIORITY, &pri); directive_failed( status, "rtems_task_set_priority"); return (int)pri; }
void epicsThreadSetPriority (epicsThreadId id,unsigned int osip) { rtems_id tid = (rtems_id)id; rtems_status_code sc; rtems_task_priority pri = epicsThreadGetOssPriorityValue(osip); sc = rtems_task_set_priority (tid, pri, &pri); if (sc != RTEMS_SUCCESSFUL) errlogPrintf("epicsThreadSetPriority failed: %s\n", rtems_status_text (sc)); }
unsigned int epicsThreadGetPriority(epicsThreadId id) { rtems_id tid = (rtems_id)id; rtems_status_code sc; rtems_task_priority pri; sc = rtems_task_set_priority (tid, RTEMS_CURRENT_PRIORITY, &pri); if (sc != RTEMS_SUCCESSFUL) errlogPrintf("epicsThreadGetPriority failed: %s\n", rtems_status_text (sc)); return epicsThreadGetOsiPriorityValue (pri); }
static rtems_task_priority set_prio(rtems_id id, rtems_task_priority prio) { rtems_status_code sc; rtems_task_priority old_prio; old_prio = 0xffffffff; sc = rtems_task_set_priority(id, prio, &old_prio); rtems_test_assert(sc == RTEMS_SUCCESSFUL); return old_prio; }
rtems_task Task_1( rtems_task_argument argument ) { rtems_id tid2; rtems_id tid3; rtems_status_code status; rtems_name tid2_name; uint32_t previous_priority; puts( "TA1 - rtems_task_wake_after - sleep 1 second" ); status = rtems_task_wake_after( rtems_clock_get_ticks_per_second() ); directive_failed( status, "rtems_task_wake_after" ); status = rtems_task_ident( Task_name[ 2 ], RTEMS_SEARCH_ALL_NODES, &tid2 ); directive_failed( status, "rtems_task_ident of TA2" ); printf( "TA1 - rtems_task_ident - tid of TA2 (0x%.8" PRIxrtems_id ")\n", tid2 ); status = rtems_object_get_classic_name( tid2, &tid2_name ); directive_failed( status, "rtems_object_get_classic_name of TA2" ); printf( "TA1 - rtems_get_classic_name - id -> name of TA2 %sOK\n", (tid2_name != Task_name[2]) ? "NOT " : "" ); status = rtems_task_ident( Task_name[ 3 ], RTEMS_SEARCH_ALL_NODES, &tid3 ); directive_failed( status, "rtems_task_ident of TA3" ); printf( "TA1 - rtems_task_ident - tid of TA3 (0x%.8" PRIxrtems_id ")\n", tid3 ); status = rtems_task_set_priority( tid3, 2, &previous_priority ); directive_failed( status, "rtems_task_set_priority" ); puts( "TA1 - rtems_task_set_priority - set TA3's priority to 2" ); puts( "TA1 - rtems_task_suspend - suspend TA2" ); status = rtems_task_suspend( tid2 ); directive_failed( status, "rtems_task_suspend of TA2" ); puts( "TA1 - rtems_task_delete - delete TA2" ); status = rtems_task_delete( tid2 ); directive_failed( status, "rtems_task_delete of TA2" ); puts( "TA1 - rtems_task_wake_after - sleep for 5 seconds" ); status = rtems_task_wake_after( 5 * rtems_clock_get_ticks_per_second() ); directive_failed( status, "rtems_task_wake_after" ); puts( "*** END OF TEST 2 ***" ); rtems_test_exit( 0 ); }
rtems_task Init( rtems_task_argument argument ) { rtems_status_code status; rtems_id id; rtems_task_priority old; puts( "\n\n*** SP76 (YIELD) TEST ***" ); status = rtems_task_ident( RTEMS_SELF, RTEMS_SEARCH_ALL_NODES, &id ); directive_failed( status, "task ident" ); /* to make sure it is equal to TA2 */ puts( "Set Init task priority = 2" ); status = rtems_task_set_priority( id, 2, &old ); directive_failed( status, "task priority" ); 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( "Create TA2 at equal priority task" ); status = rtems_task_create( rtems_build_name( 'T', 'A', '2', ' ' ), 2, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &id ); directive_failed( status, "create 2" ); status = rtems_task_start( id, Test_task, 1 ); directive_failed( status, "start 2" ); puts( "Yield to TA1" ); status = rtems_task_wake_after( RTEMS_YIELD_PROCESSOR ); directive_failed( status, "yield" ); puts( "*** should now get here ***" ); }
static rtems_task Init( rtems_task_argument argument ) { rtems_task_priority prio; rtems_status_code status; TEST_BEGIN(); Master = rtems_task_self(); if (RTEMS_MAXIMUM_PRIORITY >= 255) Priorities = Priorities_High; else if (RTEMS_MAXIMUM_PRIORITY >= 15) Priorities = Priorities_Low; else { puts( "Test needs at least 16 configured priority levels" ); rtems_test_exit( 0 ); } prio = RTEMS_MAXIMUM_PRIORITY - 1; status = rtems_task_set_priority(RTEMS_SELF, prio, &prio); directive_failed( status, "rtems_task_set_priority" ); if ( sizeof(Priorities_Low) / sizeof(rtems_task_priority) != MAX_TASKS ) { puts( "Priorities_Low table does not have right number of entries" ); rtems_test_exit( 0 ); } if ( sizeof(Priorities_High) / sizeof(rtems_task_priority) != MAX_TASKS ) { puts( "Priorities_High table does not have right number of entries" ); rtems_test_exit( 0 ); } puts( "Exercising blocking discipline w/extract in FIFO order " ); do_test( RTEMS_FIFO, TRUE ); puts( "Exercising blocking discipline w/unblock in FIFO order" ); do_test( RTEMS_FIFO, FALSE ); rtems_test_pause_and_screen_number( 2 ); puts( "Exercising blocking discipline w/extract in priority order " ); do_test( RTEMS_PRIORITY, TRUE ); puts( "Exercising blocking discipline w/unblock in priority order" ); do_test( RTEMS_PRIORITY, FALSE ); TEST_END(); rtems_test_exit(0); }
static void thread_delete_hook( Thread_Control *executing, Thread_Control *deleted ) { rtems_status_code sc = RTEMS_SUCCESSFUL; if (deleted->Object.id == task_0) { rtems_task_priority old = 0; sc = rtems_task_set_priority(task_1, 2, &old); rtems_test_assert(sc == RTEMS_SUCCESSFUL); } }
static void *thread_b(void *arg) { test_context *ctx; rtems_id scheduler_b_id; rtems_status_code sc; rtems_task_priority prio; int prio_ceiling; int eno; ctx = arg; rtems_test_assert(rtems_get_current_processor() == 0); sc = rtems_scheduler_ident(SCHED_B, &scheduler_b_id); rtems_test_assert(sc == RTEMS_SUCCESSFUL); sc = rtems_task_set_priority(pthread_self(), RTEMS_CURRENT_PRIORITY, &prio); rtems_test_assert(sc == RTEMS_SUCCESSFUL); sc = rtems_task_set_scheduler(pthread_self(), scheduler_b_id, prio); rtems_test_assert(sc == RTEMS_SUCCESSFUL); rtems_test_assert(rtems_get_current_processor() == 1); eno = pthread_mutex_init(&ctx->mtx_b, &ctx->mtx_attr); rtems_test_assert(eno == 0); eno = pthread_mutex_getprioceiling(&ctx->mtx_b, &prio_ceiling); rtems_test_assert(eno == 0); rtems_test_assert(prio_ceiling == 254); eno = pthread_mutex_lock(&ctx->mtx_b); rtems_test_assert(eno == 0); eno = pthread_mutex_unlock(&ctx->mtx_b); rtems_test_assert(eno == 0); eno = pthread_mutex_destroy(&ctx->mtx_b); rtems_test_assert(eno == 0); eno = pthread_mutex_getprioceiling(&ctx->mtx_a, &prio_ceiling); rtems_test_assert(eno == 0); rtems_test_assert(prio_ceiling == 126); eno = pthread_mutex_lock(&ctx->mtx_a); rtems_test_assert(eno == EINVAL); return ctx; }
rtems_task Middle_tasks( rtems_task_argument argument ) { rtems_task_priority previous_priority; Task_priority--; Task_count++; (void) rtems_task_set_priority( Task_id[ Task_count ], Task_priority, &previous_priority ); }
rtems_task First_task( rtems_task_argument argument ) { rtems_task_priority previous_priority; benchmark_timer_initialize(); Task_priority--; Task_count++; (void) rtems_task_set_priority( Task_id[ Task_count ], Task_priority, &previous_priority ); }
static void assert_prio( test_context *ctx, task_id id, rtems_task_priority expected ) { rtems_task_priority actual; rtems_status_code sc; sc = rtems_task_set_priority( ctx->tasks[id], RTEMS_CURRENT_PRIORITY, &actual ); rtems_test_assert(sc == RTEMS_SUCCESSFUL); rtems_test_assert(expected == actual); }
/* * OS-dependent initialization * No need to worry about making this thread-safe since * it must be called before epicsThreadCreate creates * any new threads. */ static void epicsThreadInit (void) { if (!initialized) { rtems_id tid; rtems_task_priority old; rtems_task_set_priority (RTEMS_SELF, epicsThreadGetOssPriorityValue(99), &old); onceMutex = epicsMutexMustCreate(); taskVarMutex = epicsMutexMustCreate (); rtems_task_ident (RTEMS_SELF, 0, &tid); setThreadInfo (tid, "_main_", NULL, NULL); initialized = 1; epicsThreadCreate ("ImsgDaemon", 99, epicsThreadGetStackSize (epicsThreadStackSmall), InterruptContextMessageDaemon, NULL); } }
rtems_task Init( rtems_task_argument ignored ) { #if BSP_SMALL_MEMORY printf("NO Capture Engine. MEMORY TOO SMALL"); #else rtems_status_code status; rtems_task_priority old_priority; rtems_mode old_mode; puts( "\n\n*** TEST CAPTURE ENGINE ***" ); status = rtems_shell_wait_for_input( STDIN_FILENO, 20, notification, NULL ); if (status == RTEMS_SUCCESSFUL) { /* lower the task priority to allow created tasks to execute */ rtems_task_set_priority(RTEMS_SELF, 20, &old_priority); rtems_task_mode(RTEMS_PREEMPT, RTEMS_PREEMPT_MASK, &old_mode); while (!can_proceed) { printf ("Sleeping\n"); usleep (1000000); } rtems_monitor_init (0); rtems_capture_cli_init (0); setup_tasks_to_watch (); rtems_task_delete (RTEMS_SELF); } else { puts( "*** END OF TEST CAPTURE ENGINE ***" ); exit( 0 ); } #endif }
void starttask( int arg ) { rtems_id tid; rtems_status_code sc; rtems_task_priority priority; rtems_task_set_priority(RTEMS_SELF, RTEMS_CURRENT_PRIORITY, &priority); sc = rtems_task_create(rtems_build_name('S', 'R', 'V', arg + 'A'), priority, RTEMS_MINIMUM_STACK_SIZE, RTEMS_PREEMPT|RTEMS_NO_TIMESLICE|RTEMS_NO_ASR|RTEMS_INTERRUPT_LEVEL(0), RTEMS_NO_FLOATING_POINT|RTEMS_LOCAL, &tid); directive_failed( sc, "task create" ); sc = rtems_task_start(tid, subtask, (rtems_task_argument) arg); directive_failed( sc, "task start" ); }