void test_mutex_setprioceiling(void) { benchmark_timer_t end_time; int status; int old_ceiling; benchmark_timer_initialize(); status = pthread_mutex_setprioceiling( &MutexId, 5, &old_ceiling ); end_time = benchmark_timer_read(); rtems_test_assert( status == 0 ); put_time( "pthread_mutex_setprioceiling: only case", end_time, 1, /* Only executed once */ 0, 0 ); }
int main (void) { pthread_mutexattr_t at; pthread_mutexattr_init (&at); pthread_mutexattr_settype (&at, PTHREAD_MUTEX_RECURSIVE); pthread_mutexattr_setprotocol (&at, PTHREAD_PRIO_PROTECT); pthread_mutex_init (&m1, &at); pthread_mutex_lock (&m1); printf ("Locked 1\n"); // pthread_mutex_lock (&m1); printf ("Locked 2\n"); pthread_mutex_setprioceiling (&m1, 15, 0); printf ("Ceiling set to 15\n"); // pthread_mutex_unlock (&m1); printf ("Unlocked 2\n"); pthread_mutex_unlock (&m1); printf ("Unlocked 1\n"); return 0; }
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; }
static void mutex_prioceiling_test (void) { const int test_thread_id = 0; /* ID of test thread */ pthread_mutexattr_t mattr; struct sched_param param; pthread_mutex_t m[3]; mutex_kind_t mkind; int i, ret, policy, my_prio, old_ceiling; log ("Testing priority ceilings\n"); log ("-------------------------\n"); for (mkind = M_POSIX; mkind <= M_SS2_RECURSIVE; mkind++) { log (" Protype PTHREAD_PRIO_PROTECT, Type %s\n", mutextype_strs[mkind]); /* * Initialize and create a mutex. */ assert (pthread_mutexattr_init (&mattr) == 0); /* Get this threads current priority. */ assert (pthread_getschedparam (pthread_self(), &policy, ¶m) == 0); my_prio = param.sched_priority; /* save for later use */ log_trace ("Current scheduling policy %d, priority %d\n", policy, my_prio); /* * Initialize and create 3 priority protection mutexes with * default (max priority) ceilings. */ assert (pthread_mutexattr_setprotocol(&mattr, PTHREAD_PRIO_PROTECT) == 0); /* * Ensure that the first mutex type is a POSIX * compliant mutex. */ if (mkind != M_POSIX) { assert (pthread_mutexattr_settype (&mattr, mutex_types[mkind]) == 0); } for (i = 0; i < 3; i++) assert (pthread_mutex_init (&m[i], &mattr) == 0); /* * Set the ceiling priorities for the 3 priority protection * mutexes to, 5 less than, equal to, and 5 greater than, * this threads current priority. */ for (i = 0; i < 3; i++) assert (pthread_mutex_setprioceiling (&m[i], my_prio - 5 + 5*i, &old_ceiling) == 0); /* * Check that if we attempt to take a mutex whose priority * ceiling is lower than our priority, we get an error. */ log (" Lock with ceiling priority < thread priority - "); ret = pthread_mutex_lock (&m[0]); check_result (/* expected */ EINVAL, ret); if (ret == 0) pthread_mutex_unlock (&m[0]); /* * Check that we can take a mutex whose priority ceiling * is equal to our priority. */ log (" Lock with ceiling priority = thread priority - "); ret = pthread_mutex_lock (&m[1]); check_result (/* expected */ 0, ret); if (ret == 0) pthread_mutex_unlock (&m[1]); /* * Check that we can take a mutex whose priority ceiling * is higher than our priority. */ log (" Lock with ceiling priority > thread priority - "); ret = pthread_mutex_lock (&m[2]); check_result (/* expected */ 0, ret); if (ret == 0) pthread_mutex_unlock (&m[2]); /* * Have the test thread go into a busy loop for 5 seconds * and see that it doesn't block this thread (since the * priority ceiling of mutex 0 and the priority of the test * thread are both less than the priority of this thread). */ log (" Preemption with ceiling priority < thread " "priority - "); /* Have the test thread take mutex 0. */ send_mutex_cmd (test_thread_id, CMD_TAKE_MUTEX, &m[0]); sleep (1); log_trace ("Sending busy command.\n"); send_cmd (test_thread_id, CMD_BUSY_LOOP); log_trace ("Busy sent, yielding\n"); pthread_yield (); log_trace ("Returned from yield.\n"); if (states[test_thread_id].flags & (FLAGS_IS_BUSY | FLAGS_WAS_BUSY)) log_error ("test thread inproperly preempted us.\n"); else { /* Let the thread finish its busy loop. */ sleep (6); if ((states[test_thread_id].flags & FLAGS_WAS_BUSY) == 0) log_error ("test thread never finished.\n"); else log_pass (); } states[test_thread_id].flags &= ~FLAGS_WAS_BUSY; /* Have the test thread release mutex 0. */ send_cmd (test_thread_id, CMD_RELEASE_ALL); sleep (1); /* * Have the test thread go into a busy loop for 5 seconds * and see that it preempts this thread (since the priority * ceiling of mutex 1 is the same as the priority of this * thread). The test thread should not run to completion * as its time quantum should expire before the 5 seconds * are up. */ log (" Preemption with ceiling priority = thread " "priority - "); /* Have the test thread take mutex 1. */ send_mutex_cmd (test_thread_id, CMD_TAKE_MUTEX, &m[1]); sleep (1); log_trace ("Sending busy\n"); send_cmd (test_thread_id, CMD_BUSY_LOOP); log_trace ("Busy sent, yielding\n"); pthread_yield (); log_trace ("Returned from yield.\n"); if ((states[test_thread_id].flags & FLAGS_IS_BUSY) == 0) log_error ("test thread did not switch in on yield.\n"); else if (states[test_thread_id].flags & FLAGS_WAS_BUSY) log_error ("test thread ran to completion.\n"); else { /* Let the thread finish its busy loop. */ sleep (6); if ((states[test_thread_id].flags & FLAGS_WAS_BUSY) == 0) log_error ("test thread never finished.\n"); else log_pass (); } states[test_thread_id].flags &= ~FLAGS_WAS_BUSY; /* Have the test thread release mutex 1. */ send_cmd (test_thread_id, CMD_RELEASE_ALL); sleep (1); /* * Set the scheduling policy of the test thread to SCHED_FIFO * and have it go into a busy loop for 5 seconds. This * thread is SCHED_RR, and since the priority ceiling of * mutex 1 is the same as the priority of this thread, the * test thread should run to completion once it is switched * in. */ log (" SCHED_FIFO scheduling and ceiling priority = " "thread priority - "); param.sched_priority = states[test_thread_id].priority; assert (pthread_setschedparam (states[test_thread_id].tid, SCHED_FIFO, ¶m) == 0); /* Have the test thread take mutex 1. */ send_mutex_cmd (test_thread_id, CMD_TAKE_MUTEX, &m[1]); sleep (1); log_trace ("Sending busy\n"); send_cmd (test_thread_id, CMD_BUSY_LOOP); log_trace ("Busy sent, yielding\n"); pthread_yield (); log_trace ("Returned from yield.\n"); if ((states[test_thread_id].flags & FLAGS_WAS_BUSY) == 0) { log_error ("test thread did not run to completion.\n"); /* Let the thread finish it's busy loop. */ sleep (6); } else log_pass (); states[test_thread_id].flags &= ~FLAGS_WAS_BUSY; /* Restore the test thread scheduling parameters. */ param.sched_priority = states[test_thread_id].priority; assert (pthread_setschedparam (states[test_thread_id].tid, SCHED_RR, ¶m) == 0); /* Have the test thread release mutex 1. */ send_cmd (test_thread_id, CMD_RELEASE_ALL); sleep (1); /* * Have the test thread go into a busy loop for 5 seconds * and see that it preempts this thread (since the priority * ceiling of mutex 2 is the greater than the priority of * this thread). The test thread should run to completion * and block this thread because its active priority is * higher. */ log (" SCHED_FIFO scheduling and ceiling priority > " "thread priority - "); /* Have the test thread take mutex 2. */ send_mutex_cmd (test_thread_id, CMD_TAKE_MUTEX, &m[2]); sleep (1); log_trace ("Sending busy\n"); send_cmd (test_thread_id, CMD_BUSY_LOOP); log_trace ("Busy sent, yielding\n"); pthread_yield (); log_trace ("Returned from yield.\n"); if ((states[test_thread_id].flags & FLAGS_IS_BUSY) != 0) { log_error ("test thread did not run to completion.\n"); /* Let the thread finish it's busy loop. */ sleep (6); } else if ((states[test_thread_id].flags & FLAGS_WAS_BUSY) == 0) log_error ("test thread never finished.\n"); else log_pass (); states[test_thread_id].flags &= ~FLAGS_WAS_BUSY; /* Have the test thread release mutex 2. */ send_cmd (test_thread_id, CMD_RELEASE_ALL); sleep (1); /* Destroy the mutexes. */ for (i = 0; i < 3; i++) assert (pthread_mutex_destroy (&m[i]) == 0); } }
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 */ }