void test_rwlock_init(void) {
int rc;
pthread_rwlockattr_t attrs;
rc = pthread_rwlockattr_init(&attrs);
ASSERT_EQ(rc, 0);
int shared = -1;
rc = pthread_rwlockattr_getpshared(&attrs, &shared);
ASSERT_EQ(rc, 0);
ASSERT_EQ(shared, PTHREAD_PROCESS_PRIVATE);
rc = pthread_rwlockattr_setpshared(&attrs, PTHREAD_PROCESS_SHARED);
#ifndef __GLIBC__
/*
* glibc's pthread_rwlockattr_setpshared doesn't currently fail
* with PTHREAD_PROCESS_SHARED. TODO(sbc): remove this once
* we fix the glibc bug:
* https://code.google.com/p/nativeclient/issues/detail?id=4142
*/
ASSERT_EQ(rc, EINVAL);
#endif
rc = pthread_rwlockattr_setpshared(&attrs, PTHREAD_PROCESS_PRIVATE);
ASSERT_EQ(rc, 0);
rc = pthread_rwlock_init(&g_rwlock, &attrs);
ASSERT_EQ(rc, 0);
rc = pthread_rwlockattr_destroy(&attrs);
ASSERT_EQ(rc, 0);
}
int main()
{
pthread_rwlockattr_t rwla;
int pshared;
int rc = 0;
#ifndef PTHREAD_PROCESS_SHARED
printf("process-shared attribute is not available for testing\n");
return PTS_UNSUPPORTED;
#endif
/* Initialize a rwlock attributes object */
if (pthread_rwlockattr_init(&rwla) != 0)
{
printf("Error at pthread_rwlockattr_init()\n");
return PTS_UNRESOLVED;
}
/* The default 'pshared' attribute should be PTHREAD_PROCESS_PRIVATE */
rc = pthread_rwlockattr_getpshared(&rwla, &pshared);
if (rc != 0)
{
printf("Test FAILED: Error at pthread_rwlockattr_getpshared(): %d\n", rc);
return PTS_FAIL;
}
if (pshared != PTHREAD_PROCESS_PRIVATE)
{
printf("Test FAILED: Incorrect default pshared value: %d\n", pshared);
return PTS_FAIL;
}
printf("Test PASSED\n");
return PTS_PASS;
}
static int my_pthread_rwlock_init(pthread_rwlock_t *__rwlock,
__const pthread_rwlockattr_t *__attr)
{
pthread_rwlock_t *realrwlock = NULL;
pthread_rwlockattr_t *realattr = NULL;
int pshared = 0;
if (__attr != NULL)
realattr = (pthread_rwlockattr_t *) *(unsigned int *) __attr;
if (realattr)
pthread_rwlockattr_getpshared(realattr, &pshared);
if (!pshared) {
/* non shared, standard rwlock: use malloc */
realrwlock = malloc(sizeof(pthread_rwlock_t));
*((unsigned int *) __rwlock) = (unsigned int) realrwlock;
}
else {
/* process-shared condition: use the shared memory segment */
hybris_shm_pointer_t handle = hybris_shm_alloc(sizeof(pthread_rwlock_t));
*((unsigned int *)__rwlock) = (unsigned int) handle;
if (handle)
realrwlock = (pthread_rwlock_t *)hybris_get_shmpointer(handle);
}
return pthread_rwlock_init(realrwlock, realattr);
}
int main(void)
{
pthread_rwlockattr_t rwa;
int rc;
#ifdef PTHREAD_PROCESS_SHARED
int pshared;
#endif
/* Initialize a read-write lock attributes object */
rc = pthread_rwlockattr_init(&rwa);
if (rc != 0) {
printf("Test FAILED, pthread_rwlockattr_init() returns %d\n",
rc);
return PTS_FAIL;
}
#ifdef PTHREAD_PROCESS_SHARED
/* If the symbol {PTHREAD_PROCESS_SHARED} is defined, the attribute
* process-shared should be provided and its default value should be
* PTHREAD_PROCESS_PRIVATE */
if (pthread_rwlockattr_getpshared(&rwa, &pshared) != 0) {
printf("Error obtaining the attribute process-shared\n");
return PTS_UNRESOLVED;
}
if (pshared == PTHREAD_PROCESS_PRIVATE) {
printf("Test PASSED\n");
return PTS_PASS;
} else {
printf
("Test FAILED, the default process-shared attribute is not PTHREAD_PROCESS_PRIVATE\n");
return PTS_FAIL;
}
#endif
fprintf(stderr,
"process-shared attribute is not available for testing\n");
return PTS_UNSUPPORTED;
}
TEST(pthread, pthread_rwlockattr_smoke) {
pthread_rwlockattr_t attr;
ASSERT_EQ(0, pthread_rwlockattr_init(&attr));
int pshared_value_array[] = {PTHREAD_PROCESS_PRIVATE, PTHREAD_PROCESS_SHARED};
for (size_t i = 0; i < sizeof(pshared_value_array) / sizeof(pshared_value_array[0]); ++i) {
ASSERT_EQ(0, pthread_rwlockattr_setpshared(&attr, pshared_value_array[i]));
int pshared;
ASSERT_EQ(0, pthread_rwlockattr_getpshared(&attr, &pshared));
ASSERT_EQ(pshared_value_array[i], pshared);
}
int kind_array[] = {PTHREAD_RWLOCK_PREFER_READER_NP,
PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP};
for (size_t i = 0; i < sizeof(kind_array) / sizeof(kind_array[0]); ++i) {
ASSERT_EQ(0, pthread_rwlockattr_setkind_np(&attr, kind_array[i]));
int kind;
ASSERT_EQ(0, pthread_rwlockattr_getkind_np(&attr, &kind));
ASSERT_EQ(kind_array[i], kind);
}
ASSERT_EQ(0, pthread_rwlockattr_destroy(&attr));
}
static int print_rwlockattr(const pthread_rwlockattr_t *rwlock_attr)
{
if (rwlock_attr == NULL)
{
printf("yes\n");
return THREAD_ATTR_FAILED;
}
int ret = 0;
int pshare = 0;
ret = pthread_rwlockattr_getpshared(rwlock_attr, &pshare);
if (pshare == PTHREAD_PROCESS_PRIVATE)
{
printf("rwlock shared: PRIVATE\n");
}
else if (pshare == PTHREAD_PROCESS_SHARED)
{
printf("rwlock shared: SHARED\n");
}
return THREAD_ATTR_OK;
}
int main()
{
pthread_rwlockattr_t rwla;
int pshared;
int rc = 0;
#ifndef PTHREAD_PROCESS_SHARED
printf("process-shared attribute is not available for testing\n");
return PTS_UNSUPPORTED;
#endif
/* Initialize a rwlock attributes object */
if (pthread_rwlockattr_init(&rwla) != 0) {
printf("Error at pthread_rwlockattr_init()\n");
return PTS_UNRESOLVED;
}
rc = pthread_rwlockattr_setpshared(&rwla, PTHREAD_PROCESS_PRIVATE);
if (rc != 0) {
printf
("Test FAILED: Error at pthread_rwlockattr_setpshared(), return error: %d\n",
rc);
return PTS_FAIL;
}
if (pthread_rwlockattr_getpshared(&rwla, &pshared) != 0) {
printf("Error at pthread_rwlockattr_getpshared()\n");
return PTS_UNRESOLVED;
}
if (pshared != PTHREAD_PROCESS_PRIVATE) {
printf
("Test FAILED: Expect PTHREAD_PROCESS_PRIVATE, but got %d\n",
pshared);
return PTS_FAIL;
}
rc = pthread_rwlockattr_setpshared(&rwla, PTHREAD_PROCESS_SHARED);
if (rc != 0) {
printf
("Test FAILED: Error at pthread_rwlockattr_setpshared(), return error: %d\n",
rc);
return PTS_FAIL;
}
if (pthread_rwlockattr_getpshared(&rwla, &pshared) != 0) {
printf("Error at pthread_rwlockattr_getpshared()\n");
return PTS_UNRESOLVED;
}
if (pshared != PTHREAD_PROCESS_SHARED) {
printf
("Test FAILED: Expect PTHREAD_PROCESS_SHARED, but got %d\n",
pshared);
return PTS_FAIL;
}
if (pthread_rwlockattr_destroy(&rwla) != 0) {
printf("Error at pthread_rwlockattr_destroy()");
return PTS_UNRESOLVED;
}
printf("Test PASSED\n");
return PTS_PASS;
}
static int
do_test (void)
{
size_t ps = sysconf (_SC_PAGESIZE);
char tmpfname[] = "/tmp/tst-rwlock4.XXXXXX";
char data[ps];
void *mem;
int fd;
pthread_rwlock_t *r;
pthread_rwlockattr_t a;
pid_t pid;
char *p;
int err;
int s;
fd = mkstemp (tmpfname);
if (fd == -1)
{
printf ("cannot open temporary file: %m\n");
return 1;
}
/* Make sure it is always removed. */
unlink (tmpfname);
/* Create one page of data. */
memset (data, '\0', ps);
/* Write the data to the file. */
if (write (fd, data, ps) != (ssize_t) ps)
{
puts ("short write");
return 1;
}
mem = mmap (NULL, ps, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (mem == MAP_FAILED)
{
printf ("mmap failed: %m\n");
return 1;
}
r = (pthread_rwlock_t *) (((uintptr_t) mem + __alignof (pthread_rwlock_t))
& ~(__alignof (pthread_rwlock_t) - 1));
p = (char *) (r + 1);
if (pthread_rwlockattr_init (&a) != 0)
{
puts ("rwlockattr_init failed");
return 1;
}
if (pthread_rwlockattr_getpshared (&a, &s) != 0)
{
puts ("1st rwlockattr_getpshared failed");
return 1;
}
if (s != PTHREAD_PROCESS_PRIVATE)
{
puts ("default pshared value wrong");
return 1;
}
if (pthread_rwlockattr_setpshared (&a, PTHREAD_PROCESS_SHARED) != 0)
{
puts ("rwlockattr_setpshared failed");
return 1;
}
if (pthread_rwlockattr_getpshared (&a, &s) != 0)
{
puts ("2nd rwlockattr_getpshared failed");
return 1;
}
if (s != PTHREAD_PROCESS_SHARED)
{
puts ("pshared value after setpshared call wrong");
return 1;
}
if (pthread_rwlock_init (r, &a) != 0)
{
puts ("rwlock_init failed");
return 1;
}
if (pthread_rwlock_rdlock (r) != 0)
{
puts ("rwlock_rdlock failed");
return 1;
}
if (pthread_rwlockattr_destroy (&a) != 0)
{
puts ("rwlockattr_destroy failed");
return 1;
}
err = pthread_rwlock_trywrlock (r);
if (err == 0)
{
puts ("rwlock_trywrlock succeeded");
return 1;
}
else if (err != EBUSY)
{
puts ("rwlock_trywrlock didn't return EBUSY");
return 1;
}
*p = 0;
puts ("going to fork now");
pid = fork ();
if (pid == -1)
{
puts ("fork failed");
return 1;
}
else if (pid == 0)
{
/* Play some lock ping-pong. It's our turn to unlock first. */
if ((*p)++ != 0)
{
puts ("child: *p != 0");
return 1;
}
if (pthread_rwlock_unlock (r) != 0)
{
puts ("child: 1st rwlock_unlock failed");
return 1;
}
puts ("child done");
}
else
{
if (pthread_rwlock_wrlock (r) != 0)
{
puts ("parent: rwlock_wrlock failed");
return 1;
}
if (*p != 1)
{
puts ("*p != 1");
return 1;
}
puts ("parent done");
}
return 0;
}
int main(
int argc,
char **argv
)
#endif
{
pthread_rwlock_t rwlock;
pthread_rwlockattr_t attr;
int status;
int p;
int i;
struct timespec abstime;
puts( "\n\n*** POSIX RWLOCK TEST 01 ***" );
/*************** NULL POINTER CHECKS *****************/
puts( "pthread_rwlockattr_init( NULL ) -- EINVAL" );
status = pthread_rwlockattr_init( NULL );
rtems_test_assert( status == EINVAL );
puts( "pthread_rwlockattr_setpshared( NULL, private ) -- EINVAL" );
status = pthread_rwlockattr_setpshared( NULL, PTHREAD_PROCESS_PRIVATE );
rtems_test_assert( status == EINVAL );
puts( "pthread_rwlockattr_setpshared( NULL, shared ) -- EINVAL" );
status = pthread_rwlockattr_setpshared( NULL, PTHREAD_PROCESS_SHARED );
rtems_test_assert( status == EINVAL );
puts( "pthread_rwlockattr_getpshared( NULL, &p ) -- EINVAL" );
status = pthread_rwlockattr_getpshared( NULL, &p );
rtems_test_assert( status == EINVAL );
puts( "pthread_rwlockattr_destroy( NULL ) -- EINVAL" );
status = pthread_rwlockattr_destroy( NULL );
rtems_test_assert( status == EINVAL );
/*************** NOT INITIALIZED CHECKS *****************/
/* cheat visibility */
attr.is_initialized = 0;
puts( "pthread_rwlockattr_setpshared( &attr, shared ) -- EINVAL" );
status = pthread_rwlockattr_setpshared( &attr, PTHREAD_PROCESS_SHARED );
rtems_test_assert( status == EINVAL );
puts( "pthread_rwlockattr_getpshared( &attr, NULL ) -- EINVAL" );
status = pthread_rwlockattr_getpshared( &attr, NULL );
rtems_test_assert( status == EINVAL );
puts( "pthread_rwlockattr_destroy( &attr ) -- EINVAL" );
status = pthread_rwlockattr_destroy( &attr );
rtems_test_assert( status == EINVAL );
/*************** BAD PSHARED CHECK *****************/
puts( "pthread_rwlockattr_setpshared( &attr, private ) -- EINVAL" );
status = pthread_rwlockattr_setpshared( &attr, ~PTHREAD_PROCESS_PRIVATE );
rtems_test_assert( status == EINVAL );
/*************** ACTUALLY WORK THIS TIME *****************/
puts( "pthread_rwlockattr_init( &attr ) -- OK" );
status = pthread_rwlockattr_init( &attr );
rtems_test_assert( status == 0 );
puts( "pthread_rwlockattr_setpshared( &attr, private ) -- OK" );
status = pthread_rwlockattr_setpshared( &attr, PTHREAD_PROCESS_PRIVATE );
rtems_test_assert( status == 0 );
puts( "pthread_rwlockattr_getpshared( &attr, &p ) -- OK" );
status = pthread_rwlockattr_getpshared( &attr, &p );
rtems_test_assert( status == 0 );
rtems_test_assert( p == PTHREAD_PROCESS_PRIVATE );
puts( "pthread_rwlockattr_setpshared( &attr, shared ) -- OK" );
status = pthread_rwlockattr_setpshared( &attr, PTHREAD_PROCESS_SHARED );
rtems_test_assert( status == 0 );
puts( "pthread_rwlockattr_getpshared( &attr, &p ) -- OK" );
status = pthread_rwlockattr_getpshared( &attr, &p );
rtems_test_assert( status == 0 );
rtems_test_assert( p == PTHREAD_PROCESS_SHARED );
/*************** DESTROY/REUSE CHECK *****************/
puts( "pthread_rwlockattr_destroy( &attr ) -- OK" );
status = pthread_rwlockattr_destroy( &attr );
rtems_test_assert( status == 0 );
puts( "pthread_rwlockattr_getpshared( &attr, &p ) destroyed -- EINVAL" );
status = pthread_rwlockattr_getpshared( &attr, &p );
rtems_test_assert( status == EINVAL );
/*************** NULL ARGUMENT CHECKS *****************/
abstime.tv_sec = 0;
abstime.tv_nsec = 0;
puts( "pthread_rwlock_init(NULL, &attr) -- EINVAL" );
status = pthread_rwlock_init(NULL, &attr);
rtems_test_assert( status == EINVAL );
puts( "pthread_rwlock_destroy(NULL) -- EINVAL" );
status = pthread_rwlock_destroy(NULL);
rtems_test_assert( status == EINVAL );
puts( "pthread_rwlock_rdlock(NULL) -- EINVAL" );
status = pthread_rwlock_rdlock(NULL);
rtems_test_assert( status == EINVAL );
puts( "pthread_rwlock_timedrdlock( NULL, &abstime) -- EINVAL" );
status = pthread_rwlock_timedrdlock( NULL, &abstime);
rtems_test_assert( status == EINVAL );
puts( "pthread_rwlock_timedrdlock( &rwlock, NULL) -- EINVAL" );
status = pthread_rwlock_timedrdlock( &rwlock, NULL);
rtems_test_assert( status == EINVAL );
puts( "pthread_rwlock_tryrdlock(NULL) -- EINVAL" );
status = pthread_rwlock_tryrdlock(NULL);
rtems_test_assert( status == EINVAL );
puts( "pthread_rwlock_wrlock(NULL) -- EINVAL" );
status = pthread_rwlock_wrlock(NULL);
rtems_test_assert( status == EINVAL );
puts( "pthread_rwlock_timedwrlock( NULL, &abstime) -- EINVAL" );
status = pthread_rwlock_timedwrlock( NULL, &abstime );
rtems_test_assert( status == EINVAL );
puts( "pthread_rwlock_timedwrlock( &rwlock, NULL) -- EINVAL" );
status = pthread_rwlock_timedwrlock( &rwlock, NULL);
rtems_test_assert( status == EINVAL );
puts( "pthread_rwlock_trywrlock(NULL) -- EINVAL" );
status = pthread_rwlock_trywrlock(NULL);
rtems_test_assert( status == EINVAL );
puts( "pthread_rwlock_unlock(NULL) -- EINVAL" );
status = pthread_rwlock_unlock(NULL);
rtems_test_assert( status == EINVAL );
/*************** BAD ID CHECK *****************/
rwlock = 1;
/* make a valid abstime */
puts( "clock_gettime(CLOCK_REALTIME, &abstime) -- OK" );
status = clock_gettime( CLOCK_REALTIME, &abstime );
rtems_test_assert( !status );
abstime.tv_sec += 5;
puts( "pthread_rwlock_destroy(BadId) -- EINVAL" );
status = pthread_rwlock_destroy(&rwlock);
rtems_test_assert( status == EINVAL );
puts( "pthread_rwlock_rdlock(BadId) -- EINVAL" );
status = pthread_rwlock_rdlock(&rwlock);
rtems_test_assert( status == EINVAL );
puts( "pthread_rwlock_timedrdlock(BadId, &abstime) -- EINVAL" );
status = pthread_rwlock_timedrdlock( &rwlock, &abstime);
rtems_test_assert( status == EINVAL );
puts( "pthread_rwlock_tryrdlock(BadId) -- EINVAL" );
status = pthread_rwlock_tryrdlock(&rwlock);
rtems_test_assert( status == EINVAL );
puts( "pthread_rwlock_wrlock(BadId) -- EINVAL" );
status = pthread_rwlock_wrlock(&rwlock);
rtems_test_assert( status == EINVAL );
puts( "pthread_rwlock_timedwrlock(BadId, &abstime) -- EINVAL" );
status = pthread_rwlock_timedwrlock( &rwlock, &abstime );
rtems_test_assert( status == EINVAL );
puts( "pthread_rwlock_trywrlock(BadId) -- EINVAL" );
status = pthread_rwlock_trywrlock(&rwlock);
rtems_test_assert( status == EINVAL );
puts( "pthread_rwlock_unlock(BadId) -- EINVAL" );
status = pthread_rwlock_unlock(&rwlock);
rtems_test_assert( status == EINVAL );
/*************** BAD ABSTIME CHECK *****************/
/* in the past */
abstime.tv_sec = 0;
abstime.tv_nsec = 0;
/* invalid tv_nsec */
abstime.tv_sec = 0;
abstime.tv_nsec = 0x7fffffffL;
/* XXX do we need bad time check? */
/*************** ACTUALLY CREATE ONE CHECK *****************/
puts( "pthread_rwlockattr_init( &attr ) -- OK" );
status = pthread_rwlockattr_init( &attr );
rtems_test_assert( status == 0 );
puts( "pthread_rwlock_init( &rwlock, &attr ) -- OK" );
status = pthread_rwlock_init( &rwlock, &attr );
rtems_test_assert( status == 0 );
rtems_test_assert( rwlock != 0 );
puts( "pthread_rwlock_init( &rwlock, &attr ) -- EAGAIN" );
status = pthread_rwlock_init( &rwlock, &attr );
rtems_test_assert( status == EAGAIN );
puts( "pthread_rwlock_destroy( &rwlock ) -- OK" );
status = pthread_rwlock_destroy( &rwlock );
rtems_test_assert( status == 0 );
/********* CREATE RWLOCK WITH DEFAULT ATTRIBUTES AND DESTROY IT *********/
puts( "pthread_rwlock_init( &rwlock, NULL ) -- OK" );
status = pthread_rwlock_init( &rwlock, NULL );
rtems_test_assert( status == 0 );
puts( "pthread_rwlock_destroy( &rwlock ) -- OK" );
status = pthread_rwlock_destroy( &rwlock );
rtems_test_assert( status == 0 );
/*************** CREATE THREADS AND LET THEM OBTAIN READLOCK ***************/
puts( "pthread_rwlock_init( &RWLock, &attr ) -- OK" );
status = pthread_rwlock_init( &RWLock, &attr );
rtems_test_assert( status == 0 );
puts( "pthread_rwlock_tryrdlock(RWLock) -- OK" );
status = pthread_rwlock_tryrdlock(&RWLock);
rtems_test_assert( !status );
for (i=0 ; i<NUMBER_THREADS ; i++ ) {
printf( "Init: pthread_create - thread %d OK\n", i+1 );
status = pthread_create(&ThreadIds[i], NULL, ReadLockThread, &ThreadIds[i]);
rtems_test_assert( !status );
sleep(1);
}
puts( "pthread_rwlock_unlock(RWLock) -- OK" );
status = pthread_rwlock_unlock(&RWLock);
rtems_test_assert( !status );
sleep(1);
/*************** CREATE THREADS AND LET THEM OBTAIN READLOCK ***************/
puts( "pthread_rwlock_trywrlock(RWLock) -- OK" );
status = pthread_rwlock_trywrlock(&RWLock);
rtems_test_assert( !status );
puts( "pthread_rwlock_tryrdlock(&RWLock) -- EBUSY" );
status = pthread_rwlock_tryrdlock(&RWLock);
rtems_test_assert( status == EBUSY );
for (i=0 ; i<NUMBER_THREADS ; i++ ) {
printf( "Init: pthread_create - thread %d OK\n", i+1 );
status = pthread_create(&ThreadIds[i], NULL, ReadLockThread, &ThreadIds[i]);
rtems_test_assert( !status );
sleep(1);
}
/* Attempt delete while threads are blocked */
puts( "pthread_rwlock_destroy( &RWLock ) -- EBUSY" );
status = pthread_rwlock_destroy( &RWLock );
rtems_test_assert( status == EBUSY );
/* now unlock it so the threads can continue */
puts( "pthread_rwlock_unlock(RWLock) -- OK" );
status = pthread_rwlock_unlock(&RWLock);
rtems_test_assert( !status );
sleep(2);
/*************** CREATE THREADS AND LET THEM OBTAIN WRITE LOCK *************/
puts( "\npthread_rwlock_trywrlock(RWLock) -- OK" );
status = pthread_rwlock_trywrlock(&RWLock);
rtems_test_assert( !status );
puts( "pthread_rwlock_trywrlock(&RWLock) -- EBUSY" );
status = pthread_rwlock_trywrlock(&RWLock);
rtems_test_assert( status == EBUSY );
for (i=0 ; i<NUMBER_THREADS ; i++ ) {
printf( "Init: pthread_create - thread %d OK\n", i+1 );
status =
pthread_create(&ThreadIds[i], NULL, WriteLockThread, &ThreadIds[i]);
rtems_test_assert( !status );
sleep(2);
}
puts( "pthread_rwlock_unlock(RWLock) -- OK" );
status = pthread_rwlock_unlock(&RWLock);
rtems_test_assert( !status );
sleep(6);
/*************** CREATE THREADS AND LET THEM OBTAIN WRITE LOCK *************/
/*************** THEN ATTEMPT TO OBTAIN A READLOCK *************/
puts( "\npthread_rwlock_tryrdlock(&RWLock) -- OK" );
status = pthread_rwlock_tryrdlock(&RWLock);
rtems_test_assert( !status );
printf( "Init: pthread_create - thread reader & writer OK\n" );
status = pthread_create(&ThreadIds[0], NULL, WriteLockThread, &ThreadIds[0]);
rtems_test_assert( !status );
sleep(1);
status = pthread_create(&ThreadIds[1], NULL, ReadLockThread, &ThreadIds[1]);
rtems_test_assert( !status );
sleep(1);
puts( "pthread_rwlock_tryrdlock(&RWLock) -- EBUSY" );
status = pthread_rwlock_tryrdlock(&RWLock);
rtems_test_assert( status == EBUSY );
puts( "pthread_rwlock_trywrlock(&RWLock) -- EBUSY" );
status = pthread_rwlock_trywrlock(&RWLock);
rtems_test_assert( status == EBUSY );
sleep( 5 );
puts( "pthread_rwlock_unlock(&RWLock) -- OK" );
status = pthread_rwlock_unlock(&RWLock);
rtems_test_assert( !status );
sleep( 5 );
/*************** TIMEOUT ON RWLOCK ***************/
puts( "clock_gettime(CLOCK_REALTIME, &abstime) -- OK" );
status = clock_gettime( CLOCK_REALTIME, &abstime );
rtems_test_assert( !status );
abstime.tv_sec += 1;
puts( "pthread_rwlock_timedwrlock( &RWLock, &abstime) -- OK" );
status = pthread_rwlock_timedwrlock( &RWLock, &abstime );
rtems_test_assert( status == 0 );
abstime.tv_sec += 1;
puts( "pthread_rwlock_timedrdlock( &RWLock, &abstime) -- ETIMEDOUT" );
status = pthread_rwlock_timedrdlock( &RWLock, &abstime );
rtems_test_assert( status == ETIMEDOUT );
abstime.tv_sec -= 1;
puts( "pthread_rwlock_timedrdlock( &RWLock, &abstime) -- ETIMEDOUT" );
status = pthread_rwlock_timedrdlock( &RWLock, &abstime );
rtems_test_assert( status == ETIMEDOUT );
abstime.tv_sec -= 1;
puts( "pthread_rwlock_timedwrlock( &RWLock, &abstime) -- ETIMEDOUT" );
status = pthread_rwlock_timedwrlock( &RWLock, &abstime );
rtems_test_assert( status == ETIMEDOUT );
/*************** OBTAIN RWLOCK WITH ABSTIME IN PAST ***************/
status = pthread_rwlock_unlock(&RWLock);
rtems_test_assert( !status );
abstime.tv_sec -= 1;
puts( "pthread_rwlock_timedrdlock( &RWLock, &abstime) -- in past -- OK" );
status = pthread_rwlock_timedrdlock( &RWLock, &abstime );
rtems_test_assert( status == 0 );
/*************** OBTAIN RWLOCK FOR WRITE WITH ABSTIME IN PAST ***************/
status = pthread_rwlock_unlock(&RWLock);
rtems_test_assert( !status );
abstime.tv_sec -= 1;
puts( "pthread_rwlock_timedwrlock( &RWLock, &abstime) -- in past -- OK" );
status = pthread_rwlock_timedwrlock( &RWLock, &abstime );
rtems_test_assert( status == 0 );
/*************** DESTROY RWLOCK ***************/
puts( "pthread_rwlock_destroy( &RWLock ) -- OK" );
status = pthread_rwlock_destroy( &RWLock );
rtems_test_assert( status == 0 );
/*************** OBTAIN A LOCK AND THEN RELEASE IT TWICE ***************/
puts( "pthread_rwlock_init( &rwlock, NULL ) -- OK" );
status = pthread_rwlock_init( &rwlock, NULL );
rtems_test_assert( status == 0 );
rtems_test_assert( rwlock != 0 );
puts( "pthread_rwlock_unlock ( &rwlock ) -- OK" );
status = pthread_rwlock_unlock( &rwlock );
rtems_test_assert( status == 0 );
puts( "pthread_rwlock_unlock ( &rwlock ) -- OK" );
status = pthread_rwlock_unlock( &rwlock );
rtems_test_assert( status == 0 );
/*************** END OF TEST *****************/
puts( "*** END OF POSIX RWLOCK TEST 01 ***" );
exit(0);
}
int
main (int argc, char **argv)
{
error_t err;
pthread_rwlockattr_t attr;
pthread_rwlock_t lock;
int pshared;
int i;
pthread_t tid[THREADS];
void *ret;
err = pthread_rwlockattr_init (&attr);
if (err)
error (1, err, "pthread_rwlockattr_init");
err = pthread_rwlockattr_getpshared (&attr, &pshared);
if (err)
error (1, err, "pthread_rwlockattr_getpshared");
/* Assert the default state as mandated by POSIX. */
assert (pshared == PTHREAD_PROCESS_PRIVATE);
err = pthread_rwlockattr_setpshared (&attr, pshared);
if (err)
error (1, err, "pthread_rwlockattr_setpshared");
err = pthread_rwlock_init (&lock, &attr);
if (err)
error (1, err, "pthread_rwlock_init");
err = pthread_rwlockattr_destroy (&attr);
if (err)
error (1, err, "pthread_rwlockattr_destroy");
/* Now test the lock. */
for (i = 0; i < THREADS; i ++)
{
err = pthread_create (&tid[i], 0, test1, &lock);
if (err)
error (1, err, "pthread_create");
}
for (i = 0; i < 10; i ++)
{
sched_yield ();
/* Get a write lock. */
pthread_rwlock_wrlock (&lock);
/* Increment a and b giving other threads a chance to run in
between. */
sched_yield ();
a ++;
sched_yield ();
b ++;
sched_yield ();
/* Unlock. */
pthread_rwlock_unlock (&lock);
}
for (i = 0; i < THREADS; i ++)
{
err = pthread_join (tid[i], &ret);
if (err)
error (1, err, "pthread_join");
}
/* Read lock it. */
err = pthread_rwlock_tryrdlock (&lock);
assert (err == 0);
/* Try to write lock it. It should fail with EBUSY. */
err = pthread_rwlock_trywrlock (&lock);
assert (err == EBUSY);
/* Drop the read lock. */
err = pthread_rwlock_unlock (&lock);
assert (err == 0);
/* Get a write lock. */
err = pthread_rwlock_trywrlock (&lock);
assert (err == 0);
/* Fail trying to acquire another write lock. */
err = pthread_rwlock_trywrlock (&lock);
assert (err == EBUSY);
/* Try to get a read lock which should also fail. */
err = pthread_rwlock_tryrdlock (&lock);
assert (err == EBUSY);
/* Unlock it. */
err = pthread_rwlock_unlock (&lock);
assert (err == 0);
err = pthread_rwlock_destroy (&lock);
if (err)
error (1, err, "pthread_rwlock_destroy");
return 0;
}
static int my_pthread_rwlockattr_getpshared(pthread_rwlockattr_t *__attr,
int *pshared)
{
pthread_rwlockattr_t *realattr = (pthread_rwlockattr_t *) *(unsigned int *) __attr;
return pthread_rwlockattr_getpshared(realattr, pshared);
}
int main(void)
{
pthread_rwlockattr_t attr;
pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER; /* 读写锁初始化 */
int ret;
/* 初始化读写锁 */
ret = pthread_rwlockattr_init(&attr);
if(ret)
{
fprintf(stderr, "pthread_rwlock_init error.\n");
return ret;
}
/* 设置读写锁属性 */
ret = pthread_rwlockattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);
if(ret)
{
fprintf(stderr, "pthread_rwlockattr_setpshared error.\n");
return ret;
}
/* 获取读写锁属性 */
int pshared;
ret = pthread_rwlockattr_getpshared(&attr, &pshared);
if(ret)
{
fprintf(stderr, "pthread_rwlockattr_getpshared error.\n");
return ret;
}
fprintf(stdout, "读写锁属性pshared:[%d]\n", pshared);
/* 初始化读写锁 */
ret = pthread_rwlock_init(&rwlock, &attr);
if(ret)
{
fprintf(stderr, "pthread_rwlock_init error.\n");
return ret;
}
/* 获取读写锁中的读锁 */
ret = pthread_rwlock_rdlock(&rwlock);
if(ret)
{
fprintf(stderr, "pthread_rwlock_rdlock error.\n");
return ret;
}
/* 解除锁定读写锁 */
ret = pthread_rwlock_unlock(&rwlock);
if(ret)
{
fprintf(stderr, "pthread_rwlock_unlock error.\n");
return ret;
}
/* 读取非阻塞读写锁中的锁 */
ret = pthread_rwlock_tryrdlock(&rwlock);
if(ret)
{
fprintf(stderr, "pthread_rwlock_tryrdlock error.\n");
return ret;
}
/* 解除 */
ret = pthread_rwlock_unlock(&rwlock);
if(ret)
{
fprintf(stderr, "pthread_rwlock_unlock error[%s]\n", strerror(errno));
return ret;
}
/* 写入读写锁中的锁 */
ret = pthread_rwlock_wrlock(&rwlock);
if(ret)
{
fprintf(stderr, "pthread_rwlock_rwlock error[%s]\n", strerror(errno));
return ret;
}
/* 解除 */
ret = pthread_rwlock_unlock(&rwlock);
if(ret)
{
fprintf(stderr, "pthread_rwlock_unlock error[%s]\n", strerror(errno));
return ret;
}
/* 写入非阻塞读写锁中的锁 */
ret = pthread_rwlock_trywrlock(&rwlock);
if(ret)
{
fprintf(stderr, "pthread_rwlock_trywrlock error[%s]\n", strerror(errno));
return ret;
}
/* 解除 */
ret = pthread_rwlock_unlock(&rwlock);
if(ret)
{
fprintf(stderr, "pthread_rwlock_unlock error[%s]\n", strerror(errno));
return ret;
}
/* 销毁读写锁 */
ret = pthread_rwlockattr_destroy(&attr);
if(ret)
{
fprintf(stderr, "pthread_rwlockattr_destroy.\n");
return ret;
}
ret = pthread_rwlock_destroy(&rwlock);
if(ret)
{
fprintf(stderr, "pthread_rwlock_destroy error.\n");
return ret;
}
return 0;
}
