static void release_callback(rtems_id timer_id, void *arg)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
char buf [1];
size_t size = sizeof(buf);
uint32_t released = 0;
assert_time(T4);
rtems_test_assert(
obtain_try
&& interrupt_happened
&& !delayed_happened
&& !interrupt_triggered_happened
&& !server_triggered_happened
);
switch (resource_type) {
case SEMAPHORE:
sc = rtems_semaphore_release(semaphore);
break;
case MUTEX:
sc = rtems_semaphore_release(mutex);
break;
case MESSAGE_QUEUE:
sc = rtems_message_queue_send(message_queue, buf, size);
break;
case EVENT:
sc = rtems_event_send(_Timer_server->thread->Object.id, RTEMS_EVENT_0);
break;
case BARRIER:
sc = rtems_barrier_release(barrier, &released);
break;
case TASK_WAKE_AFTER:
sc = RTEMS_SUCCESSFUL;
break;
default:
rtems_test_assert(false);
break;
}
directive_failed_with_level(sc, "release", 1);
release_happened = true;
}
rtems_task read_task( rtems_task_argument not_used )
{
int fd = 0;
int status = -1;
uint32_t released = 0;
puts( "read_task - opening /fifo in non-blocking mode" );
fd = open( "/fifo", O_RDONLY | O_NONBLOCK );
if( fd <= 0 ) {
printf( "Error opening file: (%d) :: %s\n", errno, strerror( errno ) );
rtems_test_assert( 0 );
}
puts( "read_task - attempt to read with number of writers = 0" );
status = read( fd, recvBuf, SEND_RCV_BUFSIZ );
rtems_test_assert( status == 0 );
puts( "read_task - releasing the write task" );
status = rtems_barrier_release( wBarrier, &released );
rtems_test_assert( status == 0 );
puts( "read_task - waiting at a barrier" );
status = rtems_barrier_wait( rBarrier, RTEMS_NO_TIMEOUT );
rtems_test_assert( status == RTEMS_SUCCESSFUL );
puts( "read_task - attempting to read from the fifo -- Expect EAGAIN" );
status = read( fd, recvBuf, SEND_RCV_BUFSIZ );
rtems_test_assert( status == -1 );
rtems_test_assert( errno == EAGAIN );
puts( "read_task - closing /fifo" );
status = close( fd );
rtems_test_assert( status == 0 );
puts("read_task - opening /fifo in read-only mode");
fd = open( "/fifo", O_RDONLY );
if( fd <= 0 ) {
printf( "Error opening file: (%d) :: %s\n", errno, strerror( errno ) );
rtems_test_assert( 0 );
}
puts( "read_task - releasing the write task" );
status = rtems_barrier_release( wBarrier, &released );
rtems_test_assert( status == 0 );
puts( "read_task - reading from /fifo - OK" );
status = read( fd, recvBuf, 10 );
rtems_test_assert( status == 10 );
puts( "read_task - reading from /fifo - OK" );
status = read( fd, recvBuf+10, 10 );
rtems_test_assert( status == 10 );
puts( "read_task - waiting at a barrier" );
status = rtems_barrier_wait( rBarrier, RTEMS_NO_TIMEOUT );
rtems_test_assert( status == RTEMS_SUCCESSFUL );
puts( "read_task - reading from /fifo - OK" );
status = read( fd, recvBuf+20, SEND_RCV_BUFSIZ - 20 );
rtems_test_assert( status == SEND_RCV_BUFSIZ - 20 );
if( strcmp( sendBuf, recvBuf ) ) {
puts( "Sent, received buffer do not match" );
rtems_test_assert( 0 );
}
puts( "read_task - releasing the write task" );
status = rtems_barrier_release( wBarrier, &released );
rtems_test_assert( status == 0 );
puts( "read_task - waiting at a barrier" );
status = rtems_barrier_wait( rBarrier, RTEMS_NO_TIMEOUT );
rtems_test_assert( status == RTEMS_SUCCESSFUL );
status = close( fd );
rtems_test_assert( status == 0 );
puts( "read_task - releasing the write task" );
status = rtems_barrier_release( wBarrier, &released );
rtems_test_assert( status == 0 );
rtems_task_delete( RTEMS_SELF );
}
rtems_task Init(
rtems_task_argument 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);
}
