/* * Alloc pipe control structure, buffer, and resources. * Called with pipe_semaphore held. */ static int pipe_alloc( pipe_control_t **pipep ) { static char c = 'a'; pipe_control_t *pipe; int err = -ENOMEM; pipe = malloc(sizeof(pipe_control_t)); if (pipe == NULL) return err; memset(pipe, 0, sizeof(pipe_control_t)); pipe->Size = PIPE_BUF; pipe->Buffer = malloc(pipe->Size); if (! pipe->Buffer) goto err_buf; err = -ENOMEM; if (rtems_barrier_create( rtems_build_name ('P', 'I', 'r', c), RTEMS_BARRIER_MANUAL_RELEASE, 0, &pipe->readBarrier) != RTEMS_SUCCESSFUL) goto err_rbar; if (rtems_barrier_create( rtems_build_name ('P', 'I', 'w', c), RTEMS_BARRIER_MANUAL_RELEASE, 0, &pipe->writeBarrier) != RTEMS_SUCCESSFUL) goto err_wbar; if (rtems_semaphore_create( rtems_build_name ('P', 'I', 's', c), 1, RTEMS_BINARY_SEMAPHORE | RTEMS_FIFO, RTEMS_NO_PRIORITY, &pipe->Semaphore) != RTEMS_SUCCESSFUL) goto err_sem; #ifdef RTEMS_POSIX_API pipe_interruptible(pipe); #endif *pipep = pipe; if (c ++ == 'z') c = 'a'; return 0; err_sem: rtems_barrier_delete(pipe->writeBarrier); err_wbar: rtems_barrier_delete(pipe->readBarrier); err_rbar: free(pipe->Buffer); err_buf: free(pipe); return err; }
static void benchmark_barrier_create( int iteration, void *argument ) { rtems_status_code status; status = rtems_barrier_create( iteration + 1, RTEMS_LOCAL | RTEMS_FIFO, 2, &barrier[iteration] ); directive_failed(status, "rtems_barrier_create"); }
void create_all_barriers(void) { rtems_status_code status; int i; BarrierCount = 0; memset( Barriers, 0, sizeof(Barriers) ); for ( i=0 ; i<MAXIMUM ; i++ ) { status = rtems_barrier_create( rtems_build_name( 'B', 'A', 'R', 0x30+i ), RTEMS_BARRIER_MANUAL_RELEASE, 0, &Barriers[i] ); if ( status == RTEMS_TOO_MANY ) { printf( "%d Barriers created\n", BarrierCount+1 ); return; } directive_failed( status, "barrier create" ); BarrierCount++; } }
rtems_task Init(rtems_task_argument argument) { rtems_status_code sc = RTEMS_SUCCESSFUL; char region_area [256]; enum resource_type rt = SEMAPHORE; void *new_region_item = NULL; size_t i = 0; puts("\n\n*** TEST 68 ***"); for (i = 0; i < TIMER_COUNT; ++i) { sc = rtems_timer_create( rtems_build_name('T', 'I', 'M', '0' + i), &timer [i] ); directive_failed(sc, "rtems_timer_create"); } sc = rtems_timer_initiate_server( RTEMS_MINIMUM_PRIORITY, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_ATTRIBUTES ); directive_failed(sc, "rtems_timer_initiate_server"); sc = rtems_semaphore_create( rtems_build_name('S', 'E', 'M', 'A'), 0, RTEMS_LOCAL | RTEMS_FIFO | RTEMS_COUNTING_SEMAPHORE, 0, &semaphore ); directive_failed(sc, "rtems_semaphore_create"); sc = rtems_semaphore_create( rtems_build_name('M', 'U', 'T', 'X'), 0, RTEMS_LOCAL | RTEMS_FIFO | RTEMS_SIMPLE_BINARY_SEMAPHORE, 0, &mutex ); directive_failed(sc, "rtems_semaphore_create"); sc = rtems_message_queue_create( rtems_build_name('M', 'S', 'G', 'Q'), 1, 1, RTEMS_LOCAL | RTEMS_FIFO, &message_queue ); directive_failed(sc, "rtems_message_queue_create"); sc = rtems_region_create( rtems_build_name('R', 'E', 'G', 'I'), region_area, sizeof(region_area), 1, RTEMS_LOCAL | RTEMS_FIFO, ®ion ); directive_failed(sc, "rtems_region_create"); do { region_item = new_region_item; sc = rtems_region_get_segment( region, 1, RTEMS_NO_WAIT, 0, &new_region_item); } while (sc == RTEMS_SUCCESSFUL); sc = rtems_barrier_create( rtems_build_name('B', 'A', 'R', 'R'), RTEMS_LOCAL | RTEMS_FIFO, 2, &barrier ); directive_failed(sc, "rtems_barrier_create"); while (rt <= TASK_WAKE_AFTER) { test_case(rt); ++rt; } puts("*** END OF TEST 68 ***"); rtems_test_exit(0); }
void test_main(void) //Also acts as the write task { rtems_id readTaskID; rtems_name readTaskName; char sendBuf_r1[SEND_RCV_BUFSIZ] = {0}; char sendBuf_r2[SEND_RCV_BUFSIZ] = {0}; int status = -1; int fd = 0; strcpy( sendBuf_r1, "SendBuffer1" ); strcpy( sendBuf_r2, "SendBuffer2" ); memset( &Barrier, 0, sizeof(Barrier) ); status = rtems_barrier_create ( rtems_build_name ( 'B', 'A', 'R', 't' ), RTEMS_BARRIER_AUTOMATIC_RELEASE, 2, &Barrier ); rtems_test_assert( status == RTEMS_SUCCESSFUL ); puts("\n\n*** FIFO / PIPE OPEN TEST - 6 ***"); puts("\nCreating a task name and a task"); readTaskName = rtems_build_name('T','A','r',' '); status = rtems_task_create( readTaskName, 1, RTEMS_MINIMUM_STACK_SIZE * 2, RTEMS_INTERRUPT_LEVEL(31), RTEMS_DEFAULT_ATTRIBUTES, &readTaskID ); rtems_test_assert( status == RTEMS_SUCCESSFUL ); puts("\ncreating directory /tmp"); status = mkdir("/tmp", 0777); rtems_test_assert(status == 0); puts("\ncreating fifo file /tmp/fifo01"); status = mkfifo("/tmp/fifo01", 0777); rtems_test_assert(status == 0); puts("\nStarting the read task"); status = rtems_task_start(readTaskID, read_task, 0); rtems_test_assert(status == 0); status = rtems_barrier_wait( Barrier, RTEMS_NO_TIMEOUT ); rtems_test_assert( status == RTEMS_SUCCESSFUL ); puts("\nWriter opening file(1)"); fd = open("/tmp/fifo01", O_WRONLY); if(fd <= 0) { printf("Error opening file: (%d) :: %s", errno, strerror(errno)); rtems_test_assert(0); } printf("\n@ sender: %s", sendBuf_r1); status = write(fd, sendBuf_r1, sizeof(sendBuf_r1)-1); rtems_test_assert(status == sizeof(sendBuf_r1)-1); status = close(fd); rtems_test_assert(status == 0); status = rtems_barrier_wait( Barrier, RTEMS_NO_TIMEOUT ); rtems_test_assert( status == RTEMS_SUCCESSFUL ); sleep(1); // Reader would have blocked by now puts("\nWriter opening file(2)"); fd = open("/tmp/fifo01", O_WRONLY); if(fd <= 0) { printf("Error opening file: (%d) :: %s", errno, strerror(errno)); rtems_test_assert(0); } printf("\n@ sender: %s", sendBuf_r2); status = write(fd, sendBuf_r2, sizeof(sendBuf_r2)-1); rtems_test_assert(status == sizeof(sendBuf_r2)-1); status = close(fd); rtems_test_assert(status == 0); status = rtems_barrier_wait( Barrier, RTEMS_NO_TIMEOUT ); rtems_test_assert( status == RTEMS_SUCCESSFUL ); puts( "Removing the fifo" ); status = unlink("/tmp/fifo01"); rtems_test_assert(status == 0); puts( "Removing /tmp" ); status = rmdir("/tmp"); rtems_test_assert(status == 0); puts("\n*** END OF FIFO / PIPE OPEN TEST - 6 ***"); }
static void Init(rtems_task_argument arg) { test_context *ctx = &test_instance; rtems_status_code sc; rtems_resource_snapshot snapshot; uint32_t cpu_count = rtems_get_processor_count(); uint32_t cpu_index; TEST_BEGIN(); rtems_resource_snapshot_take(&snapshot); sc = rtems_barrier_create( rtems_build_name('B', 'A', 'R', 'I'), RTEMS_BARRIER_AUTOMATIC_RELEASE, cpu_count, &ctx->barrier_id ); rtems_test_assert(sc == RTEMS_SUCCESSFUL); for (cpu_index = 1; cpu_index < cpu_count; ++cpu_index) { rtems_id scheduler_id; sc = rtems_task_create( rtems_build_name('T', 'A', 'S', 'K'), 1, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &ctx->task_id[cpu_index] ); rtems_test_assert(sc == RTEMS_SUCCESSFUL); sc = rtems_scheduler_ident(SCHED_NAME(cpu_index), &scheduler_id); rtems_test_assert(sc == RTEMS_SUCCESSFUL); sc = rtems_task_set_scheduler(ctx->task_id[cpu_index], scheduler_id); rtems_test_assert(sc == RTEMS_SUCCESSFUL); sc = rtems_task_start(ctx->task_id[cpu_index], test_task, cpu_index); rtems_test_assert(sc == RTEMS_SUCCESSFUL); } tests(); barrier_wait(ctx); sc = rtems_barrier_delete(ctx->barrier_id); rtems_test_assert(sc == RTEMS_SUCCESSFUL); done(0); for (cpu_index = 1; cpu_index < cpu_count; ++cpu_index) { sc = rtems_task_delete(ctx->task_id[cpu_index]); rtems_test_assert(sc == RTEMS_SUCCESSFUL); rtems_test_assert(ctx->cpu_index[cpu_index] == cpu_index); done(cpu_index); } rtems_test_assert(rtems_resource_snapshot_check(&snapshot)); TEST_END(); rtems_test_exit(0); }
void __po_hi_gqueue_init (__po_hi_task_id id, __po_hi_uint8_t nb_ports, __po_hi_port_t queue[], __po_hi_int8_t sizes[], __po_hi_uint8_t first[], __po_hi_uint8_t offsets[], __po_hi_uint8_t woffsets[], __po_hi_uint8_t n_dest[], __po_hi_port_t* destinations[], __po_hi_uint8_t used_size[], __po_hi_local_port_t history[], __po_hi_request_t recent[], __po_hi_uint8_t empties[], __po_hi_uint16_t total_fifo_size) { __po_hi_uint8_t tmp; __po_hi_uint16_t off; __po_hi_request_t* request; int err; #if defined (RTEMS_PURE) rtems_status_code ret; #elif defined (XENO_NATIVE) int ret; #endif __po_hi_gqueues_global_history_woffset[id] = 0; __po_hi_gqueues_global_history_offset[id] = 0; __po_hi_gqueues_n_empty[id] = nb_ports; __po_hi_gqueues[id] = queue; __po_hi_gqueues_most_recent_values[id] = recent; __po_hi_gqueues_global_history[id] = history; __po_hi_gqueues_woffsets[id] = woffsets; __po_hi_gqueues_port_is_empty[id] = empties; __po_hi_gqueues_nb_ports[id] = nb_ports; __po_hi_gqueues_sizes[id] = sizes; __po_hi_gqueues_first[id] = first; __po_hi_gqueues_used_size[id] = used_size; __po_hi_gqueues_offsets[id] = offsets; __po_hi_gqueues_n_destinations[id] = n_dest; __po_hi_gqueues_destinations[id] = destinations; __po_hi_gqueues_total_fifo_size[id] = total_fifo_size; __po_hi_gqueues_queue_is_empty[id] = 1; #if defined (RTEMS_POSIX) || defined (POSIX) || defined (XENO_POSIX) err = pthread_mutexattr_init (&__po_hi_gqueues_mutexes_attr[id]); __DEBUGMSG("MUTEX_INIT %d %d\n", id, err); err = pthread_condattr_init (&__po_hi_gqueues_conds_attr[id]); __DEBUGMSG("MUTEX_INIT %d %d\n", id, err); #if defined (POSIX) || defined (XENO_POSIX) // XXX disabled for OS X #ifndef __MACH__ // OS X bugs on this attribute err = pthread_mutexattr_setpshared(&__po_hi_gqueues_mutexes_attr[id],PTHREAD_PROCESS_SHARED); #endif __DEBUGMSG("MUTEX_INIT %d\n", err); #endif err = pthread_mutex_init (&__po_hi_gqueues_mutexes[id], &__po_hi_gqueues_mutexes_attr[id]); __DEBUGMSG("MUTEX_INIT %d %d\n", id, err); err = pthread_cond_init (&__po_hi_gqueues_conds[id], &__po_hi_gqueues_conds_attr[id]); __DEBUGMSG("COND_INIT %d %d\n", id, err); #endif #ifdef RTEMS_PURE __PO_HI_DEBUG_INFO ("[GQUEUE] Create semaphore for queue of task %d\n", id); ret = rtems_semaphore_create (rtems_build_name ('G', 'S', 'E' , 'A' + (char) id), 1, RTEMS_BINARY_SEMAPHORE, __PO_HI_DEFAULT_PRIORITY, &(__po_hi_gqueues_semaphores[id])); if (ret != RTEMS_SUCCESSFUL) { __PO_HI_DEBUG_CRITICAL ("[GQUEUE] Cannot create semaphore, error code=%d\n", ret); } __PO_HI_DEBUG_INFO ("[GQUEUE] Create barrier for queue of task %d\n", id); ret = rtems_barrier_create (rtems_build_name ('G', 'S', 'I' , 'A' + (char) id),RTEMS_BARRIER_AUTOMATIC_RELEASE , 10, &(__po_hi_gqueues_barriers[id])); if (ret != RTEMS_SUCCESSFUL) { __PO_HI_DEBUG_CRITICAL ("[GQUEUE] Cannot create barrier, error code=%d\n", ret); } #endif #ifdef XENO_NATIVE ret = rt_mutex_create (&__po_hi_gqueues_mutexes[id], NULL); if (ret != 0) { __PO_HI_DEBUG_CRITICAL ("[GQUEUE] Cannot create mutex code=%d\n", ret); } ret = rt_cond_create (&__po_hi_gqueues_conds[id], NULL); if (ret != 0) { __PO_HI_DEBUG_CRITICAL ("[GQUEUE] Cannot create cond code=%d\n", ret); } #endif #ifdef _WIN32 __po_hi_gqueues_events[id] = CreateEvent (NULL, FALSE, FALSE, NULL); if (__po_hi_gqueues_events[id] == NULL) { __PO_HI_DEBUG_CRITICAL ("CreateEvent failed (%d)\n", GetLastError()); return; } InitializeCriticalSection (&__po_hi_gqueues_cs[id]); #endif off = 0; for (tmp=0;tmp<nb_ports;tmp++) { __po_hi_gqueues_used_size[id][tmp] = 0; if ( (sizes[tmp] != __PO_HI_GQUEUE_FIFO_INDATA) && (sizes[tmp] != __PO_HI_GQUEUE_FIFO_OUT)) { __po_hi_gqueues_first[id][tmp]=off; off += __po_hi_gqueues_sizes[id][tmp]; __po_hi_gqueues_offsets[id][tmp] = 0; __po_hi_gqueues_woffsets[id][tmp] = 0; __po_hi_gqueues_port_is_empty[id][tmp] = 1; } /* Set invalid all recent values */ request = (__po_hi_request_t*)&__po_hi_gqueues_most_recent_values[id][tmp]; request->port = __PO_HI_GQUEUE_INVALID_PORT; } #ifdef __PO_HI_DEBUG __DEBUGMSG("Initialize global queue for task-id %d ... ", id); for (tmp=0;tmp<nb_ports;tmp++) { __DEBUGMSG("port %d (used_size=%d,first=%d) ", tmp, __po_hi_gqueues_used_size[id][tmp], __po_hi_gqueues_first[id][tmp]); } __DEBUGMSG(" ... done\n"); #endif }
rtems_task Init( rtems_task_argument ignored ) { rtems_status_code status; rtems_name name = rtems_build_name('B','A','R','1'); uint32_t released; rtems_id testId; rtems_id Tasks[CONFIGURE_MAXIMUM_TASKS-1]; uint32_t i; TEST_BEGIN(); /* Check bad argument cases */ puts( "rtems_barrier_delete - bad id - INVALID_ID" ); status = rtems_barrier_delete( 100 ); fatal_directive_status( status, RTEMS_INVALID_ID, "rtems_barrier_delete did not return RTEMS_INVALID_ID" ); puts( "rtems_barrier_release - bad id - INVALID_ID" ); status = rtems_barrier_release( 100, &released ); fatal_directive_status( status, RTEMS_INVALID_ID, "rtems_barrier_release did not return RTEMS_INVALID_ID" ); puts( "rtems_barrier_wait - bad id - INVALID_ID" ); status = rtems_barrier_wait( 100, 10 ); fatal_directive_status( status, RTEMS_INVALID_ID, "rtems_barrier_wait did not return RTEMS_INVALID_ID" ); /* Create barrier with automatic release and 0 maximum waiters */ puts( "Create barrier with automatic release and 0 max waiters" ); status = rtems_barrier_create( name, RTEMS_BARRIER_AUTOMATIC_RELEASE, 0, &Barrier ); fatal_directive_status( status, RTEMS_INVALID_NUMBER, "rtems_barrier_create did not return RTEMS_INVALID_NUMBER" ); /* create barrier with bad name */ puts( "rtems_barrier_create - bad name - INVALID_NAME" ); status = rtems_barrier_create( 0, RTEMS_BARRIER_AUTOMATIC_RELEASE, 1, &Barrier); fatal_directive_status( status, RTEMS_INVALID_NAME, "rtems_barrier_create did not return RTEMS_INVALID_NAME" ); /* create barrier with bad id return address */ puts( "rtems_barrier_create - NULL barrier ID - INVALID_ADDRESS" ); status = rtems_barrier_create(name, RTEMS_BARRIER_AUTOMATIC_RELEASE, 1, NULL); fatal_directive_status( status, RTEMS_INVALID_ADDRESS, "rtems_barrier_create did not return RTEMS_INVALID_ADDRESS" ); /* Create barrier */ puts( "rtems_barrier_create - OK" ); status = rtems_barrier_create( name, RTEMS_DEFAULT_ATTRIBUTES, 0, &Barrier ); directive_failed(status, "rtems_barrier_create"); /* Check for creating too many */ puts( "rtems_barrier_create - too many" ); status = rtems_barrier_create( name, RTEMS_DEFAULT_ATTRIBUTES, 0, &Barrier ); fatal_directive_status( status, RTEMS_TOO_MANY, "rtems_barrier_create did not return RTEMS_TOO_MANY" ); puts( "Check barrier ident" ); status = rtems_barrier_ident( name, &testId ); directive_failed(status, "rtems_barrier_ident"); if ( testId != Barrier ) { printf( "ERROR -- rtems_barrier_create -- did not get Id expected\n" ); exit( 0 ); } puts( "Wait on barrier w/timeout and TIMEOUT" ); status = rtems_barrier_wait( Barrier, 25 ); fatal_directive_status( status, RTEMS_TIMEOUT, "rtems_barrier_wait did not timeout" ); /* Release with bad return pointer */ puts( "rtems_barrier_release - NULL return count - INVALID_ADDRESS" ); status = rtems_barrier_release( Barrier, NULL ); fatal_directive_status( status, RTEMS_INVALID_ADDRESS, "rtems_barrier_release bad return pointer" ); /* Release no tasks */ status = rtems_barrier_release( Barrier, &released ); directive_failed(status, "rtems_barrier_release"); if ( released != 0 ) { printf( "ERROR -- rtems_barrier_release -- released != 0, = %" PRIu32, released ); rtems_test_exit(0); } /* Create some tasks to wait for the barrier */ SuccessfulCase = TRUE; DeletedCase = FALSE; puts( "\n*** Testing manual release of barrier ***" ); for (i=0 ; i<(CONFIGURE_MAXIMUM_TASKS-1) ; i++) { status = rtems_task_create( rtems_build_name('W','A','I','T'), 1, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &Tasks[ i ] ); directive_failed( status, "rtems_task_create of Waiter" ); status = rtems_task_start( Tasks[ i ], Waiter, i ); directive_failed( status, "rtems_task_start of Waiter" ); } puts( "Delay to let Waiters block" ); status = rtems_task_wake_after( rtems_clock_get_ticks_per_second() ); directive_failed(status, "rtems_task_wake_after"); /* Release tasks which were waiting */ puts( "Releasing tasks" ); status = rtems_barrier_release( Barrier, &released ); directive_failed(status, "rtems_barrier_release"); if ( released != (CONFIGURE_MAXIMUM_TASKS-1) ) { printf( "ERROR -- rtems_barrier_release -- released != %d, = %" PRIu32, (CONFIGURE_MAXIMUM_TASKS-1), released ); rtems_test_exit(0); } puts( "Delay to let Waiters print a message" ); status = rtems_task_wake_after( rtems_clock_get_ticks_per_second() ); directive_failed(status, "rtems_task_wake_after"); /* Create some tasks to wait for the barrier */ SuccessfulCase = FALSE; DeletedCase = TRUE; puts( "\n*** Testing Deletion of barrier ***" ); for (i=0 ; i<(CONFIGURE_MAXIMUM_TASKS-1) ; i++) { status = rtems_task_create( rtems_build_name('W','A','I','T'), 1, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &Tasks[ i ] ); directive_failed( status, "rtems_task_create of Waiter" ); status = rtems_task_start( Tasks[ i ], Waiter, i ); directive_failed( status, "rtems_task_start of Waiter" ); } puts( "Delay to let Waiters block" ); status = rtems_task_wake_after( rtems_clock_get_ticks_per_second() ); directive_failed(status, "rtems_task_wake_after"); puts( "rtems_barrier_delete - OK" ); status = rtems_barrier_delete( Barrier ); directive_failed(status, "rtems_barrier_delete"); puts( "Delay to let Waiters print a message" ); status = rtems_task_wake_after( rtems_clock_get_ticks_per_second() ); directive_failed(status, "rtems_task_wake_after"); /* Create barrier with automatic release */ puts( "rtems_barrier_create - OK" ); status = rtems_barrier_create( name, RTEMS_BARRIER_AUTOMATIC_RELEASE, CONFIGURE_MAXIMUM_TASKS-1, &Barrier ); directive_failed(status, "rtems_barrier_create"); /* Create some tasks to wait for the barrier */ SuccessfulCase = TRUE; DeletedCase = FALSE; puts( "\n*** Testing automatic release of barrier ***" ); for (i=0 ; i<(CONFIGURE_MAXIMUM_TASKS-1) ; i++) { status = rtems_task_create( rtems_build_name('W','A','I','T'), 1, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &Tasks[ i ] ); directive_failed( status, "rtems_task_create of Waiter" ); status = rtems_task_start( Tasks[ i ], Waiter, i ); directive_failed( status, "rtems_task_start of Waiter" ); } puts( "Delay to let task wait on barrier" ); status = rtems_task_wake_after( rtems_clock_get_ticks_per_second() ); directive_failed(status, "rtems_task_wake_after"); /* the end */ TEST_END(); rtems_test_exit(0); }
rtems_task Init( rtems_task_argument not_used ) { rtems_id readTaskID; rtems_name readTaskName; int status = -1; int fd = 0; uint32_t released = 0; int flag = 1; puts("\n*** FIFO / PIPE TESTS - 5 ***"); memset( sendBuf, '1', SEND_RCV_BUFSIZ - 30 ); memset( sendBuf, '2', 29 ); sendBuf[SEND_RCV_BUFSIZ-1] = 0; memset( &rBarrier, 0, sizeof(rBarrier) ); status = rtems_barrier_create ( rtems_build_name ( 'B', 'A', 'R', 'r' ), RTEMS_BARRIER_MANUAL_RELEASE, 2, &rBarrier ); rtems_test_assert( status == RTEMS_SUCCESSFUL ); memset( &wBarrier, 0, sizeof( wBarrier ) ); status = rtems_barrier_create ( rtems_build_name ( 'B', 'A', 'R', 'w' ), RTEMS_BARRIER_MANUAL_RELEASE, 2, &wBarrier ); rtems_test_assert( status == RTEMS_SUCCESSFUL ); readTaskName = rtems_build_name( 'T','A','r',' ' ); status = rtems_task_create( readTaskName, 1, RTEMS_MINIMUM_STACK_SIZE * 2, RTEMS_INTERRUPT_LEVEL(31), RTEMS_DEFAULT_ATTRIBUTES, &readTaskID ); rtems_test_assert( status == RTEMS_SUCCESSFUL ); puts( "Init - Creating fifo file /fifo" ); status = mkfifo( "/fifo", 0777 ); rtems_test_assert( status == 0 ); puts( "Init - starting the read task" ); status = rtems_task_start( readTaskID, read_task, 0 ); rtems_test_assert( status == 0 ); puts( "Init - waiting at a barrier" ); status = rtems_barrier_wait( wBarrier, RTEMS_NO_TIMEOUT ); rtems_test_assert( status == RTEMS_SUCCESSFUL ); puts("Init - opening the fifo in write only mode -- OK"); fd = open("/fifo", O_WRONLY); if(fd <= 0) { printf("Error opening file: (%d) :: %s\n", errno, strerror(errno)); rtems_test_assert(0); } puts( "Init - writing to /fifo" ); status = write(fd, sendBuf, 0 ); rtems_test_assert( status == 0 ); puts( "Init - releasing the read_task" ); status = rtems_barrier_release( rBarrier, &released ); rtems_test_assert( status == 0 ); puts( "Init - waiting at a barrier" ); status = rtems_barrier_wait( wBarrier, RTEMS_NO_TIMEOUT ); rtems_test_assert( status == RTEMS_SUCCESSFUL ); puts( "Init - writing to /fifo - OK" ); status = write(fd, sendBuf, SEND_RCV_BUFSIZ - 30 ); rtems_test_assert( status == SEND_RCV_BUFSIZ - 30 ); puts( "Init - writing to /fifo - OK" ); status = write(fd, sendBuf+SEND_RCV_BUFSIZ - 30, 30 ); rtems_test_assert( status == 30 ); puts( "Init - releasing the read_task" ); status = rtems_barrier_release( rBarrier, &released ); rtems_test_assert( status == 0 ); puts( "Init - waiting at a barrier" ); status = rtems_barrier_wait( wBarrier, RTEMS_NO_TIMEOUT ); rtems_test_assert( status == RTEMS_SUCCESSFUL ); puts( "Init - converting the write-mode to non-block" ); status = ioctl( fd, FIONBIO, &flag ); rtems_test_assert( status == 0 ); puts( "Init - writing to /fifo - OK" ); status = write(fd, sendBuf, SEND_RCV_BUFSIZ - 30 ); rtems_test_assert( status == SEND_RCV_BUFSIZ - 30 ); puts( "Init - writing to /fifo - Expect EAGAIN" ); status = write(fd, sendBuf, SEND_RCV_BUFSIZ - 30 ); rtems_test_assert( status == -1 ); rtems_test_assert( errno == EAGAIN ); puts( "Init - releasing the read_task" ); status = rtems_barrier_release( rBarrier, &released ); rtems_test_assert( status == 0 ); puts( "Init - waiting at a barrier" ); status = rtems_barrier_wait( wBarrier, RTEMS_NO_TIMEOUT ); rtems_test_assert( status == RTEMS_SUCCESSFUL ); puts( "Init - writing to /fifo - Expect EPIPE" ); status = write(fd, sendBuf, SEND_RCV_BUFSIZ - 30 ); rtems_test_assert( status == -1 ); rtems_test_assert( errno == EPIPE ); status = close( fd ); rtems_test_assert( status == 0 ); puts( "Removing the fifo" ); status = unlink("/fifo"); rtems_test_assert(status == 0); puts("*** END OF FIFO / PIPE OPEN TEST - 6 ***"); rtems_test_exit(0); }
int __po_hi_initialize_early () { #if defined (XENO_POSIX) || defined (XENO_NATIVE) /* * Once initialization has been done, we avoid ALL * potential paging operations that can introduce * some indeterministic timing behavior. */ #include <sys/mman.h> mlockall (MCL_CURRENT|MCL_FUTURE); #endif #if defined (XENO_NATIVE) main_task_id = rt_task_self (); __po_hi_nb_tasks_to_init--; /* * If we are using the XENO_NATIVE skin, we need * to differentiate the main task (that is non real-time) * from the others since the main task cannot use * the services and operates on resources of real-time tasks. * In addition, we decrement the amount of tasks to * initialize since the main task does not wait * for the initialization of the other tasks. */ #endif #if defined (POSIX) || defined (RTEMS_POSIX) || defined (XENO_POSIX) pthread_mutexattr_t mutex_attr; if (pthread_mutexattr_init (&mutex_attr) != 0) { __DEBUGMSG ("[MAIN] Unable to init mutex attributes\n"); } #ifdef RTEMS_POSIX if (pthread_mutexattr_setprioceiling (&mutex_attr, 50) != 0) { __DEBUGMSG ("[MAIN] Unable to set priority ceiling on mutex\n"); } #endif if (pthread_mutex_init (&mutex_init, &mutex_attr) != 0 ) { __DEBUGMSG ("[MAIN] Unable to init pthread_mutex\n"); return (__PO_HI_ERROR_PTHREAD_MUTEX); } __DEBUGMSG ("[MAIN] Have %d tasks to init\n", __po_hi_nb_tasks_to_init); if (pthread_cond_init (&cond_init, NULL) != 0) { return (__PO_HI_ERROR_PTHREAD_COND); } #endif #if defined (XENO_NATIVE) if (rt_cond_create (&cond_init, NULL)) { __DEBUGMSG ("[MAIN] Unable to init the initialization condition variable \n"); return (__PO_HI_ERROR_PTHREAD_MUTEX); } if (rt_mutex_create (&mutex_init, NULL) != 0) { __DEBUGMSG ("[MAIN] Unable to init the initialization mutex variable \n"); return (__PO_HI_ERROR_PTHREAD_COND); } #endif #if defined (RTEMS_POSIX) || defined (__PO_HI_RTEMS_CLASSIC_API) rtems_status_code ret; rtems_time_of_day time; time.year = 1988; time.month = 12; time.day = 31; time.hour = 9; time.minute = 1; time.second = 10; time.ticks = 0; ret = rtems_clock_set( &time ); if (ret != RTEMS_SUCCESSFUL) { __DEBUGMSG ("[MAIN] Cannot set the clock\n"); return __PO_HI_ERROR_CLOCK; } #endif #ifdef __PO_HI_RTEMS_CLASSIC_API __DEBUGMSG ("[MAIN] Create a barrier that wait for %d tasks\n", __po_hi_nb_tasks_to_init); ret = rtems_barrier_create (rtems_build_name ('B', 'A', 'R', 'M'), RTEMS_BARRIER_AUTOMATIC_RELEASE, __po_hi_nb_tasks_to_init, &__po_hi_main_initialization_barrier); if (ret != RTEMS_SUCCESSFUL) { __DEBUGMSG ("[MAIN] Cannot create the main barrier, return code=%d\n", ret); } #endif #ifdef _WIN32 __po_hi_main_initialization_event = CreateEvent (NULL, FALSE, FALSE, NULL); InitializeCriticalSection (&__po_hi_main_initialization_critical_section); #endif __po_hi_initialize_tasking (); /* Initialize protected objects */ #if __PO_HI_NB_PROTECTED > 0 __po_hi_protected_init(); #endif #if __PO_HI_MONITOR_ENABLED == 1 __po_hi_monitor_init (); #endif return (__PO_HI_SUCCESS); }