linuxthreads/attr.c

   1 /* Linuxthreads - a simple clone()-based implementation of Posix        */
   2 /* threads for Linux.                                                   */
   3 /* Copyright (C) 1996 Xavier Leroy (Xavier.Leroy@inria.fr)              */
   4 /*                                                                      */
   5 /* This program is free software; you can redistribute it and/or        */
   6 /* modify it under the terms of the GNU Library General Public License  */
   7 /* as published by the Free Software Foundation; either version 2       */
   8 /* of the License, or (at your option) any later version.               */
   9 /*                                                                      */
  10 /* This program is distributed in the hope that it will be useful,      */
  11 /* but WITHOUT ANY WARRANTY; without even the implied warranty of       */
  12 /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        */
  13 /* GNU Library General Public License for more details.                 */
  14
  15 /* Handling of thread attributes */
  16
  17 #include <errno.h>
  18 #include <string.h>
  19 #include <unistd.h>
  20 #include <sys/param.h>
  21 #include <sys/resource.h>
  22 #include "pthread.h"
  23 #include "internals.h"
  24 #include <shlib-compat.h>
  25
  26 int __pthread_attr_init_2_1(pthread_attr_t *attr)
  27 {
  28   size_t ps = __getpagesize ();
  29
  30   attr->__detachstate = PTHREAD_CREATE_JOINABLE;
  31   attr->__schedpolicy = SCHED_OTHER;
  32   attr->__schedparam.sched_priority = 0;
  33   attr->__inheritsched = PTHREAD_EXPLICIT_SCHED;
  34   attr->__scope = PTHREAD_SCOPE_SYSTEM;
  35   attr->__guardsize = ps;
  36   attr->__stackaddr = NULL;
  37   attr->__stackaddr_set = 0;
  38   attr->__stacksize = STACK_SIZE - ps;
  39   return 0;
  40 }
  41
  42 versioned_symbol (libpthread, __pthread_attr_init_2_1, pthread_attr_init,
  43                   GLIBC_2_1);
  44
  45 #if SHLIB_COMPAT(libpthread, GLIBC_2_0, GLIBC_2_1)
  46 int __pthread_attr_init_2_0(pthread_attr_t *attr)
  47 {
  48   attr->__detachstate = PTHREAD_CREATE_JOINABLE;
  49   attr->__schedpolicy = SCHED_OTHER;
  50   attr->__schedparam.sched_priority = 0;
  51   attr->__inheritsched = PTHREAD_EXPLICIT_SCHED;
  52   attr->__scope = PTHREAD_SCOPE_SYSTEM;
  53   return 0;
  54 }
  55 compat_symbol (libpthread, __pthread_attr_init_2_0, pthread_attr_init,
  56                GLIBC_2_0);
  57 #endif
  58
  59 int __pthread_attr_destroy(pthread_attr_t *attr)
  60 {
  61   return 0;
  62 }
  63 strong_alias (__pthread_attr_destroy, pthread_attr_destroy);
  64
  65 int __pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate)
  66 {
  67   if (detachstate < PTHREAD_CREATE_JOINABLE ||
  68       detachstate > PTHREAD_CREATE_DETACHED)
  69     return EINVAL;
  70   attr->__detachstate = detachstate;
  71   return 0;
  72 }
  73 strong_alias (__pthread_attr_setdetachstate, pthread_attr_setdetachstate);
  74
  75 int __pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate)
  76 {
  77   *detachstate = attr->__detachstate;
  78   return 0;
  79 }
  80 strong_alias (__pthread_attr_getdetachstate, pthread_attr_getdetachstate);
  81
  82 int __pthread_attr_setschedparam(pthread_attr_t *attr,
  83                                  const struct sched_param *param)
  84 {
  85   int max_prio = __sched_get_priority_max(attr->__schedpolicy);
  86   int min_prio = __sched_get_priority_min(attr->__schedpolicy);
  87
  88   if (param->sched_priority < min_prio || param->sched_priority > max_prio)
  89     return EINVAL;
  90   memcpy (&attr->__schedparam, param, sizeof (struct sched_param));
  91   return 0;
  92 }
  93 strong_alias (__pthread_attr_setschedparam, pthread_attr_setschedparam);
  94
  95 int __pthread_attr_getschedparam(const pthread_attr_t *attr,
  96                                  struct sched_param *param)
  97 {
  98   memcpy (param, &attr->__schedparam, sizeof (struct sched_param));
  99   return 0;
 100 }
 101 strong_alias (__pthread_attr_getschedparam, pthread_attr_getschedparam);
 102
 103 int __pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy)
 104 {
 105   if (policy != SCHED_OTHER && policy != SCHED_FIFO && policy != SCHED_RR)
 106     return EINVAL;
 107   attr->__schedpolicy = policy;
 108   return 0;
 109 }
 110 strong_alias (__pthread_attr_setschedpolicy, pthread_attr_setschedpolicy);
 111
 112 int __pthread_attr_getschedpolicy(const pthread_attr_t *attr, int *policy)
 113 {
 114   *policy = attr->__schedpolicy;
 115   return 0;
 116 }
 117 strong_alias (__pthread_attr_getschedpolicy, pthread_attr_getschedpolicy);
 118
 119 int __pthread_attr_setinheritsched(pthread_attr_t *attr, int inherit)
 120 {
 121   if (inherit != PTHREAD_INHERIT_SCHED && inherit != PTHREAD_EXPLICIT_SCHED)
 122     return EINVAL;
 123   attr->__inheritsched = inherit;
 124   return 0;
 125 }
 126 strong_alias (__pthread_attr_setinheritsched, pthread_attr_setinheritsched);
 127
 128 int __pthread_attr_getinheritsched(const pthread_attr_t *attr, int *inherit)
 129 {
 130   *inherit = attr->__inheritsched;
 131   return 0;
 132 }
 133 strong_alias (__pthread_attr_getinheritsched, pthread_attr_getinheritsched);
 134
 135 int __pthread_attr_setscope(pthread_attr_t *attr, int scope)
 136 {
 137   switch (scope) {
 138   case PTHREAD_SCOPE_SYSTEM:
 139     attr->__scope = scope;
 140     return 0;
 141   case PTHREAD_SCOPE_PROCESS:
 142     return ENOTSUP;
 143   default:
 144     return EINVAL;
 145   }
 146 }
 147 strong_alias (__pthread_attr_setscope, pthread_attr_setscope);
 148
 149 int __pthread_attr_getscope(const pthread_attr_t *attr, int *scope)
 150 {
 151   *scope = attr->__scope;
 152   return 0;
 153 }
 154 strong_alias (__pthread_attr_getscope, pthread_attr_getscope);
 155
 156 int __pthread_attr_setguardsize(pthread_attr_t *attr, size_t guardsize)
 157 {
 158   /* The guard size must not be larger than the stack itself */
 159   if (guardsize >= attr->__stacksize) return EINVAL;
 160
 161   attr->__guardsize = guardsize;
 162
 163   return 0;
 164 }
 165 weak_alias (__pthread_attr_setguardsize, pthread_attr_setguardsize)
 166
 167 int __pthread_attr_getguardsize(const pthread_attr_t *attr, size_t *guardsize)
 168 {
 169   *guardsize = attr->__guardsize;
 170   return 0;
 171 }
 172 weak_alias (__pthread_attr_getguardsize, pthread_attr_getguardsize)
 173
 174 int __pthread_attr_setstackaddr(pthread_attr_t *attr, void *stackaddr)
 175 {
 176   attr->__stackaddr = stackaddr;
 177   attr->__stackaddr_set = 1;
 178   return 0;
 179 }
 180 weak_alias (__pthread_attr_setstackaddr, pthread_attr_setstackaddr)
 181
 182 link_warning (pthread_attr_setstackaddr,
 183               "the use of `pthread_attr_setstackaddr' is deprecated, use `pthread_attr_setstack'")
 184
 185 int __pthread_attr_getstackaddr(const pthread_attr_t *attr, void **stackaddr)
 186 {
 187   /* XXX This function has a stupid definition.  The standard specifies
 188      no error value but what is if no stack address was set?  We simply
 189      return the value we have in the member.  */
 190   *stackaddr = attr->__stackaddr;
 191   return 0;
 192 }
 193 weak_alias (__pthread_attr_getstackaddr, pthread_attr_getstackaddr)
 194
 195 link_warning (pthread_attr_getstackaddr,
 196               "the use of `pthread_attr_getstackaddr' is deprecated, use `pthread_attr_getstack'")
 197
 198
 199 int __pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize)
 200 {
 201 #ifdef FLOATING_STACKS
 202   /* We have to check against the maximum allowed stack size.  This is no
 203      problem if the manager is already started and we determined it.  If
 204      this hasn't happened, we have to find the limit outself.  */
 205   if (__pthread_max_stacksize == 0)
 206     __pthread_init_max_stacksize ();
 207
 208   if (stacksize > __pthread_max_stacksize)
 209     return EINVAL;
 210 #else
 211   /* We have a fixed size limit.  */
 212   if (stacksize > STACK_SIZE)
 213     return EINVAL;
 214 #endif
 215
 216   /* We don't accept value smaller than PTHREAD_STACK_MIN.  */
 217   if (stacksize < PTHREAD_STACK_MIN)
 218     return EINVAL;
 219
 220   attr->__stacksize = stacksize;
 221   return 0;
 222 }
 223
 224 #if PTHREAD_STACK_MIN == 16384
 225 weak_alias (__pthread_attr_setstacksize, pthread_attr_setstacksize)
 226 #else
 227 versioned_symbol (libpthread, __pthread_attr_setstacksize,
 228                   pthread_attr_setstacksize, GLIBC_2_3_3);
 229
 230 # if SHLIB_COMPAT(libpthread, GLIBC_2_1, GLIBC_2_3_3)
 231
 232 int __old_pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize)
 233 {
 234 #  ifdef FLOATING_STACKS
 235   /* We have to check against the maximum allowed stack size.  This is no
 236      problem if the manager is already started and we determined it.  If
 237      this hasn't happened, we have to find the limit outself.  */
 238   if (__pthread_max_stacksize == 0)
 239     __pthread_init_max_stacksize ();
 240
 241   if (stacksize > __pthread_max_stacksize)
 242     return EINVAL;
 243 #  else
 244   /* We have a fixed size limit.  */
 245   if (stacksize > STACK_SIZE)
 246     return EINVAL;
 247 #  endif
 248
 249   /* We don't accept value smaller than old PTHREAD_STACK_MIN.  */
 250   if (stacksize < 16384)
 251     return EINVAL;
 252
 253   attr->__stacksize = stacksize;
 254   return 0;
 255 }
 256 compat_symbol (libpthread, __old_pthread_attr_setstacksize,
 257                pthread_attr_setstacksize, GLIBC_2_1);
 258 # endif
 259 #endif
 260
 261
 262 int __pthread_attr_getstacksize(const pthread_attr_t *attr, size_t *stacksize)
 263 {
 264   *stacksize = attr->__stacksize;
 265   return 0;
 266 }
 267 weak_alias (__pthread_attr_getstacksize, pthread_attr_getstacksize)
 268
 269 int __pthread_attr_setstack (pthread_attr_t *attr, void *stackaddr,
 270                              size_t stacksize)
 271 {
 272   int err;
 273
 274   if ((((uintptr_t) stackaddr)
 275        & (__alignof__ (struct _pthread_descr_struct) - 1)) != 0)
 276     err = EINVAL;
 277   else
 278     err = __pthread_attr_setstacksize (attr, stacksize);
 279   if (err == 0)
 280     {
 281 #ifndef _STACK_GROWS_UP
 282       attr->__stackaddr = (char *) stackaddr + stacksize;
 283 #else
 284       attr->__stackaddr = stackaddr;
 285 #endif
 286       attr->__stackaddr_set = 1;
 287     }
 288
 289   return err;
 290 }
 291
 292 #if PTHREAD_STACK_MIN == 16384
 293 weak_alias (__pthread_attr_setstack, pthread_attr_setstack)
 294 #else
 295 versioned_symbol (libpthread, __pthread_attr_setstack, pthread_attr_setstack,
 296                   GLIBC_2_3_3);
 297 # if SHLIB_COMPAT(libpthread, GLIBC_2_2, GLIBC_2_3_3)
 298 int __old_pthread_attr_setstack (pthread_attr_t *attr, void *stackaddr,
 299                                  size_t stacksize)
 300 {
 301   int err;
 302
 303   if ((((uintptr_t) stackaddr)
 304        & (__alignof__ (struct _pthread_descr_struct) - 1)) != 0)
 305     err = EINVAL;
 306   else
 307     err = __old_pthread_attr_setstacksize (attr, stacksize);
 308   if (err == 0)
 309     {
 310 #  ifndef _STACK_GROWS_UP
 311       attr->__stackaddr = (char *) stackaddr + stacksize;
 312 #  else
 313       attr->__stackaddr = stackaddr;
 314 #  endif
 315       attr->__stackaddr_set = 1;
 316     }
 317
 318   return err;
 319 }
 320
 321 compat_symbol (libpthread, __old_pthread_attr_setstack, pthread_attr_setstack,
 322                GLIBC_2_2);
 323
 324 # endif
 325 #endif
 326
 327 int __pthread_attr_getstack (const pthread_attr_t *attr, void **stackaddr,
 328                              size_t *stacksize)
 329 {
 330   /* XXX This function has a stupid definition.  The standard specifies
 331      no error value but what is if no stack address was set?  We simply
 332      return the value we have in the member.  */
 333 #ifndef _STACK_GROWS_UP
 334   *stackaddr = (char *) attr->__stackaddr - attr->__stacksize;
 335 #else
 336   *stackaddr = attr->__stackaddr;
 337 #endif
 338   *stacksize = attr->__stacksize;
 339   return 0;
 340 }
 341 weak_alias (__pthread_attr_getstack, pthread_attr_getstack)
 342
 343 int pthread_getattr_np (pthread_t thread, pthread_attr_t *attr)
 344 {
 345   pthread_handle handle = thread_handle (thread);
 346   pthread_descr descr;
 347
 348   if (handle == NULL)
 349     return ENOENT;
 350
 351   descr = handle->h_descr;
 352
 353   attr->__detachstate = (descr->p_detached
 354                          ? PTHREAD_CREATE_DETACHED
 355                          : PTHREAD_CREATE_JOINABLE);
 356
 357   attr->__schedpolicy = __sched_getscheduler (descr->p_pid);
 358   if (attr->__schedpolicy == -1)
 359     return errno;
 360
 361   if (__sched_getparam (descr->p_pid,
 362                         (struct sched_param *) &attr->__schedparam) != 0)
 363     return errno;
 364
 365   attr->__inheritsched = descr->p_inheritsched;
 366   attr->__scope = PTHREAD_SCOPE_SYSTEM;
 367 #ifdef _STACK_GROWS_DOWN
 368 # ifdef USE_TLS
 369   attr->__stacksize = descr->p_stackaddr - (char *)descr->p_guardaddr
 370                       - descr->p_guardsize;
 371 # else
 372   attr->__stacksize = (char *)(descr + 1) - (char *)descr->p_guardaddr
 373                       - descr->p_guardsize;
 374 # endif
 375 #else
 376 # ifdef USE_TLS
 377   attr->__stacksize = (char *)descr->p_guardaddr - descr->p_stackaddr;
 378 # else
 379   attr->__stacksize = (char *)descr->p_guardaddr - (char *)descr;
 380 # endif
 381 #endif
 382   attr->__guardsize = descr->p_guardsize;
 383   attr->__stackaddr_set = descr->p_userstack;
 384 #ifdef NEED_SEPARATE_REGISTER_STACK
 385   if (descr->p_userstack == 0)
 386     attr->__stacksize *= 2;
 387   /* XXX This is awkward.  The guard pages are in the middle of the
 388      two stacks.  We must count the guard size in the stack size since
 389      otherwise the range of the stack area cannot be computed.  */
 390   attr->__stacksize += attr->__guardsize;
 391 #endif
 392 #ifdef USE_TLS
 393   attr->__stackaddr = descr->p_stackaddr;
 394 #else
 395 # ifndef _STACK_GROWS_UP
 396   attr->__stackaddr = (char *)(descr + 1);
 397 # else
 398   attr->__stackaddr = (char *)descr;
 399 # endif
 400 #endif
 401
 402   return 0;
 403 }