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 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 }