rtems_task read_task(rtems_task_argument not_used)
{
int fd = 0;
int status = -1;
char recvBuf_r1[SEND_RCV_BUFSIZ] = {0};
char recvBuf_r2[SEND_RCV_BUFSIZ] = {0};
puts("\nRead task activated, waiting till writer opens");
status = rtems_barrier_wait( Barrier, RTEMS_NO_TIMEOUT );
rtems_test_assert( status == RTEMS_SUCCESSFUL );
sleep(1);
puts("\nNow, reader opening file(1)");
fd = open("/tmp/fifo01", O_RDONLY);
if(fd <= 0) {
printf("Error opening file: (%d) :: %s", errno, strerror(errno));
rtems_test_assert(0);
}
status = read(fd, recvBuf_r1, sizeof(recvBuf_r1)-1);
rtems_test_assert(status == sizeof(recvBuf_r1)-1);
printf("\n@ receiver (being a unblocked reader): Got %s", recvBuf_r1);
status = close(fd);
rtems_test_assert(status == 0);
status = rtems_barrier_wait( Barrier, RTEMS_NO_TIMEOUT );
rtems_test_assert( status == RTEMS_SUCCESSFUL );
puts("\nReader opening file(2)");
fd = open("/tmp/fifo01", O_RDONLY);
if(fd <= 0) {
printf("Error opening file: (%d) :: %s", errno, strerror(errno));
rtems_test_assert(0);
}
status = read(fd, recvBuf_r2, sizeof(recvBuf_r2)-1);
rtems_test_assert(status == sizeof(recvBuf_r2)-1);
printf("\n@ receiver (being a blocked reader): Got %s", recvBuf_r2);
status = close(fd);
rtems_test_assert(status == 0);
puts("\nReader done!");
status = rtems_barrier_wait( Barrier, RTEMS_NO_TIMEOUT );
rtems_test_assert( status == RTEMS_SUCCESSFUL );
rtems_task_delete( RTEMS_SELF );
}
static void barrier_wait(test_context *ctx)
{
rtems_status_code sc;
sc = rtems_barrier_wait(ctx->barrier_id, RTEMS_NO_TIMEOUT);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
static void obtain_callback(rtems_id timer_id, void *arg)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
char buf [1];
size_t size = sizeof(buf);
void *new_region_item = NULL;
rtems_event_set events = 0;
assert_time(T1);
rtems_test_assert(
!release_happened
&& !interrupt_happened
&& !delayed_happened
&& !interrupt_triggered_happened
&& !server_triggered_happened
);
obtain_try = true;
switch (resource_type) {
case SEMAPHORE:
sc = rtems_semaphore_obtain(semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
break;
case MUTEX:
sc = rtems_semaphore_obtain(mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
break;
case MESSAGE_QUEUE:
sc = rtems_message_queue_receive(
message_queue, buf, &size, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
break;
case REGION:
sc = rtems_region_get_segment(
region, 1, RTEMS_WAIT, RTEMS_NO_TIMEOUT, &new_region_item);
break;
case EVENT:
sc = rtems_event_receive(
RTEMS_EVENT_0, RTEMS_EVENT_ALL | RTEMS_WAIT, RTEMS_NO_TIMEOUT, &events);
break;
case BARRIER:
sc = rtems_barrier_wait(barrier, RTEMS_NO_TIMEOUT);
break;
case TASK_WAKE_AFTER:
sc = rtems_task_wake_after(T4 - T1);
break;
default:
rtems_test_assert(false);
break;
}
directive_failed(sc, "obtain");
obtain_done = true;
}
rtems_task Waiter(
rtems_task_argument number
)
{
rtems_status_code status;
printf( "Waiter %" PRIdrtems_task_argument " waiting on barrier\n", number );
status = rtems_barrier_wait( Barrier, RTEMS_NO_TIMEOUT );
printf( "Waiter %" PRIdrtems_task_argument " back from barrier\n", number );
if ( SuccessfulCase == TRUE ) {
directive_failed(status, "rtems_barrier_wait");
} else if ( DeletedCase == TRUE ) {
fatal_directive_status(
status,
RTEMS_OBJECT_WAS_DELETED,
"rtems_barrier_wait did not get deleted"
);
}
rtems_task_delete( RTEMS_SELF );
}
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 ***");
}
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 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 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_wait_initialization ()
{
#if defined (POSIX) || defined (RTEMS_POSIX) || defined (XENO_POSIX)
int cstate;
if (pthread_setcancelstate (PTHREAD_CANCEL_ENABLE, &cstate) != 0)
{
__DEBUGMSG ("[MAIN] Cannot modify the cancel state\n");
}
if (pthread_setcanceltype (PTHREAD_CANCEL_ASYNCHRONOUS, &cstate) != 0)
{
__DEBUGMSG ("[MAIN] Cannot modify the cancel type\n");
}
if (pthread_mutex_lock (&mutex_init) != 0)
{
__DEBUGMSG ("[MAIN] Unable to lock the mutex\n");
return (__PO_HI_ERROR_PTHREAD_MUTEX);
}
__po_hi_initialized_tasks++;
__DEBUGMSG ("[MAIN] %d task(s) initialized (total to init =%d)\n", __po_hi_initialized_tasks, __po_hi_nb_tasks_to_init);
while (__po_hi_initialized_tasks < __po_hi_nb_tasks_to_init)
{
pthread_cond_wait (&cond_init, &mutex_init);
}
pthread_cond_broadcast (&cond_init);
pthread_mutex_unlock (&mutex_init);
__PO_HI_INSTRUMENTATION_VCD_INIT
return (__PO_HI_SUCCESS);
#elif defined (_WIN32)
EnterCriticalSection (&__po_hi_main_initialization_critical_section);
__po_hi_initialized_tasks++;
__DEBUGMSG ("[MAIN] %d task(s) initialized (total to init =%d)\n", __po_hi_initialized_tasks, __po_hi_nb_tasks_to_init);
while (__po_hi_initialized_tasks < __po_hi_nb_tasks_to_init)
{
LeaveCriticalSection (&__po_hi_main_initialization_critical_section);
WaitForSingleObject (__po_hi_main_initialization_event, INFINITE);
EnterCriticalSection (&__po_hi_main_initialization_critical_section);
}
SetEvent (__po_hi_main_initialization_event);
LeaveCriticalSection (&__po_hi_main_initialization_critical_section);
return (__PO_HI_SUCCESS);
#elif defined (__PO_HI_RTEMS_CLASSIC_API)
rtems_status_code ret;
__DEBUGMSG ("[MAIN] Task wait for the barrier\n");
ret = rtems_barrier_wait (__po_hi_main_initialization_barrier, RTEMS_WAIT);
if (ret != RTEMS_SUCCESSFUL)
{
__DEBUGMSG ("[MAIN] Error while waiting for the barrier, return code=%d\n", ret);
return (__PO_HI_ERROR_UNKNOWN);
}
__DEBUGMSG ("[MAIN] Task release the barrier\n");
return (__PO_HI_SUCCESS);
#elif defined (XENO_NATIVE)
int ret;
if (main_task_id == rt_task_self ())
{
/*
* Here, this function is called by the main thread (the one that executes
* the main() function) so that we don't wait for the initialization of the
* other tasks, we automatically pass through the function and immeditaly
* return.
*/
return (__PO_HI_SUCCESS);
}
ret = rt_mutex_acquire (&mutex_init, TM_INFINITE);
if (ret != 0)
{
__DEBUGMSG ("[MAIN] Cannot acquire mutex (return code = %d)\n", ret);
return (__PO_HI_ERROR_PTHREAD_MUTEX);
}
__po_hi_initialized_tasks++;
__DEBUGMSG ("[MAIN] %d task(s) initialized (total to init =%d)\n", __po_hi_initialized_tasks, __po_hi_nb_tasks_to_init);
while (__po_hi_initialized_tasks < __po_hi_nb_tasks_to_init)
{
rt_cond_wait (&cond_init, &mutex_init, TM_INFINITE);
}
rt_cond_broadcast (&cond_init);
rt_mutex_release (&mutex_init);
return (__PO_HI_SUCCESS);
#else
return (__PO_HI_UNAVAILABLE);
#endif
}
