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