void *BlockingThread( void *argument ) { int sc; puts( "BlockingThread - pthread_cond_wait with mutex not locked - EPERM" ); sc = pthread_cond_wait( &Condition, &Mutex1 ); fatal_posix_service_status( sc, EPERM, "mutex1 not locked" ); sc = pthread_mutex_lock( &Mutex1 ); fatal_posix_service_status( sc, 0, "mutex1 lock" ); puts( "BlockingThread - pthread_cond_wait on Mutex1 - OK" ); sc = pthread_cond_wait( &Condition, &Mutex1 ); printf( "ERROR - BlockingThread returned from pthread_cond_wait! (rc=%d/%s)\n", sc, strerror(sc) ); rtems_test_exit( 0 ); return NULL; }
/* * A simple test of posix_memalign */ static void test_posix_memalign(void) { void *p1; int i; int sc; int maximumShift; /* * posix_memalign() is declared as never having a NULL first parameter. * We need to explicitly disable this compiler warning to make this code * warning free. */ COMPILER_DIAGNOSTIC_SETTINGS_PUSH COMPILER_DIAGNOSTIC_SETTINGS_DISABLE_NONNULL puts( "posix_memalign - NULL return pointer -- EINVAL" ); sc = posix_memalign( NULL, 32, 8 ); fatal_posix_service_status( sc, EINVAL, "posix_memalign NULL pointer" ); COMPILER_DIAGNOSTIC_SETTINGS_POP puts( "posix_memalign - alignment of 0 -- EINVAL" ); sc = posix_memalign( &p1, 0, 8 ); fatal_posix_service_status( sc, EINVAL, "posix_memalign alignment of 0" ); puts( "posix_memalign - alignment of 2-- EINVAL" ); sc = posix_memalign( &p1, 2, 8 ); fatal_posix_service_status( sc, EINVAL, "posix_memalign alignment of 2" ); maximumShift = (sizeof(size_t) * CHAR_BIT) - 1; for ( i=sizeof(void *) ; i<maximumShift ; i++ ) { size_t alignment = 1 << i; p1 = NULL; /* Initialize p1 to aovid used uninitialized */ printf( "posix_memalign - alignment of %zd -- OK\n", alignment); sc = posix_memalign( &p1, alignment, 8 ); if ( sc == ENOMEM ) { printf( "posix_memalign - ran out of memory trying %zd\n", alignment ); break; } posix_service_failed( sc, "posix_memalign alignment OK" ); free( p1 ); } for ( ; i<maximumShift ; i++ ) { size_t alignment = 1 << i; printf( "posix_memalign - alignment of %zd -- SKIPPED\n", alignment); } }
void *POSIX_Init( void *argument ) { int sc; pthread_mutex_t mutex1; pthread_mutex_t mutex2; int prioceiling; TEST_BEGIN(); /* path using mutex get with interrupts disabled */ mutex1 = PTHREAD_MUTEX_INITIALIZER; mutex2 = PTHREAD_MUTEX_INITIALIZER; puts( "Init - pthread_mutex_lock - auto initialize - OK" ); sc = pthread_mutex_lock( &mutex1 ); fatal_posix_service_status( sc, 0, "mutex lock OK" ); puts( "Init - pthread_mutex_lock - auto initialize - EINVAL" ); sc = pthread_mutex_lock( &mutex2 ); fatal_posix_service_status( sc, EINVAL, "mutex lock EINVAL" ); puts( "Init - pthread_mutex_unlock - OK" ); sc = pthread_mutex_unlock( &mutex1 ); fatal_posix_service_status( sc, 0, "mutex unlock OK" ); puts( "Init - pthread_mutex_destroy - OK" ); sc = pthread_mutex_destroy( &mutex1 ); fatal_posix_service_status( sc, 0, "mutex destroy OK" ); /* path using mutex get with dispatching disabled */ mutex1 = PTHREAD_MUTEX_INITIALIZER; mutex2 = PTHREAD_MUTEX_INITIALIZER; puts( "Init - pthread_mutex_getprioceiling - auto initialize - OK" ); prioceiling = 1; sc = pthread_mutex_getprioceiling( &mutex1, &prioceiling ); fatal_posix_service_status( sc, 0, "mutex getprioceiling OK" ); rtems_test_assert( prioceiling == 0 ); puts( "Init - pthread_mutex_getprioceiling - auto initialize - EINVAL" ); prioceiling = 1; sc = pthread_mutex_getprioceiling( &mutex2, &prioceiling ); fatal_posix_service_status( sc, EINVAL, "mutex getprioceiling EINVAL" ); rtems_test_assert( prioceiling == 1 ); puts( "Init - pthread_mutex_destroy - OK" ); sc = pthread_mutex_destroy( &mutex1 ); fatal_posix_service_status( sc, 0, "mutex destroy OK" ); TEST_END(); rtems_test_exit( 0 ); return NULL; /* just so the compiler thinks we returned something */ }
/* * A simple test of posix_memalign */ static void test_posix_memalign(void) { void *p1; int i; int sc; int maximumShift; puts( "posix_memalign - NULL return pointer -- EINVAL" ); sc = posix_memalign( NULL, 32, 8 ); fatal_posix_service_status( sc, EINVAL, "posix_memalign NULL pointer" ); puts( "posix_memalign - alignment of 0 -- EINVAL" ); sc = posix_memalign( &p1, 0, 8 ); fatal_posix_service_status( sc, EINVAL, "posix_memalign alignment of 0" ); puts( "posix_memalign - alignment of 2-- EINVAL" ); sc = posix_memalign( &p1, 2, 8 ); fatal_posix_service_status( sc, EINVAL, "posix_memalign alignment of 2" ); maximumShift = (sizeof(size_t) * CHAR_BIT) - 1; for ( i=sizeof(void *) ; i<maximumShift ; i++ ) { size_t alignment = 1 << i; printf( "posix_memalign - alignment of %zd -- OK\n", alignment); sc = posix_memalign( &p1, alignment, 8 ); if ( sc == ENOMEM ) { printf( "posix_memalign - ran out of memory trying %zd\n", alignment ); break; } posix_service_failed( sc, "posix_memalign alignment OK" ); free( p1 ); } for ( ; i<maximumShift ; i++ ) { size_t alignment = 1 << i; printf( "posix_memalign - alignment of %zd -- SKIPPED\n", alignment); } }
void *POSIX_Init( void *argument ) { int sc; pthread_t Thread; puts( "\n\n*** POSIX TEST -- CONDITION VARIABLE 01 ***" ); puts( "Init - pthread_mutex_init - Mutex1 - OK" ); sc = pthread_mutex_init( &Mutex1, NULL ); fatal_posix_service_status( sc, 0, "mutex1 create ok" ); puts( "Init - pthread_mutex_init - Mutex2 - OK" ); sc = pthread_mutex_init( &Mutex2, NULL ); fatal_posix_service_status( sc, 0, "mutex2 create ok" ); puts( "Init - pthread_cond_init - Condition - OK" ); sc = pthread_cond_init( &Condition, NULL ); fatal_posix_service_status( sc, 0, "Condition create ok" ); puts( "Init - pthread_create - OK" ); sc = pthread_create( &Thread, NULL, BlockingThread, NULL ); fatal_posix_service_status( sc, 0, "Thread create ok" ); puts( "Init - sleep to let BlockingThread run" ); sleep(1); puts( "Init - pthread_cond_wait on Mutex2 - EINVAL" ); sc = pthread_cond_wait( &Condition, &Mutex2 ); fatal_posix_service_status( sc, EINVAL, "cond_wait EINVAL" ); puts( "*** END OF POSIX TEST CONDITION VARIABLE 01 ***" ); rtems_test_exit( 0 ); return NULL; /* just so the compiler thinks we returned something */ }
void *POSIX_Init( void *argument ) { int status; int value; int i; sem_t sems[MAX_SEMS]; sem_t sem2; sem_t *n_sem1; sem_t *n_sem2; struct timespec waittime; char failure_msg[80]; puts( "\n\n*** POSIX SEMAPHORE MANAGER TEST 1 ***" ); puts( "Init: sem_init - UNSUCCESSFUL (EINVAL)" ); status = sem_init(NULL, 0, 1); fatal_posix_service_status( status, -1, "sem_init error return status"); fatal_posix_service_status( errno, EINVAL, "sem_init errorno EINVAL" ); puts( "Init: sem_init - SUCCESSFUL" ); for (i = 0; i < MAX_SEMS; i++) { status = sem_init(&sems[i], 0, i); sprintf(failure_msg, "sem_init %d", i ); fatal_posix_service_status( status, 0, failure_msg); } puts( "Init: sem_init - UNSUCCESSFUL (ENOSPC)" ); status = sem_init(&sem2, 0, 1); fatal_posix_service_status( status, -1, "sem_init error return status"); fatal_posix_service_status( errno, ENOSPC, "sem_init errorno ENOSPC" ); puts( "Init: sem_init - UNSUCCESSFUL (ENOSYS -- pshared not supported)" ); status = sem_init(&sem2, 1, 1); fatal_posix_service_status( status, -1, "sem_init error return status"); fatal_posix_service_status( errno, ENOSYS, "sem_init errno set to ENOSYS"); puts( "Init: sem_getvalue - SUCCESSFUL "); for (i = 0; i < MAX_SEMS; i++) { status = sem_getvalue(&sems[i], &value); sprintf( failure_msg, "sem_getvalue %d", i ); fatal_posix_service_status( status, 0, failure_msg ); fatal_posix_service_status( value, i, "sem_getvalue correct value" ); } puts( "Init: sem_getvalue - UNSUCCESSFUL "); status = sem_getvalue(&sem2, &value); fatal_posix_service_status( status, -1, "sem_getvalue error return status"); fatal_posix_service_status( errno, EINVAL, "sem_getvalue errno EINVAL"); puts( "Init: sem_destroy - SUCCESSFUL" ); status = sem_destroy(&sems[0]); fatal_posix_service_status( status, 0, "sem_destroy semaphore 0"); puts( "Init: sem_destroy - UNSUCCESSFUL (EINVAL)" ); status = sem_destroy(&sem2); fatal_posix_service_status( status, -1, "sem_destroy error return status"); fatal_posix_service_status( errno, EINVAL, "sem_destroy errno EINVAL"); puts( "Init: sem_wait - SUCCESSFUL" ); status = sem_wait(&sems[1]); fatal_posix_service_status( status, 0, "sem_wait semaphore 1"); /* sem[1].count = 0 */ puts( "Init: sem_wait - UNSUCCESSFUL (EINVAL)" ); status = sem_wait(&sem2); fatal_posix_service_status( status, -1, "sem_wait error return status"); fatal_posix_service_status( errno, EINVAL, "sem_wait errno EINVAL"); puts( "Init: sem_post - SUCCESSFUL" ); status = sem_post(&sems[1]); fatal_posix_service_status( status, 0, "sem_post semaphore 1"); /* sem[1].count = 1 */ puts( "Init: sem_wait - SUCCESSFUL (after a sem_post)" ); status = sem_wait(&sems[1]); fatal_posix_service_status( status, 0, "sem_wait semaphore 1"); /* sem[1].count = 0 */ puts( "Init: sem_trywait - SUCCESSFUL" ); status = sem_trywait(&sems[2]); fatal_posix_service_status( status, 0, "sem_trywait semaphore 2"); /* sem[2].count = 1 */ puts( "Init: sem_trywait - UNSUCCESSFUL (EAGAIN)" ); status = sem_trywait(&sems[1]); fatal_posix_service_status( status, -1, "sem_trywait error return status"); fatal_posix_service_status( errno, EAGAIN, "sem_trywait errno EAGAIN"); /* sem[1].count = 0 */ puts( "Init: sem_trywait - UNSUCCESSFUL (EINVAL)" ); status = sem_trywait(&sem2); fatal_posix_service_status( status, -1, "sem_trywait error return status"); fatal_posix_service_status( errno, EINVAL, "sem_trywait errno EINVAL"); #if 0 status = sem_post(&sems[2]); fatal_posix_service_status( status, 0, "sem_post semaphore 2"); /* sem[2].count = 2 */ #else /* sem[2].count = 1 */ #endif puts( "Init: sem_timedwait - SUCCESSFUL" ); waittime.tv_sec = time(NULL) + 1; waittime.tv_nsec = 100; status = sem_timedwait(&sems[2], &waittime); fatal_posix_service_status( status, 0, "sem_timedwait semaphore 2"); /* sem[2].count = 0 */ puts( "Init: sem_timedwait - UNSUCCESSFUL (ETIMEDOUT)" ); status = sem_timedwait(&sems[2], &waittime); fatal_posix_service_status( status, -1, "sem_timedwait error return status"); fatal_posix_service_status( errno, ETIMEDOUT, "sem_timedwait errno ETIMEDOUT"); /* * To do this case, we must be blocking when we want the semaphore. * POSIX doesn't want you to check the error if you can get the resource. */ #if 1 puts( "Init: sem_timedwait - UNSUCCESSFUL (EINVAL) -- skipping" ); #else puts( "Init: sem_timedwait - UNSUCCESSFUL (EINVAL)" ); waittime.tv_sec = 0; waittime.tv_nsec = 0x7FFFFFFF; status = sem_timedwait(&sems[2], &waittime); fatal_posix_service_status( status, -1, "sem_timedwait error return status"); fatal_posix_service_status( errno, EINVAL, "sem_init errno EINVAL"); #endif puts( "Init: sem_post - UNSUCCESSFUL (EINVAL)" ); status = sem_post(&sem2); fatal_posix_service_status( status, -1, "sem_post error return status"); fatal_posix_service_status( errno, EINVAL, "sem_post errno EINVAL"); puts( "Init: sem_destroy - SUCCESSFUL" ); for (i = 1; i < MAX_SEMS; i++) { status = sem_destroy(&sems[i]); sprintf( failure_msg, "sem_destroy %d", i ); fatal_posix_service_status( status, 0, failure_msg ); } /* Modes are currently unsupported */ /* * Validate all sem_open return paths. */ puts( "Init: sem_open - UNSUCCESSFUL (ENAMETOOLONG)" ); n_sem1 = sem_open(Get_Too_Long_Name(), O_CREAT, 0777, 1 ); fatal_posix_service_pointer_minus_one( n_sem1, "sem_open error return status"); fatal_posix_service_status( errno, ENAMETOOLONG, "sem_open errorno ENAMETOOLONG" ); puts( "Init: sem_open - sem1 SUCCESSFUL" ); n_sem1 = sem_open( "sem1",O_CREAT, 0777, 1 ); rtems_test_assert( n_sem1 != SEM_FAILED ); puts( "Init: sem_destroy - named sem1 - EINVAL" ); status = sem_destroy(n_sem1); fatal_posix_service_status( status, -1, "sem_destroy named semaphore"); fatal_posix_service_status( errno, EINVAL, "sem_destroy named semaphore"); puts( "Init: sem_open - Create an Existing sem (EEXIST)" ); n_sem2 = sem_open("sem1", O_CREAT | O_EXCL, 0777, 1); fatal_posix_service_pointer_minus_one( n_sem2, "sem_open error return status" ); fatal_posix_service_status( errno, EEXIST, "sem_open errno EEXIST"); puts( "Init: sem_open - Open new sem without create flag (ENOENT)" ); n_sem2 = sem_open("sem3", O_EXCL, 0777, 1); fatal_posix_service_pointer_minus_one( n_sem2, "sem_open error return status" ); fatal_posix_service_status( errno, ENOENT, "sem_open errno EEXIST"); /* * XXX - Could not hit the following errors: * E_POSIX_Semaphore_Create_support only fails if * ENOSYS - When semaphore is shared between processes. * ENOSPC - When out of memory. */ /* * Validate we can wait on a semaphore opened with sem_open. */ puts( "Init: sem_wait on sem1" ); status = sem_wait(n_sem1); fatal_posix_service_status( status, 0, "sem_wait opened semaphore"); /* * Validate a second open returns the same semaphore. */ puts( "Init: sem_open - Open an existing sem ( same id )" ); n_sem2 = sem_open("sem1", 0 ); rtems_test_assert( n_sem2 == n_sem1 ); /* * Unlink the semaphore, then verify an open of the same name produces a * different semaphore. */ puts( "Init: sem_unlink - sem1 SUCCESSFUL" ); status = sem_unlink( "sem1" ); fatal_posix_service_status( status, 0, "sem_unlink locked semaphore"); puts( "Init: sem_open - Reopen sem1 SUCCESSFUL with a different id" ); n_sem2 = sem_open( "sem1", O_CREAT | O_EXCL, 0777, 1); rtems_test_assert( n_sem2 != SEM_FAILED ); rtems_test_assert( n_sem2 != n_sem1 ); /* * Validate we can call close on a semaphore opened with sem_open. */ puts( "Init: sem_close (1) - SUCCESSFUL" ); status = sem_close( n_sem1 ); fatal_posix_service_status( status, 0, "sem_close semaphore"); /* * Validate it n_sem2 (the last open for sem1 name can be * correctly closed and unlinked. */ puts( "Init: sem_close (2) - SUCCESSFUL" ); status = sem_close( n_sem2 ); fatal_posix_service_status( status, 0, "sem_close semaphore"); puts( "Init: sem_unlink - sem1 (2) SUCCESSFUL" ); status = sem_unlink( "sem1" ); fatal_posix_service_status( status, 0, "sem_unlink locked semaphore"); puts( "Init: sem_close - UNSUCCESSFUL (EINVAL)" ); status = sem_close(n_sem2); fatal_posix_service_status( status, -1, "sem_close error return status"); fatal_posix_service_status( errno, EINVAL, "sem_close errno EINVAL"); puts( "Init: sem_unlink - UNSUCCESSFUL (ENOENT)" ); status = sem_unlink("sem1"); fatal_posix_service_status( status, -1, "sem_unlink error return status"); fatal_posix_service_status( errno, ENOENT, "sem_close errno EINVAL"); /* * Validate we can unlink (2) */ puts( "Init: sem_unlink (NULL) - EINVAL" ); status = sem_unlink( NULL ); fatal_posix_service_status( status, -1, "sem_unlink error return status"); fatal_posix_service_status( errno, EINVAL, "sem_unlink errno value"); puts( "Init: sem_unlink (\"\") - EINVAL" ); status = sem_unlink( "" ); fatal_posix_service_status( status, -1, "sem_unlink error return status"); fatal_posix_service_status( errno, EINVAL, "sem_unlink errno value"); /* * XXX - Cant' create location OBJECTS_ERROR or OBJECTS_REMOTE. * sem_close and sem_unlink. */ puts( "Init: sem_unlink - UNSUCCESSFUL (ENOENT)" ); status = sem_unlink("sem2"); fatal_posix_service_status( status, -1, "sem_unlink error return status"); fatal_posix_service_status( errno, ENOENT, "sem_unlink errno ENOENT"); rtems_test_assert( (status == -1) && (errno == ENOENT) ); /* Try adding in unlinking before closing... (can we still open?) */ puts( "*** END OF POSIX SEMAPHORE MANAGER TEST 1 ***" ); rtems_test_exit(0); return NULL; /* just so the compiler thinks we returned something */ }
int main(int argc, char **argv) #endif { pthread_t task; int taskparameter = 0; int sc; int old; TEST_BEGIN(); /* generate some error conditions */ puts( "Init - pthread_setcancelstate - NULL oldstate - EINVAL" ); sc = pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); fatal_posix_service_status( sc, EINVAL, "cancel state EINVAL" ); puts( "Init - pthread_setcancelstate - bad state - EINVAL" ); sc = pthread_setcancelstate(12, &old); fatal_posix_service_status( sc, EINVAL, "cancel state EINVAL" ); puts( "Init - pthread_setcanceltype - NULL oldtype - EINVAL" ); sc = pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL); fatal_posix_service_status( sc, EINVAL, "cancel type EINVAL" ); puts( "Init - pthread_setcanceltype - bad type - EINVAL" ); sc = pthread_setcanceltype(12, &old); fatal_posix_service_status( sc, EINVAL, "cancel type EINVAL" ); puts( "Init - pthread_cancel - bad ID - EINVAL" ); sc = pthread_cancel(0x100); fatal_posix_service_status( sc, EINVAL, "cancel bad Id" ); /* Start countTask deferred */ { sc = pthread_create(&task, NULL, countTaskDeferred, &taskparameter); if (sc) { perror("pthread_create: countTask"); rtems_test_exit(EXIT_FAILURE); } /* sleep for 5 seconds, then cancel it */ sleep(5); pthread_cancel(task); pthread_join(task, NULL); } /* Start countTask asynchronous */ { sc = pthread_create(&task, NULL, countTaskAsync, &taskparameter); if (sc) { perror("pthread_create: countTask"); rtems_test_exit(EXIT_FAILURE); } /* sleep for 5 seconds, then cancel it */ sleep(5); pthread_cancel(task); pthread_join(task, NULL); } TEST_END(); #if defined(__rtems__) rtems_test_exit(EXIT_SUCCESS); return NULL; #else return 0; #endif }