int main()
{
/* Make sure there is prioceiling capability. */
/* #ifndef _POSIX_PRIORITY_SCHEDULING
fprintf(stderr,"prioceiling attribute is not available for testing\n");
return PTS_UNRESOLVED;
#endif */
pthread_mutexattr_t mta;
int prioceiling, ret;
prioceiling = sched_get_priority_min(SCHED_FIFO);
/* Set the prioceiling of an unintialized mutex attr. */
if ((ret = pthread_mutexattr_setprioceiling(&mta, prioceiling)) == 0) {
printf
("Test PASSED: *Note: Returned 0 instead of EINVAL when passed an uninitialized mutex attribute object to pthread_mutexattr_setprioceiling, but standard says 'may' fail.\n");
return PTS_PASS;
}
if (ret != EINVAL) {
printf
("Test FAILED: Invalid return code %d. Expected EINVAL or 0.\n",
ret);
return PTS_FAIL;
}
printf("Test PASSED\n");
return PTS_PASS;
}
void test( void )
{
pthread_mutexattr_t attribute;
int prioceiling = 0;
int result;
result = pthread_mutexattr_setprioceiling( &attribute, prioceiling );
}
int main()
{
/* Make sure there is prioceiling capability. */
/* #ifndef _POSIX_PRIORITY_SCHEDULING
fprintf(stderr,"prioceiling attribute is not available for testing\n");
return PTS_UNRESOLVED;
#endif */
pthread_mutexattr_t mta;
int prioceiling, max_prio, min_prio, i;
/* Initialize a mutex attributes object */
if(pthread_mutexattr_init(&mta) != 0)
{
perror("Error at pthread_mutexattr_init()\n");
return PTS_UNRESOLVED;
}
/* Get the max and min prio according to SCHED_FIFO (posix scheduling policy) */
max_prio = sched_get_priority_max(SCHED_FIFO);
min_prio = sched_get_priority_min(SCHED_FIFO);
for(i=min_prio;(i<max_prio+1);i++)
{
/* Set the prioceiling to a priority number in the boundries
* of SCHED_FIFO policy */
if(pthread_mutexattr_setprioceiling(&mta,i))
{
printf("Error setting prioceiling to %d\n", i);
return PTS_UNRESOLVED;
}
/* Get the prioceiling mutex attr. */
if(pthread_mutexattr_getprioceiling(&mta, &prioceiling) != 0)
{
fprintf(stderr,"Error obtaining the attribute process-shared\n");
return PTS_UNRESOLVED;
}
/* Make sure that prioceiling is withing the legal SCHED_FIFO boundries. */
if(prioceiling != i)
{
printf("Test FAILED: Set prioceiling and get prioceiling did not match.\n");
return PTS_FAIL;
}
}
printf("Test PASSED\n");
return PTS_PASS;
}
void *POSIX_Init(
void *argument
)
{
#if defined(DEFINE_MUTEX_ATTRIBUTES)
pthread_mutexattr_t mutex_attr;
#endif
pthread_t thread_id;
int status;
puts( "\n\n*** LED BLINKER -- pthread_mutex ***" );
#if defined(DEFINE_MUTEX_ATTRIBUTES)
status = pthread_mutexattr_init( &mutex_attr );
status = pthread_mutexattr_setprotocol( &mutex_attr, PTHREAD_PRIO_INHERIT );
status = pthread_mutexattr_setprioceiling( &mutex_attr, 128 );
status = pthread_mutex_init( &Mutex, &mutex_attr );
#else
status = pthread_mutex_init( &Mutex, NULL );
#endif
if (status)
fprintf( stderr, "mutex init (%d) \n", status );
/* fprintf( stderr, "Mutex id --> 0x%08x\n", Mutex ); */
status = pthread_create( &thread_id, NULL, Server, NULL );
if (status)
fprintf( stderr, "pthread_create --> %d\n", status );
status = pthread_mutex_lock( &Mutex );
if (status)
fprintf( stderr, "Main -- first lock did not work (%d)\n", status );
for ( ; ; ) {
LED_OFF();
status = sleep( 1 );
status = pthread_mutex_unlock( &Mutex );
if (status)
fprintf( stderr, "Main - unlock did not work (%d)\n", status );
status = pthread_mutex_lock( &Mutex );
if (status)
fprintf( stderr, "Main - lock did not work (%d)\n", status );
}
exit( 0 );
}
/* barrier */
void barrier_init(barrier_t * mybarrier)
{
/* must run before spawning the thread */
pthread_mutexattr_t attr;
# if (OS==ORIGIN)
pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT);
pthread_mutexattr_setprioceiling(&attr, 0);
pthread_mutex_init(&(mybarrier->barrier_mutex), &attr);
# elif (OS==SOLARIS)
pthread_mutex_init(&(mybarrier->barrier_mutex), NULL);
# else
# error "undefined OS"
# endif
pthread_cond_init(&(mybarrier->barrier_cond), NULL);
mybarrier->cur_count = 0;
}
///////////////////////////////////////////////////////////////////////////////////
// Name: CMutexWrapper
// Author: Ghervase Gabriel
// Description: contructor for creating a mutex with explicit attributes
// Parameters: p_nPrioceiling - the priority ceiling of initialised mutexes,
// which is the minimum priority level at which
// the critical section guarded by the mutex is executed
// Must be within the maximum range of priorities
// defined under the SCHED_FIFO scheduling policy
// p_nProtocol - protocol to be followed ; can be one of :
// PTHREAD_PRIO_NONE,
// PTHREAD_PRIO_INHERIT,
// PTHREAD_PRIO_PROTECT
// p_nPshared - mutex's process-shared state;
// determines whether the mutex can be used to
// synchronize threads within the current process
// or threads within all processes on the system
// Values :
// PTHREAD_PROCESS_PRIVATE,
// PTHREAD_PROCESS_SHARED
// p_nType - type of mutex. Values:
// PTHREAD_MUTEX_NORMAL,
// PTHREAD_MUTEX_RECURSIVE,
// PTHREAD_MUTEX_ERRORCHECK,
// PTHREAD_MUTEX_DEFAULT
// Return: none
//////////////////////////////////////////////////////////////////////////////////
CMutexWrapper::CMutexWrapper(int p_nPrioceiling, int p_nProtocol, int p_nPshared, int p_nType)
{
int result;
pthread_mutexattr_t m_pAttr;
pthread_mutexattr_init(&m_pAttr);
pthread_mutexattr_setprioceiling(&m_pAttr, p_nPrioceiling);
pthread_mutexattr_setprotocol(&m_pAttr, p_nProtocol);
pthread_mutexattr_setpshared(&m_pAttr, p_nPshared);
if ( ( result = pthread_mutexattr_settype(&m_pAttr, p_nType) ) != 0 )
{
NLOG_ERR( "%s, pthread_mutexattr_settype() failed with result %d.", __PRETTY_FUNCTION__, result );
return;
}
if ( ( result = pthread_mutex_init(&m_oMutex, &m_pAttr) ) != 0 )
{
NLOG_ERR( "%s, pthread_mutex_init() failed with result %d.", __PRETTY_FUNCTION__, result );
return;
}
}
static void
prepare (void)
{
init_tpp_test ();
if (pthread_mutexattr_init (&a) != 0)
{
puts ("mutexattr_init failed");
exit (1);
}
if (pthread_mutexattr_setprotocol (&a, PTHREAD_PRIO_PROTECT) != 0)
{
puts ("mutexattr_setprotocol failed");
exit (1);
}
if (pthread_mutexattr_setprioceiling (&a, 6) != 0)
{
puts ("mutexattr_setprioceiling failed");
exit (1);
}
}
static int
do_test (void)
{
int ret = 0;
init_tpp_test ();
pthread_mutexattr_t ma;
if (pthread_mutexattr_init (&ma))
{
puts ("mutexattr_init failed");
return 1;
}
if (pthread_mutexattr_setprotocol (&ma, PTHREAD_PRIO_PROTECT))
{
puts ("mutexattr_setprotocol failed");
return 1;
}
int prioceiling;
if (pthread_mutexattr_getprioceiling (&ma, &prioceiling))
{
puts ("mutexattr_getprioceiling failed");
return 1;
}
if (prioceiling < fifo_min || prioceiling > fifo_max)
{
printf ("prioceiling %d not in %d..%d range\n",
prioceiling, fifo_min, fifo_max);
return 1;
}
if (fifo_max < INT_MAX
&& pthread_mutexattr_setprioceiling (&ma, fifo_max + 1) != EINVAL)
{
printf ("mutexattr_setprioceiling %d did not fail with EINVAL\n",
fifo_max + 1);
return 1;
}
if (fifo_min > 0
&& pthread_mutexattr_setprioceiling (&ma, fifo_min - 1) != EINVAL)
{
printf ("mutexattr_setprioceiling %d did not fail with EINVAL\n",
fifo_min - 1);
return 1;
}
if (pthread_mutexattr_setprioceiling (&ma, fifo_min))
{
puts ("mutexattr_setprioceiling failed");
return 1;
}
if (pthread_mutexattr_setprioceiling (&ma, fifo_max))
{
puts ("mutexattr_setprioceiling failed");
return 1;
}
if (pthread_mutexattr_setprioceiling (&ma, 6))
{
puts ("mutexattr_setprioceiling failed");
return 1;
}
if (pthread_mutexattr_getprioceiling (&ma, &prioceiling))
{
puts ("mutexattr_getprioceiling failed");
return 1;
}
if (prioceiling != 6)
{
printf ("mutexattr_getprioceiling returned %d != 6\n",
prioceiling);
return 1;
}
pthread_mutex_t m1, m2, m3;
int e = pthread_mutex_init (&m1, &ma);
if (e == ENOTSUP)
{
puts ("cannot support selected type of mutexes");
return 0;
}
else if (e != 0)
{
puts ("mutex_init failed");
return 1;
}
if (pthread_mutexattr_setprioceiling (&ma, 8))
{
puts ("mutexattr_setprioceiling failed");
return 1;
}
if (pthread_mutex_init (&m2, &ma))
{
puts ("mutex_init failed");
return 1;
}
if (pthread_mutexattr_setprioceiling (&ma, 5))
{
puts ("mutexattr_setprioceiling failed");
return 1;
}
if (pthread_mutex_init (&m3, &ma))
{
puts ("mutex_init failed");
return 1;
}
CHECK_TPP_PRIORITY (4, 4);
if (pthread_mutex_lock (&m1) != 0)
{
puts ("mutex_lock failed");
return 1;
}
CHECK_TPP_PRIORITY (4, 6);
if (pthread_mutex_trylock (&m2) != 0)
{
puts ("mutex_lock failed");
return 1;
}
CHECK_TPP_PRIORITY (4, 8);
if (pthread_mutex_lock (&m3) != 0)
{
puts ("mutex_lock failed");
return 1;
}
CHECK_TPP_PRIORITY (4, 8);
if (pthread_mutex_unlock (&m2) != 0)
{
puts ("mutex_unlock failed");
return 1;
}
CHECK_TPP_PRIORITY (4, 6);
if (pthread_mutex_unlock (&m1) != 0)
{
puts ("mutex_unlock failed");
return 1;
}
CHECK_TPP_PRIORITY (4, 5);
if (pthread_mutex_lock (&m2) != 0)
{
puts ("mutex_lock failed");
return 1;
}
CHECK_TPP_PRIORITY (4, 8);
if (pthread_mutex_unlock (&m2) != 0)
{
puts ("mutex_unlock failed");
return 1;
}
CHECK_TPP_PRIORITY (4, 5);
if (pthread_mutex_getprioceiling (&m1, &prioceiling))
{
puts ("mutex_getprioceiling m1 failed");
return 1;
}
else if (prioceiling != 6)
{
printf ("unexpected m1 prioceiling %d != 6\n", prioceiling);
return 1;
}
if (pthread_mutex_getprioceiling (&m2, &prioceiling))
{
puts ("mutex_getprioceiling m2 failed");
return 1;
}
else if (prioceiling != 8)
{
printf ("unexpected m2 prioceiling %d != 8\n", prioceiling);
return 1;
}
if (pthread_mutex_getprioceiling (&m3, &prioceiling))
{
puts ("mutex_getprioceiling m3 failed");
return 1;
}
else if (prioceiling != 5)
{
printf ("unexpected m3 prioceiling %d != 5\n", prioceiling);
return 1;
}
if (pthread_mutex_setprioceiling (&m1, 7, &prioceiling))
{
printf ("mutex_setprioceiling failed");
return 1;
}
else if (prioceiling != 6)
{
printf ("unexpected m1 old prioceiling %d != 6\n", prioceiling);
return 1;
}
if (pthread_mutex_getprioceiling (&m1, &prioceiling))
{
puts ("mutex_getprioceiling m1 failed");
return 1;
}
else if (prioceiling != 7)
{
printf ("unexpected m1 prioceiling %d != 7\n", prioceiling);
return 1;
}
CHECK_TPP_PRIORITY (4, 5);
if (pthread_mutex_unlock (&m3) != 0)
{
puts ("mutex_unlock failed");
return 1;
}
CHECK_TPP_PRIORITY (4, 4);
if (pthread_mutex_trylock (&m1) != 0)
{
puts ("mutex_lock failed");
return 1;
}
CHECK_TPP_PRIORITY (4, 7);
struct sched_param sp;
memset (&sp, 0, sizeof (sp));
sp.sched_priority = 8;
if (pthread_setschedparam (pthread_self (), SCHED_FIFO, &sp))
{
puts ("cannot set scheduling params");
return 1;
}
CHECK_TPP_PRIORITY (8, 8);
if (pthread_mutex_unlock (&m1) != 0)
{
puts ("mutex_unlock failed");
return 1;
}
CHECK_TPP_PRIORITY (8, 8);
if (pthread_mutex_lock (&m3) != EINVAL)
{
puts ("pthread_mutex_lock didn't fail with EINVAL");
return 1;
}
CHECK_TPP_PRIORITY (8, 8);
if (pthread_mutex_destroy (&m1) != 0)
{
puts ("mutex_destroy failed");
return 1;
}
if (pthread_mutex_destroy (&m2) != 0)
{
puts ("mutex_destroy failed");
return 1;
}
if (pthread_mutex_destroy (&m3) != 0)
{
puts ("mutex_destroy failed");
return 1;
}
if (pthread_mutexattr_destroy (&ma) != 0)
{
puts ("mutexattr_destroy failed");
return 1;
}
return ret;
}
void *POSIX_Init(
void *argument
)
{
int status;
pthread_mutexattr_t attr;
pthread_mutexattr_t destroyed_attr;
struct timespec times;
struct sched_param param;
int pshared;
int policy;
int protocol;
int ceiling;
int old_ceiling;
int priority;
rtems_test_assert( MUTEX_BAD_ID != PTHREAD_MUTEX_INITIALIZER );
Mutex_bad_id = MUTEX_BAD_ID;
TEST_BEGIN();
/* set the time of day, and print our buffer in multiple ways */
set_time( TM_FRIDAY, TM_MAY, 24, 96, 11, 5, 0 );
/* get id of this thread */
Init_id = pthread_self();
printf( "Init's ID is 0x%08" PRIxpthread_t "\n", Init_id );
/* test pthread_mutex_attr_init */
puts( "Init: pthread_mutexattr_init - EINVAL (NULL attr)" );
status = pthread_mutexattr_init( NULL );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutexattr_init - SUCCESSFUL" );
status = pthread_mutexattr_init( &attr );
rtems_test_assert( !status );
Print_mutexattr( "Init: ", &attr );
/* create an "uninitialized" attribute structure */
status = pthread_mutexattr_init( &destroyed_attr );
rtems_test_assert( !status );
puts( "Init: pthread_mutexattr_destroy - SUCCESSFUL" );
status = pthread_mutexattr_destroy( &destroyed_attr );
rtems_test_assert( !status );
puts( "Init: pthread_mutexattr_destroy - EINVAL (NULL attr)" );
status = pthread_mutexattr_destroy( NULL );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutexattr_destroy - EINVAL (not initialized)" );
status = pthread_mutexattr_destroy( &destroyed_attr );
rtems_test_assert( status == EINVAL );
/* error cases for set and get pshared attribute */
empty_line();
puts( "Init: pthread_mutexattr_getpshared - EINVAL (NULL attr)" );
status = pthread_mutexattr_getpshared( NULL, &pshared );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutexattr_getpshared - EINVAL (NULL pshared)" );
status = pthread_mutexattr_getpshared( &attr, NULL );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutexattr_getpshared - EINVAL (not initialized)" );
status = pthread_mutexattr_getpshared( &destroyed_attr, &pshared );
rtems_test_assert( status == EINVAL );
pshared = PTHREAD_PROCESS_PRIVATE;
puts( "Init: pthread_mutexattr_setpshared - EINVAL (NULL attr)" );
status = pthread_mutexattr_setpshared( NULL, pshared );
rtems_test_assert( status == EINVAL );
pshared = PTHREAD_PROCESS_PRIVATE;
puts( "Init: pthread_mutexattr_setpshared - EINVAL (not initialized)" );
status = pthread_mutexattr_setpshared( &destroyed_attr, pshared );
rtems_test_assert( status == EINVAL );
/* error cases for set and get protocol attribute */
empty_line();
puts( "Init: pthread_mutexattr_getprotocol - EINVAL (NULL attr)" );
status = pthread_mutexattr_getprotocol( NULL, &protocol );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutexattr_getprotocol - EINVAL (NULL protocol)" );
status = pthread_mutexattr_getprotocol( &attr, NULL );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutexattr_getprotocol - EINVAL (not initialized)" );
status = pthread_mutexattr_getprotocol( &destroyed_attr, &protocol );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutexattr_setprotocol - EINVAL (NULL attr)" );
status = pthread_mutexattr_setprotocol( NULL, PTHREAD_PRIO_NONE );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutexattr_setprotocol - EINVAL (invalid protocol)" );
status = pthread_mutexattr_setprotocol( &attr, -1 );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutexattr_setprotocol - EINVAL (not initialized)" );
status = pthread_mutexattr_setprotocol( &destroyed_attr, -1 );
rtems_test_assert( status == EINVAL );
/* error cases for set and get prioceiling attribute */
empty_line();
puts( "Init: pthread_mutexattr_getprioceiling - EINVAL (NULL attr)" );
status = pthread_mutexattr_getprioceiling( NULL, &ceiling );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutexattr_getprioceiling - EINVAL (NULL prioceiling)" );
status = pthread_mutexattr_getprioceiling( &attr, NULL );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutexattr_getprioceiling - EINVAL (not initialized)" );
status = pthread_mutexattr_getprioceiling( &destroyed_attr, &ceiling );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutexattr_setprioceiling - EINVAL (NULL attr)" );
status = pthread_mutexattr_setprioceiling( NULL, 128 );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutexattr_setprioceiling - EINVAL (invalid priority)" );
status = pthread_mutexattr_setprioceiling( &attr, 512 );
if ( status != EINVAL )
printf( "status = %d\n", status );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutexattr_setprioceiling - EINVAL (not initialized)" );
status = pthread_mutexattr_setprioceiling( &destroyed_attr, -1 );
rtems_test_assert( status == EINVAL );
/* create a thread */
status = pthread_create( &Task_id, NULL, Task_1, NULL );
rtems_test_assert( !status );
/* now try some basic mutex operations */
empty_line();
puts( "Init: pthread_mutex_init - EINVAL (NULL mutex_id)" );
status = pthread_mutex_init( NULL, &attr );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutex_init - EINVAL (not initialized attr)" );
status = pthread_mutex_init( &Mutex_id, &destroyed_attr );
rtems_test_assert( status == EINVAL );
/* must get around error checks in attribute set routines */
attr.protocol = -1;
puts( "Init: pthread_mutex_init - EINVAL (bad protocol)" );
status = pthread_mutex_init( &Mutex_id, &attr );
rtems_test_assert( status == EINVAL );
/* must get around error checks in attribute set routines */
attr.protocol = PTHREAD_PRIO_INHERIT;
attr.prio_ceiling = -1;
puts( "Init: pthread_mutex_init - EINVAL (bad priority ceiling)" );
status = pthread_mutex_init( &Mutex_id, &attr );
rtems_test_assert( status == EINVAL );
/* must get around various error checks before checking bad scope */
puts( "Init: Resetting mutex attributes" );
status = pthread_mutexattr_init( &attr );
rtems_test_assert( !status );
puts( "Init: pthread_mutex_init - ENOSYS (process wide scope)" );
attr.process_shared = PTHREAD_PROCESS_SHARED;
status = pthread_mutex_init( &Mutex_id, &attr );
rtems_test_assert( status == ENOSYS );
puts( "Init: pthread_mutex_init - EINVAL (invalid scope)" );
attr.process_shared = -1;
status = pthread_mutex_init( &Mutex_id, &attr );
rtems_test_assert( status == EINVAL );
/* bad kind */
status = pthread_mutexattr_init( &attr );
rtems_test_assert( !status );
puts( "Init: pthread_mutex_init - EINVAL (invalid type)" );
attr.type = -1;
status = pthread_mutex_init( &Mutex_id, &attr );
rtems_test_assert( status == EINVAL );
/* now set up for a success pthread_mutex_init */
puts( "Init: Resetting mutex attributes" );
status = pthread_mutexattr_init( &attr );
rtems_test_assert( !status );
puts( "Init: Changing mutex attributes" );
status = pthread_mutexattr_setprotocol( &attr, PTHREAD_PRIO_INHERIT );
rtems_test_assert( !status );
status = pthread_mutexattr_setprioceiling(
&attr,
(sched_get_priority_max(SCHED_FIFO) / 2) + 1
);
rtems_test_assert( !status );
status = pthread_mutexattr_setpshared( &attr, PTHREAD_PROCESS_SHARED );
rtems_test_assert( !status );
Print_mutexattr( "Init: ", &attr );
puts( "Init: Resetting mutex attributes" );
status = pthread_mutexattr_init( &attr );
rtems_test_assert( !status );
/*
* Set the protocol to priority ceiling so the owner check happens
* and the EPERM test (later) will work.
*/
status = pthread_mutexattr_setprotocol( &attr, PTHREAD_PRIO_INHERIT );
rtems_test_assert( !status );
puts( "Init: pthread_mutex_init - SUCCESSFUL" );
status = pthread_mutex_init( &Mutex_id, &attr );
if ( status )
printf( "status = %d\n", status );
rtems_test_assert( !status );
/*
* This is not required to be an error and when it is, there are
* behavioral conflicts with other implementations.
*/
puts( "Init: pthread_mutex_init - EBUSY (reinitialize an existing mutex) - skipped" );
#if 0
status = pthread_mutex_init( &Mutex_id, &attr );
if ( !status )
printf( "status = %d\n", status );
rtems_test_assert( status == EBUSY );
#endif
puts( "Init: pthread_mutex_trylock - EINVAL (illegal ID)" );
status = pthread_mutex_trylock( &Mutex_bad_id );
if ( status != EINVAL )
printf( "status = %d\n", status );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutex_trylock - SUCCESSFUL" );
status = pthread_mutex_trylock( &Mutex_id );
if ( status )
printf( "status = %d\n", status );
rtems_test_assert( !status );
puts( "Init: pthread_mutex_trylock - EDEADLK (already locked)" );
status = pthread_mutex_trylock( &Mutex_id );
if ( status != EBUSY )
printf( "status = %d\n", status );
rtems_test_assert( status == EBUSY );
puts( "Init: pthread_mutex_lock - EINVAL (NULL id)" );
status = pthread_mutex_lock( NULL );
if ( status != EINVAL )
printf( "status = %d\n", status );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutex_unlock - EINVAL (NULL id)" );
status = pthread_mutex_unlock( NULL );
if ( status != EINVAL )
printf( "status = %d\n", status );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutex_lock - EDEADLK (already locked)" );
status = pthread_mutex_lock( &Mutex_id );
if ( status != EDEADLK )
printf( "status = %d\n", status );
rtems_test_assert( status == EDEADLK );
puts( "Init: Sleep 1 second" );
sleep( 1 );
/* switch to task 1 */
puts( "Init: pthread_mutex_unlock - EINVAL (invalid id)" );
status = pthread_mutex_unlock( &Mutex_bad_id );
if ( status != EINVAL )
printf( "status = %d\n", status );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutex_unlock - SUCCESSFUL" );
status = pthread_mutex_unlock( &Mutex_id );
if ( status )
printf( "status = %d\n", status );
rtems_test_assert( !status );
puts( "Init: pthread_mutex_unlock - EPERM (not owner)" );
status = pthread_mutex_unlock( &Mutex_id );
if ( status != EPERM )
printf( "status = %d\n", status );
rtems_test_assert( status == EPERM );
puts( "Init: pthread_mutex_timedlock - time out in 1/2 second" );
calculate_abstimeout( ×, 0, (TOD_NANOSECONDS_PER_SECOND / 2) );
status = pthread_mutex_timedlock( &Mutex_id, × );
if ( status != ETIMEDOUT )
printf( "status = %d\n", status );
rtems_test_assert( status == ETIMEDOUT );
puts( "Init: pthread_mutex_timedlock - time out in the past" );
calculate_abstimeout( ×, -1, (TOD_NANOSECONDS_PER_SECOND / 2) );
status = pthread_mutex_timedlock( &Mutex_id, × );
if ( status != ETIMEDOUT )
printf( "status = %d\n", status );
rtems_test_assert( status == ETIMEDOUT );
/* switch to idle */
puts( "Init: pthread_mutex_timedlock - EAGAIN (timeout)" );
/* destroy a mutex */
empty_line();
puts( "Init: pthread_mutex_init - SUCCESSFUL" );
status = pthread_mutex_init( &Mutex2_id, &attr );
if ( status )
printf( "status = %d\n", status );
rtems_test_assert( !status );
puts( "Init: pthread_mutex_init - EAGAIN (too many)" );
status = pthread_mutex_init( &Mutex3_id, &attr );
rtems_test_assert( status == EAGAIN );
puts( "Init: pthread_mutexattr_destroy - SUCCESSFUL" );
status = pthread_mutexattr_destroy( &attr );
rtems_test_assert( !status );
puts( "Init: pthread_mutex_destroy - SUCCESSFUL" );
status = pthread_mutex_destroy( &Mutex2_id );
rtems_test_assert( !status );
puts( "Init: pthread_mutex_destroy - EINVAL (invalid id)" );
status = pthread_mutex_destroy( &Mutex_bad_id );
rtems_test_assert( status == EINVAL );
/* destroy a busy mutex */
empty_line();
puts( "Init: pthread_mutexattr_init - SUCCESSFUL" );
status = pthread_mutexattr_init( &attr );
rtems_test_assert( !status );
puts( "Init: pthread_mutex_init - SUCCESSFUL" );
status = pthread_mutex_init( &Mutex2_id, &attr );
rtems_test_assert( !status );
puts( "Init: pthread_mutex_trylock - SUCCESSFUL" );
status = pthread_mutex_trylock( &Mutex2_id );
if ( status )
printf( "status = %d\n", status );
rtems_test_assert( !status );
puts( "Init: pthread_mutex_destroy - EBUSY (already locked)" );
status = pthread_mutex_destroy( &Mutex2_id );
if ( status != EBUSY )
printf( "status = %d\n", status );
rtems_test_assert( status == EBUSY );
puts( "Init: pthread_mutex_unlock - SUCCESSFUL" );
status = pthread_mutex_unlock( &Mutex2_id );
rtems_test_assert( !status );
puts( "Init: pthread_mutex_destroy - SUCCESSFUL" );
status = pthread_mutex_destroy( &Mutex2_id );
rtems_test_assert( !status );
/* priority inherit mutex */
empty_line();
puts( "Init: pthread_mutexattr_init - SUCCESSFUL" );
status = pthread_mutexattr_init( &attr );
rtems_test_assert( !status );
puts(
"Init: pthread_mutexattr_setprotocol - SUCCESSFUL (PTHREAD_PRIO_INHERIT)"
);
status = pthread_mutexattr_setprotocol( &attr, PTHREAD_PRIO_INHERIT );
rtems_test_assert( !status );
puts( "Init: pthread_mutex_init - SUCCESSFUL" );
status = pthread_mutex_init( &Mutex2_id, &attr );
rtems_test_assert( !status );
puts( "Init: pthread_mutex_trylock - SUCCESSFUL" );
status = pthread_mutex_trylock( &Mutex2_id );
rtems_test_assert( !status );
/* create a thread at a lower priority */
status = pthread_create( &Task2_id, NULL, Task_2, NULL );
rtems_test_assert( !status );
/* set priority of Task2 to highest priority */
param.sched_priority = sched_get_priority_max( SCHED_FIFO );
puts( "Init: pthread_setschedparam - Setting Task2 priority to highest" );
status = pthread_setschedparam( Task2_id, SCHED_FIFO, ¶m );
rtems_test_assert( !status );
/* switching to Task2 */
status = pthread_getschedparam( pthread_self(), &policy, ¶m );
rtems_test_assert( !status );
printf( "Init: pthread_getschedparam - priority = %d\n", param.sched_priority);
puts( "Init: pthread_mutex_unlock - SUCCESSFUL" );
status = pthread_mutex_unlock( &Mutex2_id );
rtems_test_assert( !status );
puts( "Init: pthread_mutexattr_destroy - SUCCESSFUL" );
status = pthread_mutexattr_destroy( &attr );
rtems_test_assert( !status );
puts( "Init: pthread_mutex_destroy - SUCCESSFUL" );
status = pthread_mutex_destroy( &Mutex2_id );
rtems_test_assert( !status );
/* priority ceiling mutex */
empty_line();
puts( "Init: pthread_mutexattr_init - SUCCESSFUL" );
status = pthread_mutexattr_init( &attr );
rtems_test_assert( !status );
puts(
"Init: pthread_mutexattr_setprotocol - SUCCESSFUL (PTHREAD_PRIO_PROTECT)"
);
status = pthread_mutexattr_setprotocol( &attr, PTHREAD_PRIO_PROTECT );
rtems_test_assert( !status );
puts( "Init: pthread_mutex_init - SUCCESSFUL" );
status = pthread_mutex_init( &Mutex2_id, &attr );
rtems_test_assert( !status );
puts( "Init: pthread_mutex_getprioceiling - EINVAL (invalid id)" );
status = pthread_mutex_getprioceiling( &Mutex_bad_id, &ceiling );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutex_getprioceiling - EINVAL (NULL ceiling)" );
status = pthread_mutex_getprioceiling( &Mutex2_id, NULL );
rtems_test_assert( status == EINVAL );
status = pthread_mutex_getprioceiling( &Mutex2_id, &ceiling );
rtems_test_assert( !status );
printf( "Init: pthread_mutex_getprioceiling - %d\n", ceiling );
puts( "Init: pthread_mutex_setprioceiling - EINVAL (invalid id)" );
status = pthread_mutex_setprioceiling( &Mutex_bad_id, 200, &old_ceiling );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutex_setprioceiling - EINVAL (illegal priority)" );
status = pthread_mutex_setprioceiling( &Mutex2_id, 512, &old_ceiling );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutex_setprioceiling - EINVAL (NULL ceiling)" );
status = pthread_mutex_setprioceiling( &Mutex2_id, 128, NULL );
rtems_test_assert( status == EINVAL );
/* normal cases of set priority ceiling */
priority = sched_get_priority_max( SCHED_FIFO );
priority = (priority == 254) ? 200 : 13;
printf( "Init: pthread_mutex_setprioceiling - new ceiling = %d\n", priority );
status = pthread_mutex_setprioceiling( &Mutex2_id, priority, &old_ceiling );
rtems_test_assert( !status );
printf(
"Init: pthread_mutex_setprioceiling - old ceiling = %d\n",old_ceiling
);
status = pthread_getschedparam( pthread_self(), &policy, ¶m );
rtems_test_assert( !status );
printf(
"Init: pthread_getschedparam - priority = %d\n", param.sched_priority
);
puts( "Init: pthread_mutex_trylock - SUCCESSFUL" );
status = pthread_mutex_trylock( &Mutex2_id );
rtems_test_assert( !status );
status = pthread_getschedparam( pthread_self(), &policy, ¶m );
rtems_test_assert( !status );
printf(
"Init: pthread_getschedparam - priority = %d\n", param.sched_priority
);
/* create a thread at a higher priority */
status = pthread_create( &Task3_id, NULL, Task_3, NULL );
rtems_test_assert( !status );
/* set priority of Task3 to highest priority */
param.sched_priority = --priority;
status = pthread_setschedparam( Task3_id, SCHED_FIFO, ¶m );
rtems_test_assert( !status );
puts( "Init: pthread_setschedparam - set Task3 priority to highest" );
/* DOES NOT SWITCH to Task3 */
puts( "Init: Sleep 1 second" );
rtems_test_assert( !status );
sleep( 1 );
/* switch to task 3 */
puts( "Init: pthread_mutex_unlock - SUCCESSFUL" );
status = pthread_mutex_unlock( &Mutex2_id );
rtems_test_assert( !status );
status = pthread_mutex_getprioceiling( &Mutex2_id, &ceiling );
rtems_test_assert( !status );
printf( "Init: pthread_mutex_getprioceiling- ceiling = %d\n", ceiling );
/* set priority of Init to highest priority */
param.sched_priority = sched_get_priority_max(SCHED_FIFO);
status = pthread_setschedparam( Init_id, SCHED_FIFO, ¶m );
rtems_test_assert( !status );
puts( "Init: pthread_setschedparam - set Init priority to highest" );
puts( "Init: pthread_mutex_lock - EINVAL (priority ceiling violation)" );
status = pthread_mutex_lock( &Mutex2_id );
if ( status != EINVAL )
printf( "status = %d\n", status );
rtems_test_assert( status == EINVAL );
/* mutexinit.c: Initialising recursive mutex */
puts( "Init: Recursive Mutex" );
status = pthread_mutex_destroy( &Mutex2_id );
if( status )
printf( "status mutex destroy:%d\n", status );
status = pthread_mutexattr_init( &attr );
if( status )
printf( "status mutexattr:%d\n", status );
attr.recursive=true;
status = pthread_mutex_init( &Mutex2_id, &attr );
if ( status )
printf( "status recursive mutex :%d\n", status );
rtems_test_assert( !status );
TEST_END();
rtems_test_exit( 0 );
return NULL; /* just so the compiler thinks we returned something */
}
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);
}
int pthread_mutexattr_test(){
pthread_mutexattr_t attr;
int tmp;
int i;
printf("Test pthread_mutexattr_init()...");
if ( pthread_mutexattr_init(&attr) < 0 ){
fflush(stdout);
perror("failed");
return -1;
}
printf("passed\n");
printf("Test pthread_mutexattr_set/getprioceiling()...");
for(i = sched_get_priority_min(SCHED_OTHER); i <= sched_get_priority_max(SCHED_OTHER); i++ ){
if ( pthread_mutexattr_setprioceiling(&attr, i) < 0 ){
fflush(stdout);
perror("failed");
return -1;
}
if ( pthread_mutexattr_getprioceiling(&attr, &tmp) < 0 ){
fflush(stdout);
perror("failed");
return -1;
}
if ( tmp != i ){
printf("failed to set/get (%d != %d)\n", tmp, i);
return -1;
}
}
printf("passed\n");
if ( set_get_test("pthread_mutexattr_set/getprotocol()",
(int (*)(void*,int))pthread_mutexattr_setprotocol,
(int (*)(void*,int*))pthread_mutexattr_getprotocol,
&attr,
protocols,
PROTOCOLS_TOTAL,
0) ){
return -1;
}
printf("Test pthread_mutexattr_set/getpshared()...");
tmp = 1;
if ( pthread_mutexattr_setpshared(&attr, tmp) < 0 ){
fflush(stdout);
perror("failed");
return -1;
}
if ( pthread_mutexattr_getpshared(&attr, &tmp) < 0 ){
fflush(stdout);
perror("failed");
return -1;
}
if ( tmp != 1 ){
fflush(stdout);
perror("failed");
return -1;
}
printf("passed\n");
if ( set_get_test("pthread_mutexattr_set/gettype()",
(int (*)(void*,int))pthread_mutexattr_settype,
(int (*)(void*,int*))pthread_mutexattr_gettype,
&attr,
types,
TYPES_TOTAL,
0) ){
return -1;
}
printf("Test pthread_mutexattr_destroy()...");
if ( pthread_mutexattr_destroy(&attr) < 0 ){
fflush(stdout);
perror("failed");
return -1;
}
printf("passed\n");
printf("Stress Test pthread_mutexattr_destroy()...");
if ( pthread_mutexattr_destroy(&attr) == 0 ){
printf("should have failed\n");
return -1;
}
errno = 0;
printf("passed\n");
return 0;
}