1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /*
28 * Copyright 2015, Joyent, Inc.
29 */
30
31 #include "lint.h"
32 #include "thr_uberdata.h"
33 #include <sched.h>
34
35 /*
36 * Default attribute object for pthread_create() with NULL attr pointer.
37 * Note that the 'guardsize' field is initialized on the first call.
38 */
39 const thrattr_t *
40 def_thrattr(void)
41 {
42 static thrattr_t thrattr = {
43 0, /* stksize */
44 NULL, /* stkaddr */
45 PTHREAD_CREATE_JOINABLE, /* detachstate */
46 PTHREAD_CREATE_NONDAEMON_NP, /* daemonstate */
47 PTHREAD_SCOPE_PROCESS, /* scope */
48 0, /* prio */
49 SCHED_OTHER, /* policy */
50 PTHREAD_INHERIT_SCHED, /* inherit */
51 0 /* guardsize */
52 };
53 if (thrattr.guardsize == 0)
54 thrattr.guardsize = _sysconf(_SC_PAGESIZE);
55 return (&thrattr);
56 }
57
58 /*
59 * pthread_attr_init: allocates the attribute object and initializes it
60 * with the default values.
61 */
62 #pragma weak _pthread_attr_init = pthread_attr_init
63 int
64 pthread_attr_init(pthread_attr_t *attr)
65 {
66 thrattr_t *ap;
67
68 if ((ap = lmalloc(sizeof (thrattr_t))) != NULL) {
69 *ap = *def_thrattr();
70 attr->__pthread_attrp = ap;
71 return (0);
72 }
73 return (ENOMEM);
74 }
75
76 /*
77 * pthread_attr_destroy: frees the attribute object and invalidates it
78 * with NULL value.
79 */
80 int
81 pthread_attr_destroy(pthread_attr_t *attr)
82 {
83 if (attr == NULL || attr->__pthread_attrp == NULL)
84 return (EINVAL);
85 lfree(attr->__pthread_attrp, sizeof (thrattr_t));
86 attr->__pthread_attrp = NULL;
87 return (0);
88 }
89
90 /*
91 * pthread_attr_clone: make a copy of a pthread_attr_t.
92 */
93 int
94 pthread_attr_clone(pthread_attr_t *attr, const pthread_attr_t *old_attr)
95 {
96 thrattr_t *ap;
97 const thrattr_t *old_ap =
98 old_attr? old_attr->__pthread_attrp : def_thrattr();
99
100 if (old_ap == NULL)
101 return (EINVAL);
102 if ((ap = lmalloc(sizeof (thrattr_t))) == NULL)
103 return (ENOMEM);
104 *ap = *old_ap;
105 attr->__pthread_attrp = ap;
106 return (0);
107 }
108
109 /*
110 * pthread_attr_equal: compare two pthread_attr_t's, return 1 if equal.
111 * A NULL pthread_attr_t pointer implies default attributes.
112 * This is a consolidation-private interface, for librt.
113 */
114 int
115 pthread_attr_equal(const pthread_attr_t *attr1, const pthread_attr_t *attr2)
116 {
117 const thrattr_t *ap1 = attr1? attr1->__pthread_attrp : def_thrattr();
118 const thrattr_t *ap2 = attr2? attr2->__pthread_attrp : def_thrattr();
119
120 if (ap1 == NULL || ap2 == NULL)
121 return (0);
122 return (ap1 == ap2 || memcmp(ap1, ap2, sizeof (thrattr_t)) == 0);
123 }
124
125 /*
126 * pthread_attr_setstacksize: sets the user stack size, minimum should
127 * be PTHREAD_STACK_MIN (MINSTACK).
128 * This is equivalent to stksize argument in thr_create().
129 */
130 int
131 pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize)
132 {
133 thrattr_t *ap;
134
135 if (attr != NULL && (ap = attr->__pthread_attrp) != NULL &&
136 stacksize >= MINSTACK) {
137 ap->stksize = stacksize;
138 return (0);
139 }
140 return (EINVAL);
141 }
142
143 /*
144 * pthread_attr_getstacksize: gets the user stack size.
145 */
146 #pragma weak _pthread_attr_getstacksize = pthread_attr_getstacksize
147 int
148 pthread_attr_getstacksize(const pthread_attr_t *attr, size_t *stacksize)
149 {
150 thrattr_t *ap;
151
152 if (attr != NULL && (ap = attr->__pthread_attrp) != NULL &&
153 stacksize != NULL) {
154 *stacksize = ap->stksize;
155 return (0);
156 }
157 return (EINVAL);
158 }
159
160 /*
161 * pthread_attr_setstackaddr: sets the user stack addr.
162 * This is equivalent to stkaddr argument in thr_create().
163 */
164 int
165 pthread_attr_setstackaddr(pthread_attr_t *attr, void *stackaddr)
166 {
167 thrattr_t *ap;
168
169 if (attr != NULL && (ap = attr->__pthread_attrp) != NULL) {
170 ap->stkaddr = stackaddr;
171 return (0);
172 }
173 return (EINVAL);
174 }
175
176 /*
177 * pthread_attr_getstackaddr: gets the user stack addr.
178 */
179 #pragma weak _pthread_attr_getstackaddr = pthread_attr_getstackaddr
180 int
181 pthread_attr_getstackaddr(const pthread_attr_t *attr, void **stackaddr)
182 {
183 thrattr_t *ap;
184
185 if (attr != NULL && (ap = attr->__pthread_attrp) != NULL &&
186 stackaddr != NULL) {
187 *stackaddr = ap->stkaddr;
188 return (0);
189 }
190 return (EINVAL);
191 }
192
193 /*
194 * pthread_attr_setdetachstate: sets the detach state to DETACHED or JOINABLE.
195 * PTHREAD_CREATE_DETACHED is equivalent to thr_create(THR_DETACHED).
196 */
197 int
198 pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate)
199 {
200 thrattr_t *ap;
201
202 if (attr != NULL && (ap = attr->__pthread_attrp) != NULL &&
203 (detachstate == PTHREAD_CREATE_DETACHED ||
204 detachstate == PTHREAD_CREATE_JOINABLE)) {
205 ap->detachstate = detachstate;
206 return (0);
207 }
208 return (EINVAL);
209 }
210
211 /*
212 * pthread_attr_getdetachstate: gets the detach state.
213 */
214 #pragma weak _pthread_attr_getdetachstate = pthread_attr_getdetachstate
215 int
216 pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate)
217 {
218 thrattr_t *ap;
219
220 if (attr != NULL && (ap = attr->__pthread_attrp) != NULL &&
221 detachstate != NULL) {
222 *detachstate = ap->detachstate;
223 return (0);
224 }
225 return (EINVAL);
226 }
227
228 /*
229 * pthread_attr_setdaemonstate_np: sets the daemon state to DAEMON or NONDAEMON.
230 * PTHREAD_CREATE_DAEMON is equivalent to thr_create(THR_DAEMON).
231 * For now, this is a private interface in libc.
232 */
233 int
234 pthread_attr_setdaemonstate_np(pthread_attr_t *attr, int daemonstate)
235 {
236 thrattr_t *ap;
237
238 if (attr != NULL && (ap = attr->__pthread_attrp) != NULL &&
239 (daemonstate == PTHREAD_CREATE_DAEMON_NP ||
240 daemonstate == PTHREAD_CREATE_NONDAEMON_NP)) {
241 ap->daemonstate = daemonstate;
242 return (0);
243 }
244 return (EINVAL);
245 }
246
247 /*
248 * pthread_attr_getdaemonstate_np: gets the daemon state.
249 * For now, this is a private interface in libc, but it is exposed in the
250 * mapfile for the purposes of testing only.
251 */
252 int
253 pthread_attr_getdaemonstate_np(const pthread_attr_t *attr, int *daemonstate)
254 {
255 thrattr_t *ap;
256
257 if (attr != NULL && (ap = attr->__pthread_attrp) != NULL &&
258 daemonstate != NULL) {
259 *daemonstate = ap->daemonstate;
260 return (0);
261 }
262 return (EINVAL);
263 }
264
265 /*
266 * pthread_attr_setscope: sets the scope to SYSTEM or PROCESS.
267 * This is equivalent to setting THR_BOUND flag in thr_create().
268 */
269 int
270 pthread_attr_setscope(pthread_attr_t *attr, int scope)
271 {
272 thrattr_t *ap;
273
274 if (attr != NULL && (ap = attr->__pthread_attrp) != NULL &&
275 (scope == PTHREAD_SCOPE_SYSTEM ||
276 scope == PTHREAD_SCOPE_PROCESS)) {
277 ap->scope = scope;
278 return (0);
279 }
280 return (EINVAL);
281 }
282
283 /*
284 * pthread_attr_getscope: gets the scheduling scope.
285 */
286 #pragma weak _pthread_attr_getscope = pthread_attr_getscope
287 int
288 pthread_attr_getscope(const pthread_attr_t *attr, int *scope)
289 {
290 thrattr_t *ap;
291
292 if (attr != NULL && (ap = attr->__pthread_attrp) != NULL &&
293 scope != NULL) {
294 *scope = ap->scope;
295 return (0);
296 }
297 return (EINVAL);
298 }
299
300 /*
301 * pthread_attr_setinheritsched: sets the scheduling parameters to be
302 * EXPLICIT or INHERITED from parent thread.
303 */
304 int
305 pthread_attr_setinheritsched(pthread_attr_t *attr, int inherit)
306 {
307 thrattr_t *ap;
308
309 if (attr != NULL && (ap = attr->__pthread_attrp) != NULL &&
310 (inherit == PTHREAD_EXPLICIT_SCHED ||
311 inherit == PTHREAD_INHERIT_SCHED)) {
312 ap->inherit = inherit;
313 return (0);
314 }
315 return (EINVAL);
316 }
317
318 /*
319 * pthread_attr_getinheritsched: gets the scheduling inheritance.
320 */
321 #pragma weak _pthread_attr_getinheritsched = pthread_attr_getinheritsched
322 int
323 pthread_attr_getinheritsched(const pthread_attr_t *attr, int *inherit)
324 {
325 thrattr_t *ap;
326
327 if (attr != NULL && (ap = attr->__pthread_attrp) != NULL &&
328 inherit != NULL) {
329 *inherit = ap->inherit;
330 return (0);
331 }
332 return (EINVAL);
333 }
334
335 /*
336 * pthread_attr_setschedpolicy: sets the scheduling policy.
337 */
338 int
339 pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy)
340 {
341 thrattr_t *ap;
342
343 if (attr != NULL && (ap = attr->__pthread_attrp) != NULL &&
344 policy != SCHED_SYS && get_info_by_policy(policy) != NULL) {
345 ap->policy = policy;
346 return (0);
347 }
348 return (EINVAL);
349 }
350
351 /*
352 * pthread_attr_getpolicy: gets the scheduling policy.
353 */
354 #pragma weak _pthread_attr_getschedpolicy = pthread_attr_getschedpolicy
355 int
356 pthread_attr_getschedpolicy(const pthread_attr_t *attr, int *policy)
357 {
358 thrattr_t *ap;
359
360 if (attr != NULL && (ap = attr->__pthread_attrp) != NULL &&
361 policy != NULL) {
362 *policy = ap->policy;
363 return (0);
364 }
365 return (EINVAL);
366 }
367
368 /*
369 * pthread_attr_setschedparam: sets the scheduling parameters.
370 * Currently, we support priority only.
371 */
372 int
373 pthread_attr_setschedparam(pthread_attr_t *attr,
374 const struct sched_param *param)
375 {
376 thrattr_t *ap;
377
378 if (attr != NULL && (ap = attr->__pthread_attrp) != NULL &&
379 param != NULL) {
380 ap->prio = param->sched_priority;
381 return (0);
382 }
383 return (EINVAL);
384 }
385
386 /*
387 * pthread_attr_getschedparam: gets the scheduling parameters.
388 * Currently, only priority is defined as sched parameter.
389 */
390 #pragma weak _pthread_attr_getschedparam = pthread_attr_getschedparam
391 int
392 pthread_attr_getschedparam(const pthread_attr_t *attr,
393 struct sched_param *param)
394 {
395 thrattr_t *ap;
396
397 if (attr != NULL && (ap = attr->__pthread_attrp) != NULL &&
398 param != NULL) {
399 param->sched_priority = ap->prio;
400 return (0);
401 }
402 return (EINVAL);
403 }
404
405 /*
406 * UNIX98
407 * pthread_attr_setguardsize: sets the guardsize
408 */
409 int
410 pthread_attr_setguardsize(pthread_attr_t *attr, size_t guardsize)
411 {
412 thrattr_t *ap;
413
414 if (attr != NULL && (ap = attr->__pthread_attrp) != NULL) {
415 ap->guardsize = guardsize;
416 return (0);
417 }
418 return (EINVAL);
419 }
420
421 /*
422 * UNIX98
423 * pthread_attr_getguardsize: gets the guardsize
424 */
425 int
426 pthread_attr_getguardsize(const pthread_attr_t *attr, size_t *guardsize)
427 {
428 thrattr_t *ap;
429
430 if (attr != NULL && (ap = attr->__pthread_attrp) != NULL &&
431 guardsize != NULL) {
432 *guardsize = ap->guardsize;
433 return (0);
434 }
435 return (EINVAL);
436 }
437
438 /*
439 * pthread_attr_setstack: sets the user stack addr and stack size.
440 * This is equivalent to the stack_base and stack_size arguments
441 * to thr_create().
442 */
443 int
444 pthread_attr_setstack(pthread_attr_t *attr,
445 void *stackaddr, size_t stacksize)
446 {
447 thrattr_t *ap;
448
449 if (attr != NULL && (ap = attr->__pthread_attrp) != NULL &&
450 stacksize >= MINSTACK) {
451 ap->stkaddr = stackaddr;
452 ap->stksize = stacksize;
453 if (stackaddr != NULL &&
454 setup_top_frame(stackaddr, stacksize, NULL) == NULL)
455 return (EACCES);
456 return (0);
457 }
458 return (EINVAL);
459 }
460
461 /*
462 * pthread_attr_getstack: gets the user stack addr and stack size.
463 */
464 int
465 pthread_attr_getstack(const pthread_attr_t *attr,
466 void **stackaddr, size_t *stacksize)
467 {
468 thrattr_t *ap;
469
470 if (attr != NULL && (ap = attr->__pthread_attrp) != NULL &&
471 stackaddr != NULL && stacksize != NULL) {
472 *stackaddr = ap->stkaddr;
473 *stacksize = ap->stksize;
474 return (0);
475 }
476 return (EINVAL);
477 }
478
479 /*
480 * This function is a common BSD extension to pthread which is used to obtain
481 * the attributes of a thread that might have changed after its creation, for
482 * example, it's stack address.
483 *
484 * Note, there is no setattr analogue, nor do we desire to add one at this time.
485 * Similarly there is no native threads API analogue (nor should we add one for
486 * C11).
487 *
488 * The astute reader may note that there is a GNU version of this called
489 * pthread_getattr_np(). The two functions are similar, but subtley different in
490 * a rather important way. While the pthread_attr_get_np() expects to be given
491 * a pthread_attr_t that has had pthread_attr_init() called on in,
492 * pthread_getattr_np() does not. However, on GNU systems, where the function
493 * originates, the pthread_attr_t is not opaque and thus it is entirely safe to
494 * both call pthread_attr_init() and then call pthread_getattr_np() on the same
495 * attributes object. On illumos, since the pthread_attr_t is opaque, that would
496 * be a memory leak. As such, we don't provide it.
497 */
498 int
499 pthread_attr_get_np(pthread_t tid, pthread_attr_t *attr)
500 {
501 int ret;
502 ulwp_t *self = curthread;
503 uberdata_t *udp = self->ul_uberdata;
504 ulwp_t *target = NULL;
505 thrattr_t *ap;
506
507 /*
508 * To ensure that information about the target thread does not change or
509 * disappear while we're trying to interrogate it, we grab the uwlp
510 * lock.
511 */
512 if (self->ul_lwpid == tid) {
513 ulwp_lock(self, udp);
514 target = self;
515 } else {
516 target = find_lwp(tid);
517 if (target == NULL)
518 return (ESRCH);
519 }
520
521 if (attr == NULL) {
522 ret = EINVAL;
523 goto out;
524 }
525
526 if ((ap = attr->__pthread_attrp) == NULL) {
527 ret = EINVAL;
528 goto out;
529 }
530
531 ap->stksize = target->ul_stksiz;
532 ap->stkaddr = target->ul_stk;
533 if (target->ul_usropts & THR_DETACHED) {
534 ap->detachstate = PTHREAD_CREATE_DETACHED;
535 } else {
536 ap->detachstate = PTHREAD_CREATE_JOINABLE;
537 }
538
539 if (target->ul_usropts & THR_DAEMON) {
540 ap->daemonstate = PTHREAD_CREATE_DAEMON_NP;
541 } else {
542 ap->daemonstate = PTHREAD_CREATE_NONDAEMON_NP;
543 }
544
545 if (target->ul_usropts & THR_BOUND) {
546 ap->scope = PTHREAD_SCOPE_SYSTEM;
547 } else {
548 ap->scope = PTHREAD_SCOPE_PROCESS;
549 }
550 ap->prio = target->ul_pri;
551 ap->policy = target->ul_policy;
552 ap->inherit = target->ul_ptinherit;
553 ap->guardsize = target->ul_guardsize;
554
555 ret = 0;
556 out:
557 ulwp_unlock(target, udp);
558 return (ret);
559 }