/*
* 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);
}
