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