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
16 T_GLOBAL_META(T_META_NAMESPACE("xnu.scheduler"),
17 T_META_RUN_CONCURRENTLY(true));
18
19 static mach_port_t port = MACH_PORT_NULL;
20
21 static void *
joining_thread_fn(__unused void * arg)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
67 for (uint32_t i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) {
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");
120 }
121
122 static mach_timebase_info_data_t timebase_info;
123
124 static uint64_t
nanos_to_abs(uint64_t nanos)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
set_realtime(pthread_t thread)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
set_nonrealtime(pthread_t thread)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 }
238