1 /*
2 * This file and its contents are supplied under the terms of the
3 * Common Development and Distribution License ("CDDL"), version 1.0.
4 * You may only use this file in accordance with the terms of version
5 * 1.0 of the CDDL.
6 *
7 * A full copy of the text of the CDDL should have accompanied this
8 * source. A copy of the CDDL is also available via the Internet at
9 * http://www.illumos.org/license/CDDL.
10 */
11
12 /*
13 * Copyright 2016 Joyent, Inc.
14 */
15
16 /*
17 * Test and verify that pthrad_attr_get_np works as we expect.
18 *
19 * Verify the following:
20 * o ESRCH
21 * o stack size is set to a valid value after a thread is created.
22 * o main thread can grab an alternate thread's info.
23 * o custom guard size is honored
24 * o detach state
25 * - detached 1
26 * - joinable 2
27 * - changing 2
28 * o daemon state
29 * - enabled 1
30 * - disabled 2
31 * o scope
32 * - system 1
33 * - process 2
34 * o inheritable
35 * - inherit 1
36 * - explicit 2
37 * o priority
38 * - honors change 2
39 * o policy
40 * - honours change 2
41 *
42 *
43 * For each of the cases above we explicitly go through and create the set of
44 * attributes as marked above and then inside of a thread, verify that the
45 * attributes match what we expect. Because each case ends up in creating a
46 * detached thread, we opt to have both it and the main thread enter a barrier
47 * to indicate that we have completed the test successfully.
48 */
49
50 #include <errno.h>
51 #include <limits.h>
52 #include <stdio.h>
53 #include <pthread.h>
54 #include <unistd.h>
55 #include <ucontext.h>
56 #include <sched.h>
57 #include <strings.h>
58 #include <stdlib.h>
59
60 #include <sys/procfs.h>
61 #include <sys/debug.h>
62
63 /*
64 * Currently these are only defined in thr_uberdata.h. Rather than trying and
65 * fight with libc headers, just explicitly define them here.
66 */
67 #define PTHREAD_CREATE_DAEMON_NP 0x100 /* = THR_DAEMON */
68 #define PTHREAD_CREATE_NONDAEMON_NP 0
69 extern int pthread_attr_setdaemonstate_np(pthread_attr_t *, int);
70 extern int pthread_attr_getdaemonstate_np(const pthread_attr_t *, int *);
71
72 #define PGN_TEST_PRI 23
73
74 static pthread_attr_t pgn_attr;
75 static pthread_attr_t pgn_thr_attr;
76 static pthread_barrier_t pgn_barrier;
77
78 #ifdef __sparc
79 #define gregs __gregs
80 #endif
81
82 /*
83 * Verify that the stack pointer of a context is consistent with where the
84 * attributes indicate.
85 */
86 static void
87 pgn_verif_thr_stack(pthread_attr_t *attr)
88 {
89 size_t stksz;
90 void *stk;
91 ucontext_t ctx;
92 uint32_t sp;
93
94 VERIFY0(getcontext(&ctx));
95 VERIFY0(pthread_attr_getstack(attr, &stk, &stksz));
96 VERIFY3P(stk, !=, NULL);
97 VERIFY3S(stksz, !=, 0);
98 sp = ctx.uc_mcontext.gregs[R_SP];
99 VERIFY3U(sp, >, (uintptr_t)stk);
100 VERIFY3U(sp, <, (uintptr_t)stk + stksz);
101 }
102
103 #ifdef __sparc
104 #undef gregs
105 #endif
106
107 static void
108 pgn_test_fini(void)
109 {
110 int ret;
111
112 ret = pthread_barrier_wait(&pgn_barrier);
113 VERIFY(ret == 0 || ret == PTHREAD_BARRIER_SERIAL_THREAD);
114 VERIFY0(pthread_attr_destroy(&pgn_attr));
115 VERIFY0(pthread_attr_destroy(&pgn_thr_attr));
116 VERIFY0(pthread_barrier_destroy(&pgn_barrier));
117 }
118
119 static void
120 pgn_test_init(void)
121 {
122 VERIFY0(pthread_attr_init(&pgn_attr));
123 VERIFY0(pthread_attr_init(&pgn_thr_attr));
124 VERIFY0(pthread_barrier_init(&pgn_barrier, NULL, 2));
125 }
126
127 /* ARGSUSED */
128 static void *
129 pgn_set_one_thr(void *arg)
130 {
131 int odetach, ndetach;
132 int odaemon, ndaemon;
133 int oscope, nscope;
134 int oinherit, ninherit;
135
136 VERIFY0(pthread_attr_get_np(pthread_self(), &pgn_attr));
137 pgn_verif_thr_stack(&pgn_attr);
138
139 VERIFY0(pthread_attr_getdetachstate(&pgn_thr_attr, &odetach));
140 VERIFY0(pthread_attr_getdetachstate(&pgn_attr, &ndetach));
141
142 VERIFY3S(odetach, ==, ndetach);
143 VERIFY3S(ndetach, ==, PTHREAD_CREATE_DETACHED);
144
145 VERIFY0(pthread_attr_getdaemonstate_np(&pgn_thr_attr, &odaemon));
146 VERIFY0(pthread_attr_getdaemonstate_np(&pgn_attr, &ndaemon));
147
148 VERIFY3S(odaemon, ==, ndaemon);
149 VERIFY3S(ndaemon, ==, PTHREAD_CREATE_DAEMON_NP);
150
151 VERIFY0(pthread_attr_getscope(&pgn_thr_attr, &oscope));
152 VERIFY0(pthread_attr_getscope(&pgn_attr, &nscope));
153
154 VERIFY3S(oscope, ==, nscope);
155 VERIFY3S(nscope, ==, PTHREAD_SCOPE_SYSTEM);
156
157 VERIFY0(pthread_attr_getinheritsched(&pgn_thr_attr, &oinherit));
158 VERIFY0(pthread_attr_getinheritsched(&pgn_attr, &ninherit));
159
160 VERIFY3S(oinherit, ==, ninherit);
161 VERIFY3S(ninherit, ==, PTHREAD_INHERIT_SCHED);
162
163 VERIFY3S(pthread_barrier_wait(&pgn_barrier), !=, 1);
164 return (NULL);
165 }
166
167 static void
168 pgn_set_one(void)
169 {
170 int ret;
171 pthread_t thr;
172
173 pgn_test_init();
174
175 VERIFY0(pthread_attr_setdetachstate(&pgn_thr_attr,
176 PTHREAD_CREATE_DETACHED));
177 VERIFY0(pthread_attr_setdaemonstate_np(&pgn_thr_attr,
178 PTHREAD_CREATE_DAEMON_NP));
179 VERIFY0(pthread_attr_setscope(&pgn_thr_attr, PTHREAD_SCOPE_SYSTEM));
180 VERIFY0(pthread_attr_setinheritsched(&pgn_thr_attr,
181 PTHREAD_INHERIT_SCHED));
182
183 VERIFY0(pthread_create(&thr, &pgn_thr_attr, pgn_set_one_thr, NULL));
184
185 /*
186 * Verify it's not joinable.
187 */
188 ret = pthread_join(thr, NULL);
189 VERIFY3S(ret, ==, EINVAL);
190
191 /*
192 * At this point we let the test continue and wait on the barrier. We'll
193 * wake up when the other thread is done.
194 */
195 pgn_test_fini();
196 }
197
198 /* ARGSUSED */
199 static void *
200 pgn_set_two_thr(void *arg)
201 {
202 int odetach, ndetach;
203 int odaemon, ndaemon;
204 int oscope, nscope;
205 int oinherit, ninherit;
206 int opolicy, npolicy;
207 struct sched_param oparam, nparam;
208
209 VERIFY0(pthread_attr_get_np(pthread_self(), &pgn_attr));
210 pgn_verif_thr_stack(&pgn_attr);
211
212 VERIFY0(pthread_attr_getdetachstate(&pgn_thr_attr, &odetach));
213 VERIFY0(pthread_attr_getdetachstate(&pgn_attr, &ndetach));
214
215 VERIFY3S(odetach, ==, ndetach);
216 VERIFY3S(ndetach, ==, PTHREAD_CREATE_JOINABLE);
217
218 VERIFY0(pthread_attr_getdaemonstate_np(&pgn_thr_attr, &odaemon));
219 VERIFY0(pthread_attr_getdaemonstate_np(&pgn_attr, &ndaemon));
220
221 VERIFY3S(odaemon, ==, ndaemon);
222 VERIFY3S(ndaemon, ==, PTHREAD_CREATE_NONDAEMON_NP);
223
224 VERIFY0(pthread_attr_getscope(&pgn_thr_attr, &oscope));
225 VERIFY0(pthread_attr_getscope(&pgn_attr, &nscope));
226
227 VERIFY3S(oscope, ==, nscope);
228 VERIFY3S(nscope, ==, PTHREAD_SCOPE_PROCESS);
229
230 VERIFY0(pthread_attr_getinheritsched(&pgn_thr_attr, &oinherit));
231 VERIFY0(pthread_attr_getinheritsched(&pgn_attr, &ninherit));
232
233 VERIFY3S(oinherit, ==, ninherit);
234 VERIFY3S(ninherit, ==, PTHREAD_EXPLICIT_SCHED);
235
236 VERIFY0(pthread_attr_getschedpolicy(&pgn_thr_attr, &opolicy));
237 VERIFY0(pthread_attr_getschedpolicy(&pgn_attr, &npolicy));
238
239 VERIFY3S(opolicy, ==, npolicy);
240 VERIFY3S(npolicy, ==, SCHED_FSS);
241
242 /*
243 * Now that we've validated the basics, go ahead and test the changes,
244 * which include making sure that we see updates via
245 * pthread_setschedparam() and pthread_detach().
246 */
247 VERIFY0(pthread_detach(pthread_self()));
248
249 opolicy = SCHED_FX;
250 oparam.sched_priority = PGN_TEST_PRI;
251 VERIFY0(pthread_setschedparam(pthread_self(), opolicy, &oparam));
252
253 VERIFY0(pthread_attr_get_np(pthread_self(), &pgn_attr));
254 VERIFY0(pthread_attr_getdetachstate(&pgn_attr, &ndetach));
255
256 VERIFY3S(odetach, !=, ndetach);
257 VERIFY3S(ndetach, ==, PTHREAD_CREATE_DETACHED);
258
259 VERIFY0(pthread_attr_getschedpolicy(&pgn_attr, &npolicy));
260 VERIFY0(pthread_attr_getschedparam(&pgn_attr, &nparam));
261
262 VERIFY3S(opolicy, ==, npolicy);
263 VERIFY3S(npolicy, ==, SCHED_FX);
264
265 VERIFY3S(oparam.sched_priority, ==, nparam.sched_priority);
266 VERIFY3S(nparam.sched_priority, ==, PGN_TEST_PRI);
267
268 VERIFY3S(pthread_barrier_wait(&pgn_barrier), !=, 1);
269
270 return (NULL);
271 }
272
273 static void
274 pgn_set_two(void)
275 {
276 pthread_t thr;
277
278 pgn_test_init();
279
280 VERIFY0(pthread_attr_setdetachstate(&pgn_thr_attr,
281 PTHREAD_CREATE_JOINABLE));
282 VERIFY0(pthread_attr_setdaemonstate_np(&pgn_thr_attr,
283 PTHREAD_CREATE_NONDAEMON_NP));
284 VERIFY0(pthread_attr_setscope(&pgn_thr_attr, PTHREAD_SCOPE_PROCESS));
285 VERIFY0(pthread_attr_setinheritsched(&pgn_thr_attr,
286 PTHREAD_EXPLICIT_SCHED));
287 VERIFY0(pthread_attr_setschedpolicy(&pgn_thr_attr, SCHED_FSS));
288
289 VERIFY0(pthread_create(&thr, &pgn_thr_attr, pgn_set_two_thr, NULL));
290
291 /*
292 * At this point we let the test continue and wait on the barrier. We'll
293 * wake up when the other thread is done.
294 */
295 pgn_test_fini();
296 }
297
298 /* ARGSUSED */
299 static void *
300 pgn_set_three_thr(void *arg)
301 {
302 VERIFY3S(pthread_barrier_wait(&pgn_barrier), !=, 1);
303
304 return (NULL);
305 }
306
307 void
308 pgn_set_three(void)
309 {
310 pthread_t thr;
311 pthread_attr_t altattr, selfattr;
312 void *altstk, *selfstk;
313 size_t altsz, selfsz;
314
315 VERIFY0(pthread_attr_init(&altattr));
316 VERIFY0(pthread_attr_init(&selfattr));
317 pgn_test_init();
318
319 VERIFY0(pthread_create(&thr, NULL, pgn_set_three_thr, NULL));
320
321 VERIFY0(pthread_attr_get_np(thr, &altattr));
322 VERIFY0(pthread_attr_get_np(pthread_self(), &selfattr));
323
324 VERIFY0(pthread_attr_getstack(&selfattr, &selfstk, &selfsz));
325 VERIFY0(pthread_attr_getstack(&altattr, &altstk, &altsz));
326 VERIFY3P(altstk, !=, selfstk);
327
328 pgn_test_fini();
329 VERIFY0(pthread_attr_destroy(&selfattr));
330 VERIFY0(pthread_attr_destroy(&altattr));
331 }
332
333 int
334 main(void)
335 {
336 int ret;
337
338 VERIFY0(pthread_attr_init(&pgn_attr));
339
340 ret = pthread_attr_get_np(UINT32_MAX, &pgn_attr);
341 VERIFY3S(ret, ==, ESRCH);
342
343 pgn_set_one();
344 pgn_set_two();
345 pgn_set_three();
346
347 exit(0);
348 }