[apple/libpthread.git] / tests / cond_prepost.c

#include <pthread.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <stdbool.h>
#include <errno.h>
#include <TargetConditionals.h>

#include <pthread/pthread_spis.h>

#include <sys/sysctl.h>

#include "darwintest_defaults.h"
#include <darwintest_multiprocess.h>

// <rdar://problem/38810583> this test case is intended to test for the
// specific issue found in this radar. That is, if:
//
//     1. A mutex is in first-fit policy mode, and
//     2. is used as the mutex in a pthread_cond_wait (or timedwait), and
//     3. the mutex has the K-bit set but has no kernel waiters, and
//     4. the cvwait call preposts an unlock to the mutex
//
//  Under these conditions, the fact that the cvwait preposted an unlock to
//  the paired mutex is lost during the call. The P-bit was never returned to
//  userspace and the kwq in the kernel would continue to exist. If the same
//  uaddr is then reused as another synchroniser type then we would often
//  return EINVAL from the wait/lock function.
//
//  So this test is attempting to:
//
//     1. Repeatedly bang on a mutex+cvar for a number of iterations in the
//        hope of triggering a cvwait prepost situation.
//     2. Then destroy both the mutex and cvar, and reinitialise each memory
//        location as the opposite type of synchroniser. Then cvwait once to
//        trigger the failure condition.

struct context {
	union {
		pthread_mutex_t mutex;
		pthread_cond_t cond;
	};
	union {
		pthread_mutex_t mutex2;
		pthread_cond_t cond2;
	};
	long value;
	long count;
	long waiter;
};

static void *test_cond(void *ptr) {
	struct context *context = ptr;
	int res;

	res = pthread_cond_wait(&context->cond, &context->mutex2);
	T_ASSERT_POSIX_ZERO(res, "condition wait on condvar completed");
	res = pthread_mutex_unlock(&context->mutex2);
	T_ASSERT_POSIX_ZERO(res, "unlock condvar mutex");
	return NULL;
}

static void *test_cond_wake(void *ptr) {
	struct context *context = ptr;
	int res;

	res = pthread_mutex_lock(&context->mutex2);
	T_ASSERT_POSIX_ZERO(res, "locked condvar mutex");
	res = pthread_cond_signal(&context->cond);
	T_ASSERT_POSIX_ZERO(res, "condvar signalled");
	res = pthread_mutex_unlock(&context->mutex2);
	T_ASSERT_POSIX_ZERO(res, "dropped condvar mutex");

	return NULL;
}

static void *test_thread(void *ptr) {
	int res;
	long old;
	struct context *context = ptr;

	int i = 0;
	char *str;

	do {
		bool try = i++ & 1;
		bool cond = i & 16;

		if (!try){
			str = "pthread_mutex_lock";
			res = pthread_mutex_lock(&context->mutex);
		} else {
			str = "pthread_mutex_trylock";
			res = pthread_mutex_trylock(&context->mutex);
		}
		if (res != 0) {
			if (try && res == EBUSY) {
				continue;
			}
			T_ASSERT_POSIX_ZERO(res, "[%ld] %s", context->count, str);
		}

		old = __sync_fetch_and_or(&context->value, 1);
		if ((old & 1) != 0) {
			T_FAIL("[%ld] OR %lx\n", context->count, old);
		}

		old = __sync_fetch_and_and(&context->value, 0);
		if ((old & 1) == 0) {
			T_FAIL("[%ld] AND %lx\n", context->count, old);
		}

		if (cond && !context->waiter) {
			context->waiter = 1;
			struct timespec ts = {
				.tv_sec = 0,
				.tv_nsec = 10ull * NSEC_PER_MSEC,
			};

			res = pthread_cond_timedwait_relative_np(&context->cond2, &context->mutex, &ts);
			if (res == ETIMEDOUT) {
				// ignore, should be the last thread out
			} else if (res) {
				T_ASSERT_POSIX_ZERO(res, "[%ld] pthread_cond_wait",
						context->count);
			}
			context->waiter = 0;
			res = pthread_mutex_unlock(&context->mutex);
			if (res) {
				T_ASSERT_POSIX_ZERO(res, "[%ld] pthread_mutex_unlock",
						context->count);
			}
		} else {
			if (context->waiter) {
				res = pthread_cond_broadcast(&context->cond2);
				if (res) {
					T_ASSERT_POSIX_ZERO(res, "[%ld] pthread_cond_broadcast",
							context->count);
				}
			}
			res = pthread_mutex_unlock(&context->mutex);
			if (res) {
				T_ASSERT_POSIX_ZERO(res, "[%ld] pthread_mutex_unlock",
						context->count);
			}
		}
	} while (__sync_fetch_and_sub(&context->count, 1) > 0);
	return NULL;
}


static void
_test_condvar_prepost_race(void)
{
	struct context context = {
		.mutex = PTHREAD_MUTEX_INITIALIZER,
		.cond2 = PTHREAD_COND_INITIALIZER,
		.value = 0,
		.count = 10000,
		.waiter = false,
	};
	int i;
	int res;
	int threads = 8;
	pthread_t p[threads];
	for (i = 0; i < threads; ++i) {
		res = pthread_create(&p[i], NULL, test_thread, &context);
		T_QUIET; T_ASSERT_POSIX_ZERO(res, "pthread_create()");
	}
	for (i = 0; i < threads; ++i) {
		res = pthread_join(p[i], NULL);
		T_QUIET; T_ASSERT_POSIX_ZERO(res, "pthread_join()");
	}

	T_PASS("initial pthread mutex storm completed");

	pthread_mutex_destroy(&context.mutex);
	pthread_cond_destroy(&context.cond2);

	pthread_mutex_init(&context.mutex2, NULL);
	pthread_cond_init(&context.cond, NULL);
	res = pthread_mutex_lock(&context.mutex2);
	T_ASSERT_POSIX_ZERO(res, "mutex lock for condition wait");
	res = pthread_create(&p[0], NULL, test_cond, &context);
	T_QUIET; T_ASSERT_POSIX_ZERO(res, "pthread_create()");
	res = pthread_create(&p[1], NULL, test_cond_wake, &context);
	T_QUIET; T_ASSERT_POSIX_ZERO(res, "pthread_create()");

	res = pthread_join(p[0], NULL);
	T_QUIET; T_ASSERT_POSIX_ZERO(res, "pthread_join()");
	res = pthread_join(p[1], NULL);
	T_QUIET; T_ASSERT_POSIX_ZERO(res, "pthread_join()");

	pthread_cond_destroy(&context.cond);
}

T_DECL(cond_prepost_fairshare, "cond_prepost_fairshare (fairshare)",
	T_META_ALL_VALID_ARCHS(YES),
	T_META_ENVVAR("PTHREAD_MUTEX_DEFAULT_POLICY=1"))
{
	int i;
	int count = 100;
	for (i=0; i < count; i++) {
		_test_condvar_prepost_race();
	}
}

T_DECL(cond_prepost_firstfit, "cond_prepost_firstfit (firstfit)",
	T_META_ALL_VALID_ARCHS(YES),
	T_META_ENVVAR("PTHREAD_MUTEX_DEFAULT_POLICY=3"))
{
	int i;
	int count = 100;
	for (i=0; i < count; i++) {
		_test_condvar_prepost_race();
	}
}
Commit	Line	Data
214d78a2 A	1	#include <pthread.h>
	2	#include <stdlib.h>
	3	#include <string.h>
	4	#include <unistd.h>
	5	#include <stdbool.h>
	6	#include <errno.h>
	7	#include <TargetConditionals.h>
	8
	9	#include <pthread/pthread_spis.h>
	10
	11	#include <sys/sysctl.h>
	12
	13	#include "darwintest_defaults.h"
	14	#include <darwintest_multiprocess.h>
	15
	16	// <rdar://problem/38810583> this test case is intended to test for the
	17	// specific issue found in this radar. That is, if:
	18	//
	19	// 1. A mutex is in first-fit policy mode, and
	20	// 2. is used as the mutex in a pthread_cond_wait (or timedwait), and
	21	// 3. the mutex has the K-bit set but has no kernel waiters, and
	22	// 4. the cvwait call preposts an unlock to the mutex
	23	//
	24	// Under these conditions, the fact that the cvwait preposted an unlock to
	25	// the paired mutex is lost during the call. The P-bit was never returned to
	26	// userspace and the kwq in the kernel would continue to exist. If the same
	27	// uaddr is then reused as another synchroniser type then we would often
	28	// return EINVAL from the wait/lock function.
	29	//
	30	// So this test is attempting to:
	31	//
	32	// 1. Repeatedly bang on a mutex+cvar for a number of iterations in the
	33	// hope of triggering a cvwait prepost situation.
	34	// 2. Then destroy both the mutex and cvar, and reinitialise each memory
	35	// location as the opposite type of synchroniser. Then cvwait once to
	36	// trigger the failure condition.
	37
	38	struct context {
	39	union {
	40	pthread_mutex_t mutex;
	41	pthread_cond_t cond;
	42	};
	43	union {
	44	pthread_mutex_t mutex2;
	45	pthread_cond_t cond2;
	46	};
	47	long value;
	48	long count;
	49	long waiter;
	50	};
	51
	52	static void test_cond(void ptr) {
	53	struct context *context = ptr;
	54	int res;
	55
	56	res = pthread_cond_wait(&context->cond, &context->mutex2);
	57	T_ASSERT_POSIX_ZERO(res, "condition wait on condvar completed");
	58	res = pthread_mutex_unlock(&context->mutex2);
	59	T_ASSERT_POSIX_ZERO(res, "unlock condvar mutex");
	60	return NULL;
	61	}
	62
	63	static void test_cond_wake(void ptr) {
	64	struct context *context = ptr;
65	int res;
66
67	res = pthread_mutex_lock(&context->mutex2);
68	T_ASSERT_POSIX_ZERO(res, "locked condvar mutex");
69	res = pthread_cond_signal(&context->cond);
70	T_ASSERT_POSIX_ZERO(res, "condvar signalled");
71	res = pthread_mutex_unlock(&context->mutex2);
72	T_ASSERT_POSIX_ZERO(res, "dropped condvar mutex");
73
74	return NULL;
75	}
76
77	static void test_thread(void ptr) {
78	int res;
79	long old;
80	struct context *context = ptr;
81
82	int i = 0;
83	char *str;
84
85	do {
86	bool try = i++ & 1;
87	bool cond = i & 16;
88
89	if (!try){
90	str = "pthread_mutex_lock";
91	res = pthread_mutex_lock(&context->mutex);
92	} else {
93	str = "pthread_mutex_trylock";
94	res = pthread_mutex_trylock(&context->mutex);
95	}
96	if (res != 0) {
97	if (try && res == EBUSY) {
98	continue;
99	}
100	T_ASSERT_POSIX_ZERO(res, "[%ld] %s", context->count, str);
101	}
102
103	old = __sync_fetch_and_or(&context->value, 1);
104	if ((old & 1) != 0) {
105	T_FAIL("[%ld] OR %lx\n", context->count, old);
106	}
107
108	old = __sync_fetch_and_and(&context->value, 0);
109	if ((old & 1) == 0) {
110	T_FAIL("[%ld] AND %lx\n", context->count, old);
111	}
112
113	if (cond && !context->waiter) {
114	context->waiter = 1;
115	struct timespec ts = {
116	.tv_sec = 0,
117	.tv_nsec = 10ull * NSEC_PER_MSEC,
118	};
119
120	res = pthread_cond_timedwait_relative_np(&context->cond2, &context->mutex, &ts);
121	if (res == ETIMEDOUT) {
122	// ignore, should be the last thread out
123	} else if (res) {
124	T_ASSERT_POSIX_ZERO(res, "[%ld] pthread_cond_wait",
125	context->count);
126	}
127	context->waiter = 0;
128	res = pthread_mutex_unlock(&context->mutex);
129	if (res) {
130	T_ASSERT_POSIX_ZERO(res, "[%ld] pthread_mutex_unlock",
131	context->count);
132	}
133	} else {
134	if (context->waiter) {
135	res = pthread_cond_broadcast(&context->cond2);
136	if (res) {
137	T_ASSERT_POSIX_ZERO(res, "[%ld] pthread_cond_broadcast",
138	context->count);
139	}
140	}
141	res = pthread_mutex_unlock(&context->mutex);
142	if (res) {
143	T_ASSERT_POSIX_ZERO(res, "[%ld] pthread_mutex_unlock",
144	context->count);
145	}
146	}
147	} while (__sync_fetch_and_sub(&context->count, 1) > 0);
148	return NULL;
149	}
150
151
152	static void
153	_test_condvar_prepost_race(void)
154	{
155	struct context context = {
156	.mutex = PTHREAD_MUTEX_INITIALIZER,
157	.cond2 = PTHREAD_COND_INITIALIZER,
158	.value = 0,
159	.count = 10000,
160	.waiter = false,
161	};
162	int i;
163	int res;
164	int threads = 8;
165	pthread_t p[threads];
166	for (i = 0; i < threads; ++i) {
167	res = pthread_create(&p[i], NULL, test_thread, &context);
168	T_QUIET; T_ASSERT_POSIX_ZERO(res, "pthread_create()");
169	}
170	for (i = 0; i < threads; ++i) {
171	res = pthread_join(p[i], NULL);
172	T_QUIET; T_ASSERT_POSIX_ZERO(res, "pthread_join()");
173	}
174
175	T_PASS("initial pthread mutex storm completed");
176
177	pthread_mutex_destroy(&context.mutex);
178	pthread_cond_destroy(&context.cond2);
179
180	pthread_mutex_init(&context.mutex2, NULL);
181	pthread_cond_init(&context.cond, NULL);
182	res = pthread_mutex_lock(&context.mutex2);
183	T_ASSERT_POSIX_ZERO(res, "mutex lock for condition wait");
184	res = pthread_create(&p[0], NULL, test_cond, &context);
185	T_QUIET; T_ASSERT_POSIX_ZERO(res, "pthread_create()");
186	res = pthread_create(&p[1], NULL, test_cond_wake, &context);
187	T_QUIET; T_ASSERT_POSIX_ZERO(res, "pthread_create()");
188
189	res = pthread_join(p[0], NULL);
190	T_QUIET; T_ASSERT_POSIX_ZERO(res, "pthread_join()");
191	res = pthread_join(p[1], NULL);
192	T_QUIET; T_ASSERT_POSIX_ZERO(res, "pthread_join()");
193
194	pthread_cond_destroy(&context.cond);
195	}
196
197	T_DECL(cond_prepost_fairshare, "cond_prepost_fairshare (fairshare)",
198	T_META_ALL_VALID_ARCHS(YES),
199	T_META_ENVVAR("PTHREAD_MUTEX_DEFAULT_POLICY=1"))
200	{
201	int i;
202	int count = 100;
203	for (i=0; i < count; i++) {
204	_test_condvar_prepost_race();
205	}
206	}
207
208	T_DECL(cond_prepost_firstfit, "cond_prepost_firstfit (firstfit)",
209	T_META_ALL_VALID_ARCHS(YES),
210	T_META_ENVVAR("PTHREAD_MUTEX_DEFAULT_POLICY=3"))
211	{
212	int i;
213	int count = 100;
214	for (i=0; i < count; i++) {
215	_test_condvar_prepost_race();
216	}
217	}