[apple/xnu.git] / tests / work_interval_test.c

/* test that the header doesn't implicitly depend on others */
#include <sys/work_interval.h>

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <err.h>
#include <string.h>
#include <pthread.h>

#include <mach/mach.h>

#include <darwintest.h>

T_GLOBAL_META(T_META_NAMESPACE("xnu.scheduler"),
    T_META_RUN_CONCURRENTLY(true));

static mach_port_t port = MACH_PORT_NULL;

static void *
joining_thread_fn(__unused void *arg)
{
	int ret = 0;
	kern_return_t kr = KERN_SUCCESS;

	ret = work_interval_join_port(port);
	T_ASSERT_POSIX_SUCCESS(ret, "work_interval_join_port, another thread");

	kr = mach_port_deallocate(mach_task_self(), port);
	T_ASSERT_MACH_SUCCESS(kr, "mach_port_deallocate of port, another thread");

	/* deliberately exit with joined work interval */
	return NULL;
}

T_DECL(work_interval, "work interval interface")
{
	int ret = 0;
	work_interval_t handle = NULL;
	uint64_t now = mach_absolute_time();
	kern_return_t kr = KERN_SUCCESS;

	ret = work_interval_create(NULL, 0);
	T_ASSERT_EQ(errno, EINVAL, "create with null errno EINVAL");
	T_ASSERT_EQ(ret, -1, "create with null returns -1");

	/* Binary must be entitled for this to succeed */
	ret = work_interval_create(&handle, 0);
	T_ASSERT_POSIX_SUCCESS(ret, "work_interval_create, no flags");

	ret = work_interval_copy_port(handle, &port);
	T_ASSERT_EQ(errno, EINVAL, "work_interval_copy_port on non-joinable interval errno EINVAL");
	T_ASSERT_EQ(ret, -1, "work_interval_copy_port on non-joinable interval returns -1");

	ret = work_interval_notify(handle, now - 1000, now, now + 1000, now + 2000, 0);
	T_ASSERT_POSIX_SUCCESS(ret, "work_interval_notify, no flags");

	ret = work_interval_destroy(handle);
	T_ASSERT_POSIX_SUCCESS(ret, "work_interval_destroy, no flags");

	uint32_t flags[] = {
		WORK_INTERVAL_FLAG_JOINABLE,
		WORK_INTERVAL_FLAG_JOINABLE | WORK_INTERVAL_FLAG_GROUP,
	};

	for (uint32_t i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) {
		ret = work_interval_create(&handle, flags[i]);
		T_ASSERT_POSIX_SUCCESS(ret, "work_interval_create, joinable");

		ret = work_interval_copy_port(handle, &port);
		T_ASSERT_POSIX_SUCCESS(ret, "work_interval_copy_port, joinable");

		ret = work_interval_notify(handle, now - 1000, now, now + 1000, now + 2000, 0);
		T_ASSERT_EQ(ret, -1, "work_interval_notify on non-joined thread returns -1");
		T_ASSERT_EQ(errno, EINVAL, "work_interval_copy_port on non-joined thread errno EINVAL");

		ret = work_interval_join_port(port);
		T_ASSERT_POSIX_SUCCESS(ret, "work_interval_join_port, joinable");

		ret = work_interval_notify(handle, now - 1000, now, now + 1000, now + 2000, 0);
		T_ASSERT_POSIX_SUCCESS(ret, "work_interval_notify, on joined thread");

		ret = work_interval_join_port(port);
		T_ASSERT_POSIX_SUCCESS(ret, "work_interval_join_port, join the same interval after destroy");

		kr = mach_port_deallocate(mach_task_self(), port);
		T_ASSERT_MACH_SUCCESS(kr, "mach_port_deallocate of port");

		ret = work_interval_notify(handle, now - 1000, now, now + 1000, now + 2000, 0);
		T_ASSERT_POSIX_SUCCESS(ret, "work_interval_notify, on joined thread after destroy");

		ret = work_interval_destroy(handle);
		T_ASSERT_POSIX_SUCCESS(ret, "work_interval_destroy, joinable, on joined thread");

		ret = work_interval_leave();
		T_ASSERT_POSIX_SUCCESS(ret, "work_interval_leave, on destroyed work interval");
	}

	ret = work_interval_create(&handle, WORK_INTERVAL_FLAG_JOINABLE | WORK_INTERVAL_FLAG_GROUP);
	T_ASSERT_POSIX_SUCCESS(ret, "work_interval_create, joinable");

	ret = work_interval_copy_port(handle, &port);
	T_ASSERT_POSIX_SUCCESS(ret, "work_interval_copy_port, joinable");

	ret = work_interval_join_port(port);
	T_ASSERT_POSIX_SUCCESS(ret, "work_interval_join_port, join before handing to another thread");

	pthread_t joining_thread;

	T_ASSERT_POSIX_ZERO(pthread_create(&joining_thread, NULL, joining_thread_fn, NULL), "pthread_create");

	T_ASSERT_POSIX_ZERO(pthread_join(joining_thread, NULL), "pthread_join");

	ret = work_interval_leave();
	T_ASSERT_POSIX_SUCCESS(ret, "work_interval_leave");

	ret = work_interval_destroy(handle);
	T_ASSERT_POSIX_SUCCESS(ret, "work_interval_destroy");
}

static mach_timebase_info_data_t timebase_info;

static uint64_t
nanos_to_abs(uint64_t nanos)
{
	mach_timebase_info(&timebase_info);
	return nanos * timebase_info.denom / timebase_info.numer;
}

static void
set_realtime(pthread_t thread)
{
	kern_return_t kr;
	thread_time_constraint_policy_data_t pol;

	mach_port_t target_thread = pthread_mach_thread_np(thread);
	T_ASSERT_NOTNULL(target_thread, "pthread_mach_thread_np");

	/* 1s 100ms 10ms */
	pol.period      = (uint32_t)nanos_to_abs(1000000000);
	pol.constraint  = (uint32_t)nanos_to_abs(100000000);
	pol.computation = (uint32_t)nanos_to_abs(10000000);

	pol.preemptible = 0; /* Ignored by OS */
	kr = thread_policy_set(target_thread, THREAD_TIME_CONSTRAINT_POLICY, (thread_policy_t) &pol,
	    THREAD_TIME_CONSTRAINT_POLICY_COUNT);
	T_ASSERT_MACH_SUCCESS(kr, "thread_policy_set(THREAD_TIME_CONSTRAINT_POLICY)");
}

static void
set_nonrealtime(pthread_t thread)
{
	kern_return_t kr;
	thread_standard_policy_data_t pol = {0};

	mach_port_t target_thread = pthread_mach_thread_np(thread);
	T_ASSERT_NOTNULL(target_thread, "pthread_mach_thread_np");

	kr = thread_policy_set(target_thread, THREAD_STANDARD_POLICY, (thread_policy_t) &pol,
	    THREAD_STANDARD_POLICY_COUNT);
	T_ASSERT_MACH_SUCCESS(kr, "thread_policy_set(THREAD_STANDARD_POLICY)");
}

T_DECL(work_interval_audio_realtime_only, "joining RT threads to audio work interval", T_META_ASROOT(YES))
{
	int ret = 0;
	work_interval_t handle = NULL;
	kern_return_t kr = KERN_SUCCESS;

	uint32_t flags = WORK_INTERVAL_FLAG_GROUP | WORK_INTERVAL_FLAG_JOINABLE | WORK_INTERVAL_TYPE_COREAUDIO;

	ret = work_interval_create(&handle, flags);
	T_ASSERT_POSIX_SUCCESS(ret, "work_interval_create, joinable");

	ret = work_interval_copy_port(handle, &port);
	T_ASSERT_POSIX_SUCCESS(ret, "work_interval_copy_port, joinable");

	ret = work_interval_join_port(port);
	T_EXPECT_POSIX_FAILURE(ret, EINVAL, "work_interval_join_port for audio on non-RT thread");

	set_realtime(pthread_self());

	ret = work_interval_join_port(port);
	T_ASSERT_POSIX_SUCCESS(ret, "work_interval_join_port for audio on RT thread");

	ret = work_interval_leave();
	T_ASSERT_POSIX_SUCCESS(ret, "work_interval_leave");

	ret = work_interval_destroy(handle);
	T_ASSERT_POSIX_SUCCESS(ret, "work_interval_destroy");

	kr = mach_port_deallocate(mach_task_self(), port);
	T_ASSERT_MACH_SUCCESS(kr, "mach_port_deallocate of port");

	set_nonrealtime(pthread_self());
}

T_DECL(work_interval_get_flags, "querying a port for create flags")
{
	int ret = 0;
	work_interval_t handle = NULL;
	uint32_t flags = WORK_INTERVAL_FLAG_JOINABLE | WORK_INTERVAL_FLAG_GROUP | WORK_INTERVAL_TYPE_COREAUDIO;

	ret = work_interval_create(&handle, flags);
	T_ASSERT_POSIX_SUCCESS(ret, "work_interval_create(AUDIO)");

	ret = work_interval_copy_port(handle, &port);
	T_ASSERT_POSIX_SUCCESS(ret, "work_interval_copy_port");
	T_ASSERT_TRUE(MACH_PORT_VALID(port), "port from copy port is a valid port");

	uint32_t expected_flags = 0;

	ret = work_interval_get_flags_from_port(port, &expected_flags);
	T_ASSERT_EQ(ret, 0, "work_interval_get_flags_from_port");

	T_ASSERT_EQ(expected_flags, flags, "Flags match with what work interval was created with");

	mach_port_mod_refs(mach_task_self(), port, MACH_PORT_RIGHT_SEND, -1);
	work_interval_destroy(handle);

	// Negative test

	mach_port_t fake_port = MACH_PORT_NULL;
	ret = mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &fake_port);
	T_ASSERT_EQ(ret, 0, "successfully allocated a port");
	T_ASSERT_TRUE(MACH_PORT_VALID(fake_port), "allocated port is valid");

	ret = mach_port_insert_right(mach_task_self(), fake_port, fake_port, MACH_MSG_TYPE_MAKE_SEND);
	T_ASSERT_EQ(ret, 0, "successfully inserted a send right");

	ret = work_interval_get_flags_from_port(fake_port, &expected_flags);
	T_ASSERT_EQ(ret, -1, "query port failed as expected");

	mach_port_mod_refs(mach_task_self(), fake_port, MACH_PORT_RIGHT_SEND, -1);
	mach_port_mod_refs(mach_task_self(), fake_port, MACH_PORT_RIGHT_RECEIVE, -1);
}
Commit	Line	Data
5ba3f43e A	1	/* test that the header doesn't implicitly depend on others */
	2	#include <sys/work_interval.h>
	3
	4	#include <stdlib.h>
	5	#include <stdio.h>
	6	#include <unistd.h>
	7	#include <errno.h>
	8	#include <err.h>
	9	#include <string.h>
	10	#include <pthread.h>
	11
	12	#include <mach/mach.h>
	13
	14	#include <darwintest.h>
	15
cb323159 A	16	T_GLOBAL_META(T_META_NAMESPACE("xnu.scheduler"),
cb323159 A	17	T_META_RUN_CONCURRENTLY(true));
5ba3f43e A	18
	19	static mach_port_t port = MACH_PORT_NULL;
	20
	21	static void *
	22	joining_thread_fn(__unused void *arg)
	23	{
	24	int ret = 0;
	25	kern_return_t kr = KERN_SUCCESS;
	26
	27	ret = work_interval_join_port(port);
	28	T_ASSERT_POSIX_SUCCESS(ret, "work_interval_join_port, another thread");
	29
	30	kr = mach_port_deallocate(mach_task_self(), port);
	31	T_ASSERT_MACH_SUCCESS(kr, "mach_port_deallocate of port, another thread");
	32
	33	/* deliberately exit with joined work interval */
	34	return NULL;
	35	}
	36
	37	T_DECL(work_interval, "work interval interface")
	38	{
	39	int ret = 0;
	40	work_interval_t handle = NULL;
	41	uint64_t now = mach_absolute_time();
	42	kern_return_t kr = KERN_SUCCESS;
	43
	44	ret = work_interval_create(NULL, 0);
	45	T_ASSERT_EQ(errno, EINVAL, "create with null errno EINVAL");
	46	T_ASSERT_EQ(ret, -1, "create with null returns -1");
	47
	48	/* Binary must be entitled for this to succeed */
	49	ret = work_interval_create(&handle, 0);
	50	T_ASSERT_POSIX_SUCCESS(ret, "work_interval_create, no flags");
	51
	52	ret = work_interval_copy_port(handle, &port);
	53	T_ASSERT_EQ(errno, EINVAL, "work_interval_copy_port on non-joinable interval errno EINVAL");
	54	T_ASSERT_EQ(ret, -1, "work_interval_copy_port on non-joinable interval returns -1");
	55
	56	ret = work_interval_notify(handle, now - 1000, now, now + 1000, now + 2000, 0);
	57	T_ASSERT_POSIX_SUCCESS(ret, "work_interval_notify, no flags");
	58
	59	ret = work_interval_destroy(handle);
	60	T_ASSERT_POSIX_SUCCESS(ret, "work_interval_destroy, no flags");
	61
	62	uint32_t flags[] = {
	63	WORK_INTERVAL_FLAG_JOINABLE,
	64	WORK_INTERVAL_FLAG_JOINABLE \| WORK_INTERVAL_FLAG_GROUP,
	65	};
	66
0a7de745	67	for (uint32_t i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) {
5ba3f43e A	68	ret = work_interval_create(&handle, flags[i]);
	69	T_ASSERT_POSIX_SUCCESS(ret, "work_interval_create, joinable");
	70
	71	ret = work_interval_copy_port(handle, &port);
	72	T_ASSERT_POSIX_SUCCESS(ret, "work_interval_copy_port, joinable");
	73
	74	ret = work_interval_notify(handle, now - 1000, now, now + 1000, now + 2000, 0);
	75	T_ASSERT_EQ(ret, -1, "work_interval_notify on non-joined thread returns -1");
	76	T_ASSERT_EQ(errno, EINVAL, "work_interval_copy_port on non-joined thread errno EINVAL");
	77
	78	ret = work_interval_join_port(port);
	79	T_ASSERT_POSIX_SUCCESS(ret, "work_interval_join_port, joinable");
	80
	81	ret = work_interval_notify(handle, now - 1000, now, now + 1000, now + 2000, 0);
	82	T_ASSERT_POSIX_SUCCESS(ret, "work_interval_notify, on joined thread");
	83
	84	ret = work_interval_join_port(port);
	85	T_ASSERT_POSIX_SUCCESS(ret, "work_interval_join_port, join the same interval after destroy");
	86
	87	kr = mach_port_deallocate(mach_task_self(), port);
	88	T_ASSERT_MACH_SUCCESS(kr, "mach_port_deallocate of port");
	89
	90	ret = work_interval_notify(handle, now - 1000, now, now + 1000, now + 2000, 0);
	91	T_ASSERT_POSIX_SUCCESS(ret, "work_interval_notify, on joined thread after destroy");
	92
	93	ret = work_interval_destroy(handle);
	94	T_ASSERT_POSIX_SUCCESS(ret, "work_interval_destroy, joinable, on joined thread");
	95
	96	ret = work_interval_leave();
	97	T_ASSERT_POSIX_SUCCESS(ret, "work_interval_leave, on destroyed work interval");
	98	}
	99
	100	ret = work_interval_create(&handle, WORK_INTERVAL_FLAG_JOINABLE \| WORK_INTERVAL_FLAG_GROUP);
	101	T_ASSERT_POSIX_SUCCESS(ret, "work_interval_create, joinable");
	102
	103	ret = work_interval_copy_port(handle, &port);
	104	T_ASSERT_POSIX_SUCCESS(ret, "work_interval_copy_port, joinable");
	105
	106	ret = work_interval_join_port(port);
	107	T_ASSERT_POSIX_SUCCESS(ret, "work_interval_join_port, join before handing to another thread");
	108
	109	pthread_t joining_thread;
	110
	111	T_ASSERT_POSIX_ZERO(pthread_create(&joining_thread, NULL, joining_thread_fn, NULL), "pthread_create");
	112
	113	T_ASSERT_POSIX_ZERO(pthread_join(joining_thread, NULL), "pthread_join");
	114
	115	ret = work_interval_leave();
	116	T_ASSERT_POSIX_SUCCESS(ret, "work_interval_leave");
	117
	118	ret = work_interval_destroy(handle);
	119	T_ASSERT_POSIX_SUCCESS(ret, "work_interval_destroy");
5ba3f43e	120	}
f427ee49 A	121
	122	static mach_timebase_info_data_t timebase_info;
	123
	124	static uint64_t
	125	nanos_to_abs(uint64_t nanos)
	126	{
	127	mach_timebase_info(&timebase_info);
	128	return nanos * timebase_info.denom / timebase_info.numer;
	129	}
	130
	131	static void
	132	set_realtime(pthread_t thread)
	133	{
	134	kern_return_t kr;
	135	thread_time_constraint_policy_data_t pol;
	136
	137	mach_port_t target_thread = pthread_mach_thread_np(thread);
	138	T_ASSERT_NOTNULL(target_thread, "pthread_mach_thread_np");
	139
	140	/* 1s 100ms 10ms */
	141	pol.period = (uint32_t)nanos_to_abs(1000000000);
	142	pol.constraint = (uint32_t)nanos_to_abs(100000000);
	143	pol.computation = (uint32_t)nanos_to_abs(10000000);
	144
	145	pol.preemptible = 0; /* Ignored by OS */
	146	kr = thread_policy_set(target_thread, THREAD_TIME_CONSTRAINT_POLICY, (thread_policy_t) &pol,
	147	THREAD_TIME_CONSTRAINT_POLICY_COUNT);
	148	T_ASSERT_MACH_SUCCESS(kr, "thread_policy_set(THREAD_TIME_CONSTRAINT_POLICY)");
	149	}
	150
	151	static void
	152	set_nonrealtime(pthread_t thread)
	153	{
	154	kern_return_t kr;
	155	thread_standard_policy_data_t pol = {0};
	156
	157	mach_port_t target_thread = pthread_mach_thread_np(thread);
	158	T_ASSERT_NOTNULL(target_thread, "pthread_mach_thread_np");
	159
	160	kr = thread_policy_set(target_thread, THREAD_STANDARD_POLICY, (thread_policy_t) &pol,
	161	THREAD_STANDARD_POLICY_COUNT);
	162	T_ASSERT_MACH_SUCCESS(kr, "thread_policy_set(THREAD_STANDARD_POLICY)");
	163	}
	164
	165	T_DECL(work_interval_audio_realtime_only, "joining RT threads to audio work interval", T_META_ASROOT(YES))
	166	{
	167	int ret = 0;
	168	work_interval_t handle = NULL;
	169	kern_return_t kr = KERN_SUCCESS;
	170
	171	uint32_t flags = WORK_INTERVAL_FLAG_GROUP \| WORK_INTERVAL_FLAG_JOINABLE \| WORK_INTERVAL_TYPE_COREAUDIO;
	172
	173	ret = work_interval_create(&handle, flags);
	174	T_ASSERT_POSIX_SUCCESS(ret, "work_interval_create, joinable");
	175
	176	ret = work_interval_copy_port(handle, &port);
	177	T_ASSERT_POSIX_SUCCESS(ret, "work_interval_copy_port, joinable");
	178
	179	ret = work_interval_join_port(port);
	180	T_EXPECT_POSIX_FAILURE(ret, EINVAL, "work_interval_join_port for audio on non-RT thread");
	181
	182	set_realtime(pthread_self());
	183
	184	ret = work_interval_join_port(port);
185	T_ASSERT_POSIX_SUCCESS(ret, "work_interval_join_port for audio on RT thread");
186
187	ret = work_interval_leave();
188	T_ASSERT_POSIX_SUCCESS(ret, "work_interval_leave");
189
190	ret = work_interval_destroy(handle);
191	T_ASSERT_POSIX_SUCCESS(ret, "work_interval_destroy");
192
193	kr = mach_port_deallocate(mach_task_self(), port);
194	T_ASSERT_MACH_SUCCESS(kr, "mach_port_deallocate of port");
195
196	set_nonrealtime(pthread_self());
197	}
198
199	T_DECL(work_interval_get_flags, "querying a port for create flags")
200	{
201	int ret = 0;
202	work_interval_t handle = NULL;
203	uint32_t flags = WORK_INTERVAL_FLAG_JOINABLE \| WORK_INTERVAL_FLAG_GROUP \| WORK_INTERVAL_TYPE_COREAUDIO;
204
205	ret = work_interval_create(&handle, flags);
206	T_ASSERT_POSIX_SUCCESS(ret, "work_interval_create(AUDIO)");
207
208	ret = work_interval_copy_port(handle, &port);
209	T_ASSERT_POSIX_SUCCESS(ret, "work_interval_copy_port");
210	T_ASSERT_TRUE(MACH_PORT_VALID(port), "port from copy port is a valid port");
211
212	uint32_t expected_flags = 0;
213
214	ret = work_interval_get_flags_from_port(port, &expected_flags);
215	T_ASSERT_EQ(ret, 0, "work_interval_get_flags_from_port");
216
217	T_ASSERT_EQ(expected_flags, flags, "Flags match with what work interval was created with");
218
219	mach_port_mod_refs(mach_task_self(), port, MACH_PORT_RIGHT_SEND, -1);
220	work_interval_destroy(handle);
221
222	// Negative test
223
224	mach_port_t fake_port = MACH_PORT_NULL;
225	ret = mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &fake_port);
226	T_ASSERT_EQ(ret, 0, "successfully allocated a port");
227	T_ASSERT_TRUE(MACH_PORT_VALID(fake_port), "allocated port is valid");
228
229	ret = mach_port_insert_right(mach_task_self(), fake_port, fake_port, MACH_MSG_TYPE_MAKE_SEND);
230	T_ASSERT_EQ(ret, 0, "successfully inserted a send right");
231
232	ret = work_interval_get_flags_from_port(fake_port, &expected_flags);
233	T_ASSERT_EQ(ret, -1, "query port failed as expected");
234
235	mach_port_mod_refs(mach_task_self(), fake_port, MACH_PORT_RIGHT_SEND, -1);
236	mach_port_mod_refs(mach_task_self(), fake_port, MACH_PORT_RIGHT_RECEIVE, -1);
237	}