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