// pthread_mutex_init
PTH_FUNC(int, pthreadZumutexZuinit, // pthread_mutex_init
pthread_mutex_t *mutex,
pthread_mutexattr_t* attr)
{
int ret;
long mbRec;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
if (TRACE_PTH_FNS) {
fprintf(stderr, "<< pthread_mxinit %p", mutex); fflush(stderr);
}
mbRec = 0;
if (attr) {
int ty, zzz;
zzz = pthread_mutexattr_gettype(attr, &ty);
if (zzz == 0 && ty == PTHREAD_MUTEX_RECURSIVE)
mbRec = 1;
}
CALL_FN_W_WW(ret, fn, mutex,attr);
if (ret == 0 /*success*/) {
DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_MUTEX_INIT_POST,
pthread_mutex_t*,mutex, long,mbRec);
} else {
DO_PthAPIerror( "pthread_mutex_init", ret );
}
if (TRACE_PTH_FNS) {
fprintf(stderr, " :: mxinit -> %d >>\n", ret);
}
return ret;
}
mutextype_t MutexAttr::GetType()
{
int result;
if(pthread_mutexattr_gettype(&m_MutexAttr,&result)!=0)
throw std::runtime_error("pthread_mutexattr_gettype failed");
return mutextype_t(result);
}
int
main()
{
pthread_t t;
int mxType = -1;
assert(pthread_mutexattr_init(&mxAttr) == 0);
assert(pthread_mutexattr_settype(&mxAttr, PTHREAD_MUTEX_NORMAL) == 0);
assert(pthread_mutexattr_gettype(&mxAttr, &mxType) == 0);
assert(mxType == PTHREAD_MUTEX_NORMAL);
assert(pthread_mutex_init(&mutex, &mxAttr) == 0);
assert(pthread_create(&t, NULL, locker, NULL) == 0);
Sleep(1000);
assert(lockCount == 1);
/*
* Should succeed even though we don't own the lock
* because FAST mutexes don't check ownership.
*/
assert(pthread_mutex_unlock(&mutex) == 0);
Sleep (1000);
assert(lockCount == 2);
exit(0);
/* Never reached */
return 0;
}
int
main()
{
pthread_t t;
int mxType = -1;
assert(pthread_mutexattr_init(&mxAttr) == 0);
BEGIN_MUTEX_STALLED_ROBUST(mxAttr)
lockCount = 0;
assert(pthread_mutexattr_settype(&mxAttr, PTHREAD_MUTEX_ERRORCHECK) == 0);
assert(pthread_mutexattr_gettype(&mxAttr, &mxType) == 0);
assert(mxType == PTHREAD_MUTEX_ERRORCHECK);
assert(pthread_mutex_init(&mutex, &mxAttr) == 0);
assert(pthread_mutex_lock(&mutex) == 0);
assert(pthread_create(&t, NULL, locker, NULL) == 0);
Sleep(2000);
assert(lockCount == 1);
assert(pthread_mutex_unlock(&mutex) == 0);
END_MUTEX_STALLED_ROBUST(mxAttr)
return 0;
}
int
pthread_test_mutex7n()
{
pthread_t t;
int mxType = -1;
lockCount = 0;
assert(pthread_mutexattr_init(&mxAttr) == 0);
assert(pthread_mutexattr_settype(&mxAttr, PTHREAD_MUTEX_NORMAL) == 0);
assert(pthread_mutexattr_gettype(&mxAttr, &mxType) == 0);
assert(mxType == PTHREAD_MUTEX_NORMAL);
assert(pthread_mutex_init(&mutex, &mxAttr) == 0);
assert(pthread_create(&t, NULL, locker, NULL) == 0);
pte_osThreadSleep(1000);
assert(lockCount == 2);
assert(pthread_join(t,NULL) == 0);
assert(pthread_mutex_destroy(&mutex) == 0);
/* Never reached */
return 0;
}
static int
do_test (void)
{
pthread_mutexattr_t attr;
int kind;
int error;
error = pthread_mutexattr_init (&attr);
if (error)
{
printf ("pthread_mutexattr_init: %s\n", strerror (error));
return 1;
}
error = pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_DEFAULT);
if (error)
{
printf ("pthread_mutexattr_settype (1): %s\n", strerror (error));
return 1;
}
error = pthread_mutexattr_gettype (&attr, &kind);
if (error)
{
printf ("pthread_mutexattr_gettype: %s\n", strerror (error));
return 1;
}
error = pthread_mutexattr_settype (&attr, kind);
if (error)
{
printf ("pthread_mutexattr_settype (2): %s\n", strerror (error));
return 1;
}
return 0;
}
static void test_mutexattr()
{
pthread_mutex_t m;
pthread_mutexattr_t a;
int r;
int i;
T(pthread_mutexattr_init(&a));
T(pthread_mutexattr_gettype(&a, &i));
if (i != PTHREAD_MUTEX_DEFAULT)
t_error("default mutex type is %d, wanted PTHREAD_MUTEX_DEFAULT (%d)\n", i, PTHREAD_MUTEX_DEFAULT);
T(pthread_mutexattr_settype(&a, PTHREAD_MUTEX_ERRORCHECK));
T(pthread_mutexattr_gettype(&a, &i));
if (i != PTHREAD_MUTEX_ERRORCHECK)
t_error("setting error check mutex type failed failed: got %d, wanted %d\n", i, PTHREAD_MUTEX_ERRORCHECK);
}
int
test_mutex6r(void)
#endif
{
pthread_t t;
void* result = (void*)0;
int mxType = -1;
assert(pthread_mutexattr_init(&mxAttr) == 0);
BEGIN_MUTEX_STALLED_ROBUST(mxAttr)
lockCount = 0;
assert(pthread_mutexattr_settype(&mxAttr, PTHREAD_MUTEX_RECURSIVE) == 0);
assert(pthread_mutexattr_gettype(&mxAttr, &mxType) == 0);
assert(mxType == PTHREAD_MUTEX_RECURSIVE);
assert(pthread_mutex_init(&mutex, &mxAttr) == 0);
assert(pthread_create(&t, NULL, locker, NULL) == 0);
assert(pthread_join(t, &result) == 0);
assert((int)(size_t)result == 555);
assert(lockCount == 2);
assert(pthread_mutex_destroy(&mutex) == 0);
END_MUTEX_STALLED_ROBUST(mxAttr)
assert(pthread_mutexattr_destroy(&mxAttr) == 0);
return 0;
}
int main(void)
{
pthread_mutexattr_t mta;
int type;
/* Initialize a mutex attributes object */
if (pthread_mutexattr_init(&mta) != 0) {
perror("Error at pthread_mutexattr_init()\n");
return PTS_UNRESOLVED;
}
/* Set the mutex attribute 'type' to PTHREAD_MUTEX_DEFAULT. */
if (pthread_mutexattr_settype(&mta, PTHREAD_MUTEX_DEFAULT) != 0) {
fprintf(stderr,
"pthread_mutexattr_settype(): Error setting the attribute 'type'\n");
return PTS_UNRESOLVED;
}
/* The 'type' attribute should be PTHREAD_MUTEX_DEFAULT */
if (pthread_mutexattr_gettype(&mta, &type) != 0) {
fprintf(stderr,
"pthread_mutexattr_gettype(): Error obtaining the attribute 'type'\n");
return PTS_UNRESOLVED;
}
if (type != PTHREAD_MUTEX_DEFAULT) {
printf
("Test FAILED: Incorrect mutexattr 'type' value: %d. Should be PTHREAD_MUTEX_DEFAULT\n",
type);
return PTS_FAIL;
}
printf("Test PASSED\n");
return PTS_PASS;
}
int
test_mutex8r(void)
#endif
{
pthread_t t;
int mxType = -1;
assert(pthread_mutexattr_init(&mxAttr) == 0);
BEGIN_MUTEX_STALLED_ROBUST(mxAttr)
lockCount = 0;
assert(pthread_mutexattr_settype(&mxAttr, PTHREAD_MUTEX_RECURSIVE) == 0);
assert(pthread_mutexattr_gettype(&mxAttr, &mxType) == 0);
assert(mxType == PTHREAD_MUTEX_RECURSIVE);
assert(pthread_mutex_init(&mutex, &mxAttr) == 0);
assert(pthread_mutex_lock(&mutex) == 0);
assert(pthread_create(&t, NULL, locker, NULL) == 0);
Sleep(2000);
assert(lockCount == 1);
assert(pthread_mutex_unlock(&mutex) == 0);
END_MUTEX_STALLED_ROBUST(mxAttr)
return 0;
}
int
main()
{
pthread_t t;
int result = 0;
int mxType = -1;
assert(pthread_mutexattr_init(&mxAttr) == 0);
assert(pthread_mutexattr_settype(&mxAttr, PTHREAD_MUTEX_ERRORCHECK) == 0);
assert(pthread_mutexattr_gettype(&mxAttr, &mxType) == 0);
assert(mxType == PTHREAD_MUTEX_ERRORCHECK);
assert(pthread_mutex_init(&mutex, &mxAttr) == 0);
assert(pthread_create(&t, NULL, locker, NULL) == 0);
assert(pthread_join(t, (void **) &result) == 0);
assert(result == 555);
assert(lockCount == 2);
assert(pthread_mutex_destroy(&mutex) == 0);
assert(pthread_mutexattr_destroy(&mxAttr) == 0);
exit(0);
/* Never reached */
return 0;
}
int
main()
{
pthread_t t;
int mxType = -1;
assert(pthread_mutexattr_init(&mxAttr) == 0);
assert(pthread_mutexattr_settype(&mxAttr, PTHREAD_MUTEX_RECURSIVE) == 0);
assert(pthread_mutexattr_gettype(&mxAttr, &mxType) == 0);
assert(mxType == PTHREAD_MUTEX_RECURSIVE);
assert(pthread_mutex_init(&mutex, &mxAttr) == 0);
assert(pthread_mutex_lock(&mutex) == 0);
assert(pthread_create(&t, NULL, locker, NULL) == 0);
Sleep(2000);
assert(lockCount == 1);
assert(pthread_mutex_unlock(&mutex) == 0);
return 0;
}
int
pthread_mutex_init (pthread_mutex_t *m, const pthread_mutexattr_t *a)
{
mutex_t *_m;
int r = mutex_ref_init (m);
if (r)
return r;
if (!(_m = (pthread_mutex_t)calloc(1,sizeof(*_m))))
{
pthread_spin_unlock (&mutex_global);
return ENOMEM;
}
_m->type = PTHREAD_MUTEX_DEFAULT;
_m->count = 0;
_m->busy = 0;
if (a)
{
int share = PTHREAD_PROCESS_PRIVATE;
r = pthread_mutexattr_gettype (a, &_m->type);
if (!r)
r = pthread_mutexattr_getpshared(a, &share);
if (!r && share == PTHREAD_PROCESS_SHARED)
r = ENOSYS;
}
if (!r)
{
if ((_m->h = CreateSemaphore(NULL, 1, 0x7fffffff, NULL)) == NULL)
{
switch (GetLastError()) {
case ERROR_ACCESS_DENIED:
r = EPERM;
break;
default: /* We assume this, to keep it simple: */
r = ENOMEM;
}
}
}
if (r)
{
_m->valid = DEAD_MUTEX;
free(_m);
*m = NULL;
pthread_spin_unlock (&mutex_global);
return r;
}
_m->valid = LIFE_MUTEX;
*m = _m;
pthread_spin_unlock (&mutex_global);
return 0;
}
/*!
\return int
\retval one of the mutex type codes above.
*/
int
CMutexAttr::getType()
{
int type;
int status = pthread_mutexattr_gettype(&m_attributes, &type);
throwifbad(status, "CMutexAttr::getType");
return type;
}
TEST(pthread, pthread_mutexattr_gettype) {
pthread_mutexattr_t attr;
ASSERT_EQ(0, pthread_mutexattr_init(&attr));
int attr_type;
ASSERT_EQ(0, pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL));
ASSERT_EQ(0, pthread_mutexattr_gettype(&attr, &attr_type));
ASSERT_EQ(PTHREAD_MUTEX_NORMAL, attr_type);
ASSERT_EQ(0, pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK));
ASSERT_EQ(0, pthread_mutexattr_gettype(&attr, &attr_type));
ASSERT_EQ(PTHREAD_MUTEX_ERRORCHECK, attr_type);
ASSERT_EQ(0, pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE));
ASSERT_EQ(0, pthread_mutexattr_gettype(&attr, &attr_type));
ASSERT_EQ(PTHREAD_MUTEX_RECURSIVE, attr_type);
ASSERT_EQ(0, pthread_mutexattr_destroy(&attr));
}
int cobalt_mutexattr_gettype(const pthread_mutexattr_t __user *u_attr,
int __user *u_type)
{
pthread_mutexattr_t attr;
int err, type;
if (__xn_safe_copy_from_user(&attr, u_attr, sizeof(attr)))
return -EFAULT;
err = pthread_mutexattr_gettype(&attr, &type);
if (err)
return -err;
return __xn_safe_copy_to_user(u_type, &type, sizeof(*u_type));
}
// pthread_mutex_init
PTH_FUNC(int, pthreadZumutexZuinit,
pthread_mutex_t *mutex,
const pthread_mutexattr_t* attr)
{
int ret;
int res;
OrigFn fn;
int mt;
VALGRIND_GET_ORIG_FN(fn);
mt = PTHREAD_MUTEX_DEFAULT;
if (attr)
pthread_mutexattr_gettype(attr, &mt);
VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_MUTEX_INIT,
mutex, pthread_to_drd_mutex_type(mt), 0, 0, 0);
CALL_FN_W_WW(ret, fn, mutex, attr);
VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_MUTEX_INIT,
mutex, 0, 0, 0, 0);
return ret;
}
static __always_inline
int pthread_mutex_init_intercept(pthread_mutex_t *mutex,
const pthread_mutexattr_t* attr)
{
int ret;
OrigFn fn;
int mt;
VALGRIND_GET_ORIG_FN(fn);
mt = PTHREAD_MUTEX_DEFAULT;
if (attr)
pthread_mutexattr_gettype(attr, &mt);
VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_MUTEX_INIT,
mutex, DRD_(pthread_to_drd_mutex_type)(mt),
0, 0, 0);
CALL_FN_W_WW(ret, fn, mutex, attr);
VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_MUTEX_INIT,
mutex, 0, 0, 0, 0);
return ret;
}
int
main()
{
int mxType = -1;
assert(PTHREAD_MUTEX_DEFAULT == PTHREAD_MUTEX_NORMAL);
assert(PTHREAD_MUTEX_DEFAULT != PTHREAD_MUTEX_ERRORCHECK);
assert(PTHREAD_MUTEX_DEFAULT != PTHREAD_MUTEX_RECURSIVE);
assert(PTHREAD_MUTEX_RECURSIVE != PTHREAD_MUTEX_ERRORCHECK);
assert(PTHREAD_MUTEX_NORMAL == PTHREAD_MUTEX_FAST_NP);
assert(PTHREAD_MUTEX_RECURSIVE == PTHREAD_MUTEX_RECURSIVE_NP);
assert(PTHREAD_MUTEX_ERRORCHECK == PTHREAD_MUTEX_ERRORCHECK_NP);
assert(pthread_mutexattr_init(&mxAttr) == 0);
assert(pthread_mutexattr_gettype(&mxAttr, &mxType) == 0);
assert(mxType == PTHREAD_MUTEX_NORMAL);
return 0;
}
static int print_mutexattr(const pthread_mutexattr_t *mutex_attr)
{
if (mutex_attr == NULL)
{
return THREAD_ATTR_FAILED;
}
int ret = 0;
int pshare = 0;
int type = 0;
ret = pthread_mutexattr_getpshared(mutex_attr, &pshare);
if (pshare == PTHREAD_PROCESS_PRIVATE)
{
printf("mutex shared: PRIVATE\n");
}
else if (pshare == PTHREAD_PROCESS_SHARED)
{
printf("mutex shared: SHARED\n");
}
ret = pthread_mutexattr_gettype(mutex_attr, &type);
if (type == PTHREAD_MUTEX_NORMAL)
{
printf("mutex NORMAL\n");
}
else if (type == PTHREAD_MUTEX_ERRORCHECK)
{
printf("mutex ERRORCHECK\n");
}
else if (type == PTHREAD_MUTEX_RECURSIVE)
{
printf("mutex RECURSIVE\n");
}
else if (type == PTHREAD_MUTEX_DEFAULT)
{
printf("mutex DEFAULT\n");
}
return THREAD_ATTR_OK;
}
int
test_mutex5(void)
#endif
{
int mxType = -1;
assert(FOIL(PTHREAD_MUTEX_DEFAULT) == PTHREAD_MUTEX_NORMAL);
assert(FOIL(PTHREAD_MUTEX_DEFAULT) != PTHREAD_MUTEX_ERRORCHECK);
assert(FOIL(PTHREAD_MUTEX_DEFAULT) != PTHREAD_MUTEX_RECURSIVE);
assert(FOIL(PTHREAD_MUTEX_RECURSIVE) != PTHREAD_MUTEX_ERRORCHECK);
assert(FOIL(PTHREAD_MUTEX_NORMAL) == PTHREAD_MUTEX_FAST_NP);
assert(FOIL(PTHREAD_MUTEX_RECURSIVE) == PTHREAD_MUTEX_RECURSIVE_NP);
assert(FOIL(PTHREAD_MUTEX_ERRORCHECK) == PTHREAD_MUTEX_ERRORCHECK_NP);
assert(pthread_mutexattr_init(&mxAttr) == 0);
assert(pthread_mutexattr_gettype(&mxAttr, &mxType) == 0);
assert(mxType == PTHREAD_MUTEX_NORMAL);
return 0;
}
int
test_mutex6n(void)
#endif
{
pthread_t t;
int mxType = -1;
assert(pthread_mutexattr_init(&mxAttr) == 0);
BEGIN_MUTEX_STALLED_ROBUST(mxAttr)
lockCount = 0;
assert(pthread_mutexattr_settype(&mxAttr, PTHREAD_MUTEX_NORMAL) == 0);
assert(pthread_mutexattr_gettype(&mxAttr, &mxType) == 0);
assert(mxType == PTHREAD_MUTEX_NORMAL);
assert(pthread_mutex_init(&mutex, &mxAttr) == 0);
assert(pthread_create(&t, NULL, locker, NULL) == 0);
Sleep(1000);
assert(lockCount == 1);
/*
* Should succeed even though we don't own the lock
* because FAST mutexes don't check ownership.
*/
assert(pthread_mutex_unlock(&mutex) == (IS_ROBUST?EPERM:0));
Sleep (1000);
assert(lockCount == (IS_ROBUST?1:2));
END_MUTEX_STALLED_ROBUST(mxAttr)
return 0;
}
int myfunc() {
int ret = 0;
int type = 0;
pthread_mutexattr_t attr;
if ((ret = pthread_mutexattr_init(&attr)) != 0)
{
printf("pthread_mutexattr_init error: %s\n", strerror(ret));
return ret;
}
if ((ret = pthread_mutexattr_gettype(&attr, &type)) != 0)
{
printf("gettype error\n");
return ret;
}
whichtype(type);
if ((ret = pthread_mutexattr_destroy(&attr)) != 0)
{
printf("destroy error\n");
return ret;
}
return 0;
}
int
main()
{
pthread_t t;
int mxType = -1;
assert(pthread_mutexattr_init(&mxAttr) == 0);
BEGIN_MUTEX_STALLED_ROBUST(mxAttr)
lockCount = 0;
assert(pthread_mutexattr_settype(&mxAttr, PTHREAD_MUTEX_NORMAL) == 0);
assert(pthread_mutexattr_gettype(&mxAttr, &mxType) == 0);
assert(mxType == PTHREAD_MUTEX_NORMAL);
assert(pthread_mutex_init(&mutex, &mxAttr) == 0);
assert(pthread_create(&t, NULL, locker, NULL) == 0);
Sleep(100);
assert(lockCount == 1);
assert(pthread_mutex_unlock(&mutex) == IS_ROBUST?EPERM:0);
Sleep (100);
assert(lockCount == IS_ROBUST?1:2);
END_MUTEX_STALLED_ROBUST(mxAttr)
exit(0);
/* Never reached */
return 0;
}
int
main()
{
pthread_t t;
int mxType = -1;
assert(pthread_mutexattr_init(&mxAttr) == 0);
assert(pthread_mutexattr_settype(&mxAttr, PTHREAD_MUTEX_NORMAL) == 0);
assert(pthread_mutexattr_gettype(&mxAttr, &mxType) == 0);
assert(mxType == PTHREAD_MUTEX_NORMAL);
assert(pthread_mutex_init(&mutex, &mxAttr) == 0);
assert(pthread_create(&t, NULL, locker, NULL) == 0);
Sleep(1000);
assert(lockCount == 2);
exit(0);
/* Never reached */
return 0;
}
int
main()
{
int mxType = -1;
int success = 0; /* Use to quell GNU compiler warnings. */
assert(success = PTHREAD_MUTEX_DEFAULT == PTHREAD_MUTEX_NORMAL);
assert(success = PTHREAD_MUTEX_DEFAULT != PTHREAD_MUTEX_ERRORCHECK);
assert(success = PTHREAD_MUTEX_DEFAULT != PTHREAD_MUTEX_RECURSIVE);
assert(success = PTHREAD_MUTEX_RECURSIVE != PTHREAD_MUTEX_ERRORCHECK);
assert(success = PTHREAD_MUTEX_NORMAL == PTHREAD_MUTEX_FAST_NP);
assert(success = PTHREAD_MUTEX_RECURSIVE == PTHREAD_MUTEX_RECURSIVE_NP);
assert(success = PTHREAD_MUTEX_ERRORCHECK == PTHREAD_MUTEX_ERRORCHECK_NP);
if (success == success)
{
assert(pthread_mutexattr_init(&mxAttr) == 0);
assert(pthread_mutexattr_gettype(&mxAttr, &mxType) == 0);
assert(mxType == PTHREAD_MUTEX_NORMAL);
}
return 0;
}
int
main()
{
pthread_t t;
void* result = (void*)0;
int mxType = -1;
assert(pthread_mutexattr_init(&mxAttr) == 0);
BEGIN_MUTEX_STALLED_ROBUST(mxAttr)
lockCount = 0;
assert(pthread_mutexattr_settype(&mxAttr, PTHREAD_MUTEX_ERRORCHECK) == 0);
assert(pthread_mutexattr_gettype(&mxAttr, &mxType) == 0);
assert(mxType == PTHREAD_MUTEX_ERRORCHECK);
assert(pthread_mutex_init(&mutex, &mxAttr) == 0);
assert(pthread_create(&t, NULL, locker, NULL) == 0);
assert(pthread_join(t, &result) == 0);
assert((int)(size_t)result == 555);
assert(lockCount == 2);
assert(pthread_mutex_destroy(&mutex) == 0);
END_MUTEX_STALLED_ROBUST(mxAttr)
assert(pthread_mutexattr_destroy(&mxAttr) == 0);
exit(0);
/* Never reached */
return 0;
}
int main(int argc, char *argv[])
{
int ret, i, j;
pthread_mutexattr_t ma;
pthread_condattr_t ca;
pthread_t th[NTHREADS];
int loc_started, loc_stopped;
long altclk_ok, pshared_ok;
struct {
char altclk; /* Want to use alternative clock */
char pshared; /* Want to use process-shared primitives */
int type; /* mutex type */
char *descr; /* Description of the case */
} scenar[] = {
{
0, 0, PTHREAD_MUTEX_RECURSIVE, "Recursive mutex"}, {
0, 0, PTHREAD_MUTEX_ERRORCHECK, "Errorcheck mutex"},
#ifdef USE_ALTCLK
{
1, 0, PTHREAD_MUTEX_RECURSIVE,
"Recursive mutex + altclock cond"}, {
1, 0, PTHREAD_MUTEX_ERRORCHECK,
"Errorcheck mutex + altclock cond"}, {
1, 1, PTHREAD_MUTEX_RECURSIVE,
"Recursive pshared mutex + altclock cond"}, {
1, 1, PTHREAD_MUTEX_ERRORCHECK,
"Errorcheck pshared mutex + altclock cond"},
#endif
{
0, 1, PTHREAD_MUTEX_RECURSIVE, "Recursive pshared mutex"}, {
0, 1, PTHREAD_MUTEX_ERRORCHECK,
"Errorcheck pshared mutex"},};
output_init();
/* Initialize the constants */
altclk_ok = sysconf(_SC_CLOCK_SELECTION);
if (altclk_ok > 0)
altclk_ok = sysconf(_SC_MONOTONIC_CLOCK);
#ifndef USE_ALTCLK
if (altclk_ok > 0)
output("Implementation supports the MONOTONIC CLOCK "
"but option is disabled in test.\n");
#endif
pshared_ok = sysconf(_SC_THREAD_PROCESS_SHARED);
#if VERBOSE > 0
output("Test starting\n");
output(" Process-shared primitive %s be tested\n",
(pshared_ok > 0) ? "will" : "won't");
output(" Alternative clock for cond %s be tested\n",
(altclk_ok > 0) ? "will" : "won't");
#endif
for (i = 0; i < (sizeof(scenar) / sizeof(scenar[0])); i++) {
#if VERBOSE > 1
output("Starting test for %s\n", scenar[i].descr);
#endif
/* Initialize the data structure */
ret = pthread_mutexattr_init(&ma);
if (ret != 0)
UNRESOLVED(ret, "Mutex attribute object init failed");
ret = pthread_mutexattr_settype(&ma, scenar[i].type);
if (ret != 0)
UNRESOLVED(ret, "Unable to set mutex type");
if ((pshared_ok > 0) && (scenar[i].pshared != 0)) {
ret =
pthread_mutexattr_setpshared(&ma,
PTHREAD_PROCESS_SHARED);
if (ret != 0)
UNRESOLVED(ret,
"Unable to set mutex process-shared");
}
ret = pthread_condattr_init(&ca);
if (ret != 0)
UNRESOLVED(ret, "Cond attribute object init failed");
if ((pshared_ok > 0) && (scenar[i].pshared != 0)) {
ret =
pthread_condattr_setpshared(&ca,
PTHREAD_PROCESS_SHARED);
if (ret != 0)
UNRESOLVED(ret,
"Unable to set cond process-shared");
}
#ifdef USE_ALTCLK
if ((altclk_ok > 0) && (scenar[i].altclk != 0)) {
ret = pthread_condattr_setclock(&ca, CLOCK_MONOTONIC);
if (ret != 0)
UNRESOLVED(ret,
"Unable to set alternative (monotonic) clock for cond");
}
#endif
ret = pthread_mutex_init(&(data.mtx1), &ma);
if (ret != 0)
UNRESOLVED(ret, "Unable to init mutex 1");
ret = pthread_mutex_init(&(data.mtx2), &ma);
if (ret != 0)
UNRESOLVED(ret, "Unable to init mutex 2");
ret = pthread_cond_init(&(data.cnd), &ca);
if (ret != 0)
UNRESOLVED(ret, "Unable to initialize condvar");
data.boolcnd = 0;
ret = pthread_mutexattr_gettype(&ma, &(data.type));
if (ret != 0)
UNRESOLVED(ret, "Unable to get type from mutex attr");
#ifdef USE_ALTCLK
ret = pthread_condattr_getclock(&ca, &(data.cid));
if (ret != 0)
UNRESOLVED(ret,
"Unable to get clock ID from cond attr");
#else
data.cid = CLOCK_REALTIME;
#endif
data.started = 0;
data.stopped = 0;
/* Start the threads */
#if VERBOSE > 1
output("Initialization OK, starting threads\n");
#endif
for (j = 0; j < NTHREADS; j++) {
ret =
pthread_create(&th[j], NULL, threaded,
(void *)(long)(j & 1));
if (ret != 0)
UNRESOLVED(ret, "Thread creation failed");
}
/* Wait for the threads to be started */
do {
ret = pthread_mutex_lock(&(data.mtx1));
if (ret != 0)
UNRESOLVED(ret, "Unable to lock m1 in parent");
loc_started = data.started;
ret = pthread_mutex_unlock(&(data.mtx1));
if (ret != 0)
UNRESOLVED(ret,
"Unable to unlock m1 in parent");
} while (loc_started < NTHREADS);
/* Broadcast the condition until all threads are terminated */
data.boolcnd = 1;
do {
ret = pthread_cond_broadcast(&(data.cnd));
if (ret != 0)
UNRESOLVED(ret, "Unable to broadcast cnd");
sched_yield();
ret = pthread_mutex_lock(&(data.mtx2));
if (ret != 0)
UNRESOLVED(ret, "Unable to lock m2 in parent");
loc_stopped = data.stopped;
ret = pthread_mutex_unlock(&(data.mtx2));
if (ret != 0)
UNRESOLVED(ret,
"Unable to unlock m2 in parent");
} while (loc_stopped < NTHREADS);
/* Join the threads */
for (j = 0; j < NTHREADS; j++) {
ret = pthread_join(th[j], NULL);
if (ret != 0)
UNRESOLVED(ret, "Thread join failed");
}
#if VERBOSE > 1
output("Test passed for %s\n", scenar[i].descr);
#endif
/* Destroy data */
ret = pthread_cond_destroy(&(data.cnd));
if (ret != 0)
UNRESOLVED(ret, "Cond destroy failed");
ret = pthread_mutex_destroy(&(data.mtx1));
if (ret != 0)
UNRESOLVED(ret, "Mutex 1 destroy failed");
ret = pthread_mutex_destroy(&(data.mtx2));
if (ret != 0)
UNRESOLVED(ret, "Mutex 2 destroy failed");
ret = pthread_condattr_destroy(&ca);
if (ret != 0)
UNRESOLVED(ret, "Cond attribute destroy failed");
ret = pthread_mutexattr_destroy(&ma);
if (ret != 0)
UNRESOLVED(ret, "Mutex attr destroy failed");
} /* Proceed to next case */
PASSED;
}
int pthread_mutex_init(pthread_mutex_t *m, const pthread_mutexattr_t *a)
{
mutex_t *_m;
int r = mutex_ref_init(m);
if(r) return r;
if (!(_m = (pthread_mutex_t)calloc(1,sizeof(*_m))))
return ENOMEM;
_m->type = PTHREAD_MUTEX_DEFAULT;
_m->count = 0;
if (a) {
int share = PTHREAD_PROCESS_SHARED;
r = pthread_mutexattr_gettype(a, &_m->type);
if (!r) r = pthread_mutexattr_getpshared(a, &share);
if (!r && share == PTHREAD_PROCESS_SHARED) r = ENOSYS;
}
if (!r) {
#if defined USE_MUTEX_Mutex
if ( (_m->h = CreateSemaphore(NULL, 1, 0x7fffffff, NULL)) != NULL) {
#else /* USE_MUTEX_CriticalSection */
if (InitializeCriticalSectionAndSpinCount(&_m->cs.cs, USE_MUTEX_CriticalSection_SpinCount)) {
#endif
} else {
#if defined USE_MUTEX_Mutex
switch (GetLastError()) {
case ERROR_ACCESS_DENIED:
r = EPERM;
break;
default: /* We assume this, to keep it simple: */
r = ENOMEM;
}
#else /* USE_MUTEX_CriticalSection */
r = ENOMEM;
#endif
}
}
if (r)
{
_m->valid = DEAD_MUTEX;
free(_m);
*m = NULL;
return r;
}
if (InterlockedExchange(&InitOnce, 0))
_mutex_init_once(_m);
_m->valid = LIFE_MUTEX;
*m = _m;
return 0;
}
int pthread_mutex_destroy(pthread_mutex_t *m)
{
pthread_mutex_t mDestroy;
int r = mutex_ref_destroy(m,&mDestroy);
if(r) return r;
if(!mDestroy) return 0; /* destroyed a (still) static initialized mutex */
/* now the mutex is invalid, and no one can touch it */
mutex_t *_m = (mutex_t *)mDestroy;
#if defined USE_MUTEX_Mutex
CloseHandle(_m->h);
#else /* USE_MUTEX_CriticalSection */
DeleteCriticalSection(&_m->cs.cs);
#endif
_m->valid = DEAD_MUTEX;
_m->type = 0;
_m->count = 0;
free(mDestroy);
return 0;
}
void recursive_mutex_test(void)
{
pthread_t thread[NTHREADS];
#ifdef SDCC
pthread_addr_t result[NTHREADS];
pthread_attr_t attr;
#endif
pthread_mutexattr_t mattr;
int type;
int status;
int i;
/* Initialize the mutex attributes */
pthread_mutexattr_init(&mattr);
status = pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_RECURSIVE);
if (status != 0)
{
printf("recursive_mutex_test: ERROR pthread_mutexattr_settype failed, status=%d\n", status);
}
status = pthread_mutexattr_gettype(&mattr, &type);
if (status != 0)
{
printf("recursive_mutex_test: ERROR pthread_mutexattr_gettype failed, status=%d\n", status);
}
if (type != PTHREAD_MUTEX_RECURSIVE)
{
printf("recursive_mutex_test: ERROR pthread_mutexattr_gettype return type=%d\n", type);
}
/* Initialize the mutex */
printf("recursive_mutex_test: Initializing mutex\n");
pthread_mutex_init(&mut, &mattr);
/* Start the threads -- all at the same, default priority */
for (i = 0; i < NTHREADS; i++)
{
printf("recursive_mutex_test: Starting thread %d\n", i+1);
#ifdef SDCC
(void)pthread_attr_init(&attr);
status = pthread_create(&thread[i], &attr, thread_outer, (pthread_addr_t)i+1);
#else
status = pthread_create(&thread[i], NULL, thread_outer, (pthread_addr_t)i+1);
#endif
if (status != 0)
{
printf("recursive_mutex_test: ERRROR thread#%d creation: %d\n", i+1, status);
}
}
/* Wait for all; of the threads to complete */
for (i = 0; i < NTHREADS; i++)
{
printf("recursive_mutex_test: Waiting for thread %d\n", i+1);
#ifdef SDCC
pthread_join(thread[i], &result1);
#else
pthread_join(thread[i], NULL);
#endif
}
printf("recursive_mutex_test: Complete\n");
}
