usr/src/lib/libc/port/threads/pthr_attr.c

   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 }