// 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"); }