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 mach_timebase_info_data_t timebase_info;
23
24 static uint64_t
nanos_to_abs(uint64_t nanos)25 nanos_to_abs(uint64_t nanos)
26 {
27 mach_timebase_info(&timebase_info);
28 return nanos * timebase_info.denom / timebase_info.numer;
29 }
30
31 static void
set_realtime(pthread_t thread)32 set_realtime(pthread_t thread)
33 {
34 kern_return_t kr;
35 thread_time_constraint_policy_data_t pol;
36
37 mach_port_t target_thread = pthread_mach_thread_np(thread);
38 T_EXPECT_NE(target_thread, MACH_PORT_NULL, "pthread_mach_thread_np");
39
40 /* 1s 100ms 10ms */
41 pol.period = (uint32_t)nanos_to_abs(1000000000);
42 pol.constraint = (uint32_t)nanos_to_abs(100000000);
43 pol.computation = (uint32_t)nanos_to_abs(10000000);
44
45 pol.preemptible = 0; /* Ignored by OS */
46 kr = thread_policy_set(target_thread, THREAD_TIME_CONSTRAINT_POLICY, (thread_policy_t) &pol,
47 THREAD_TIME_CONSTRAINT_POLICY_COUNT);
48 T_ASSERT_MACH_SUCCESS(kr, "thread_policy_set(THREAD_TIME_CONSTRAINT_POLICY)");
49 }
50
51 static void
set_nonrealtime(pthread_t thread)52 set_nonrealtime(pthread_t thread)
53 {
54 kern_return_t kr;
55 thread_standard_policy_data_t pol = {0};
56
57 mach_port_t target_thread = pthread_mach_thread_np(thread);
58 T_EXPECT_NE(target_thread, MACH_PORT_NULL, "pthread_mach_thread_np");
59
60 kr = thread_policy_set(target_thread, THREAD_STANDARD_POLICY, (thread_policy_t) &pol,
61 THREAD_STANDARD_POLICY_COUNT);
62 T_ASSERT_MACH_SUCCESS(kr, "thread_policy_set(THREAD_STANDARD_POLICY)");
63 }
64
65 T_DECL(unentitled_work_intervals, "work interval interface for unentitled types")
66 {
67 int ret = 0;
68 work_interval_t handle = NULL;
69 uint64_t now = mach_absolute_time();
70 kern_return_t kr = KERN_SUCCESS;
71
72 ret = work_interval_create(NULL, 0);
73 T_ASSERT_EQ(errno, EINVAL, "create with null errno EINVAL");
74 T_ASSERT_EQ(ret, -1, "create with null returns -1");
75
76 ret = work_interval_create(&handle, WORK_INTERVAL_FLAG_GROUP | WORK_INTERVAL_FLAG_UNRESTRICTED | WORK_INTERVAL_TYPE_DEFAULT);
77 T_ASSERT_POSIX_SUCCESS(ret, "work_interval_create, public flags");
78
79 ret = work_interval_copy_port(handle, &port);
80 T_ASSERT_EQ(errno, EINVAL, "work_interval_copy_port on non-joinable interval errno EINVAL");
81 T_ASSERT_EQ(ret, -1, "work_interval_copy_port on non-joinable interval returns -1");
82
83 ret = work_interval_notify(handle, now - 1000, now, now + 1000, now + 2000, 0);
84 T_ASSERT_POSIX_SUCCESS(ret, "work_interval_notify, no flags");
85
86 ret = work_interval_destroy(handle);
87 T_ASSERT_POSIX_SUCCESS(ret, "work_interval_destroy, no flags");
88
89 uint32_t flags[] = {
90 WORK_INTERVAL_FLAG_JOINABLE | WORK_INTERVAL_FLAG_GROUP | WORK_INTERVAL_FLAG_UNRESTRICTED | WORK_INTERVAL_TYPE_DEFAULT,
91 };
92
93 for (uint32_t i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) {
94 ret = work_interval_create(&handle, flags[i]);
95 T_ASSERT_POSIX_SUCCESS(ret, "work_interval_create, joinable");
96
97 ret = work_interval_copy_port(handle, &port);
98 T_ASSERT_POSIX_SUCCESS(ret, "work_interval_copy_port, joinable");
99
100 ret = work_interval_notify(handle, now - 1000, now, now + 1000, now + 2000, 0);
101 T_ASSERT_EQ(ret, -1, "work_interval_notify on non-joined thread returns -1");
102 T_ASSERT_EQ(errno, EINVAL, "work_interval_copy_port on non-joined thread errno EINVAL");
103
104 ret = work_interval_join_port(port);
105 T_ASSERT_POSIX_SUCCESS(ret, "work_interval_join_port, joinable");
106
107 ret = work_interval_notify(handle, now - 1000, now, now + 1000, now + 2000, 0);
108 T_ASSERT_POSIX_SUCCESS(ret, "work_interval_notify, on joined thread");
109
110 ret = work_interval_join_port(port);
111 T_ASSERT_POSIX_SUCCESS(ret, "work_interval_join_port, join the same interval after destroy");
112
113 kr = mach_port_deallocate(mach_task_self(), port);
114 T_ASSERT_MACH_SUCCESS(kr, "mach_port_deallocate of port");
115
116 ret = work_interval_notify(handle, now - 1000, now, now + 1000, now + 2000, 0);
117 T_ASSERT_POSIX_SUCCESS(ret, "work_interval_notify, on joined thread after destroy");
118
119 ret = work_interval_destroy(handle);
120 T_ASSERT_POSIX_SUCCESS(ret, "work_interval_destroy, joinable, on joined thread");
121
122 ret = work_interval_leave();
123 T_ASSERT_POSIX_SUCCESS(ret, "work_interval_leave, on destroyed work interval");
124 }
125 }
126
127 T_DECL(unentitled_work_interval_create_while_joined, "work interval interface: create while joined")
128 {
129 int ret = 0;
130 work_interval_t handle = NULL;
131 work_interval_t handle2 = NULL;
132 mach_port_t port1 = MACH_PORT_NULL;
133 mach_port_t port2 = MACH_PORT_NULL;
134 kern_return_t kr = KERN_SUCCESS;
135
136 uint32_t flags = WORK_INTERVAL_FLAG_JOINABLE | WORK_INTERVAL_FLAG_GROUP | WORK_INTERVAL_FLAG_UNRESTRICTED | WORK_INTERVAL_TYPE_DEFAULT;
137
138 ret = work_interval_create(&handle, flags);
139 T_ASSERT_POSIX_SUCCESS(ret, "work_interval_create, joinable");
140
141 ret = work_interval_copy_port(handle, &port1);
142 T_ASSERT_POSIX_SUCCESS(ret, "work_interval_copy_port, joinable");
143
144 ret = work_interval_join_port(port1);
145 T_ASSERT_POSIX_SUCCESS(ret, "work_interval_join_port, joinable");
146
147
148 ret = work_interval_create(&handle2, flags);
149 T_ASSERT_POSIX_SUCCESS(ret, "work_interval_create, joinable, while already joined");
150
151 ret = work_interval_copy_port(handle2, &port2);
152 T_ASSERT_POSIX_SUCCESS(ret, "work_interval_copy_port, joinable, while already joined");
153
154 ret = work_interval_join_port(port2);
155 T_ASSERT_POSIX_SUCCESS(ret, "work_interval_join_port, joinable, while already joined");
156
157 ret = work_interval_leave();
158 T_ASSERT_POSIX_SUCCESS(ret, "work_interval_leave, first time");
159
160 ret = work_interval_leave();
161 T_ASSERT_POSIX_SUCCESS(ret, "work_interval_leave, again");
162
163 ret = work_interval_destroy(handle);
164 T_ASSERT_POSIX_SUCCESS(ret, "work_interval_destroy");
165
166 ret = work_interval_destroy(handle2);
167 T_ASSERT_POSIX_SUCCESS(ret, "work_interval_destroy");
168
169 kr = mach_port_deallocate(mach_task_self(), port1);
170 T_ASSERT_MACH_SUCCESS(kr, "mach_port_deallocate of port");
171
172 kr = mach_port_deallocate(mach_task_self(), port2);
173 T_ASSERT_MACH_SUCCESS(kr, "mach_port_deallocate of port");
174 }
175
176 T_DECL(work_interval_audio_unentitled, "unentitled work interval for audio")
177 {
178 int ret = 0;
179 work_interval_t handle = NULL;
180 kern_return_t kr = KERN_SUCCESS;
181
182 uint32_t flags = WORK_INTERVAL_FLAG_GROUP | WORK_INTERVAL_FLAG_JOINABLE | WORK_INTERVAL_TYPE_COREAUDIO | WORK_INTERVAL_FLAG_UNRESTRICTED;
183
184 ret = work_interval_create(&handle, flags);
185 T_ASSERT_POSIX_SUCCESS(ret, "work_interval_create, joinable");
186
187 ret = work_interval_copy_port(handle, &port);
188 T_ASSERT_POSIX_SUCCESS(ret, "work_interval_copy_port, joinable");
189
190 ret = work_interval_join_port(port);
191 T_EXPECT_POSIX_FAILURE(ret, EINVAL, "work_interval_join_port for audio on non-RT thread");
192
193 set_realtime(pthread_self());
194
195 ret = work_interval_join_port(port);
196 T_ASSERT_POSIX_SUCCESS(ret, "work_interval_join_port for audio on RT thread");
197
198 ret = work_interval_leave();
199 T_ASSERT_POSIX_SUCCESS(ret, "work_interval_leave");
200
201 ret = work_interval_destroy(handle);
202 T_ASSERT_POSIX_SUCCESS(ret, "work_interval_destroy");
203
204 kr = mach_port_deallocate(mach_task_self(), port);
205 T_ASSERT_MACH_SUCCESS(kr, "mach_port_deallocate of port");
206
207 set_nonrealtime(pthread_self());
208 }
209