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 <unistd.h>
  18 #include <sys/param.h>
  19 #include "pthread.h"
  20 #include "internals.h"
  21
  22
  23 int __pthread_attr_init_2_1(pthread_attr_t *attr)
  24 {
  25   size_t ps = __getpagesize ();
  26
  27   attr->detachstate = PTHREAD_CREATE_JOINABLE;
  28   attr->schedpolicy = SCHED_OTHER;
  29   attr->schedparam.sched_priority = 0;
  30   attr->inheritsched = PTHREAD_EXPLICIT_SCHED;
  31   attr->scope = PTHREAD_SCOPE_SYSTEM;
  32   attr->guardsize = ps;
  33   attr->stackaddr = NULL;
  34   attr->stackaddr_set = 0;
  35   attr->stacksize = STACK_SIZE - ps;
  36   return 0;
  37 }
  38 #if defined HAVE_ELF && defined PIC && defined DO_VERSIONING
  39 default_symbol_version (__pthread_attr_init_2_1, pthread_attr_init, GLIBC_2.1);
  40
  41 int __pthread_attr_init_2_0(pthread_attr_t *attr)
  42 {
  43   attr->detachstate = PTHREAD_CREATE_JOINABLE;
  44   attr->schedpolicy = SCHED_OTHER;
  45   attr->schedparam.sched_priority = 0;
  46   attr->inheritsched = PTHREAD_EXPLICIT_SCHED;
  47   attr->scope = PTHREAD_SCOPE_SYSTEM;
  48   return 0;
  49 }
  50 symbol_version (__pthread_attr_init_2_0, pthread_attr_init, GLIBC_2.0);
  51 #else
  52 strong_alias (__pthread_attr_init_2_1, pthread_attr_init)
  53 #endif
  54
  55 int pthread_attr_destroy(pthread_attr_t *attr)
  56 {
  57   return 0;
  58 }
  59
  60 int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate)
  61 {
  62   if (detachstate < PTHREAD_CREATE_JOINABLE ||
  63       detachstate > PTHREAD_CREATE_DETACHED)
  64     return EINVAL;
  65   attr->detachstate = detachstate;
  66   return 0;
  67 }
  68
  69 int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate)
  70 {
  71   *detachstate = attr->detachstate;
  72   return 0;
  73 }
  74
  75 int pthread_attr_setschedparam(pthread_attr_t *attr,
  76                                const struct sched_param *param)
  77 {
  78   int max_prio = __sched_get_priority_max(attr->schedpolicy);
  79   int min_prio = __sched_get_priority_min(attr->schedpolicy);
  80
  81   if (param->sched_priority < min_prio || param->sched_priority > max_prio)
  82     return EINVAL;
  83   attr->schedparam = *param;
  84   return 0;
  85 }
  86
  87 int pthread_attr_getschedparam(const pthread_attr_t *attr,
  88                                struct sched_param *param)
  89 {
  90   *param = attr->schedparam;
  91   return 0;
  92 }
  93
  94 int pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy)
  95 {
  96   if (policy != SCHED_OTHER && policy != SCHED_FIFO && policy != SCHED_RR)
  97     return EINVAL;
  98   if (policy != SCHED_OTHER && geteuid() != 0)
  99     return ENOTSUP;
 100   attr->schedpolicy = policy;
 101   return 0;
 102 }
 103
 104 int pthread_attr_getschedpolicy(const pthread_attr_t *attr, int *policy)
 105 {
 106   *policy = attr->schedpolicy;
 107   return 0;
 108 }
 109
 110 int pthread_attr_setinheritsched(pthread_attr_t *attr, int inherit)
 111 {
 112   if (inherit != PTHREAD_INHERIT_SCHED && inherit != PTHREAD_EXPLICIT_SCHED)
 113     return EINVAL;
 114   attr->inheritsched = inherit;
 115   return 0;
 116 }
 117
 118 int pthread_attr_getinheritsched(const pthread_attr_t *attr, int *inherit)
 119 {
 120   *inherit = attr->inheritsched;
 121   return 0;
 122 }
 123
 124 int pthread_attr_setscope(pthread_attr_t *attr, int scope)
 125 {
 126   switch (scope) {
 127   case PTHREAD_SCOPE_SYSTEM:
 128     attr->scope = scope;
 129     return 0;
 130   case PTHREAD_SCOPE_PROCESS:
 131     return ENOTSUP;
 132   default:
 133     return EINVAL;
 134   }
 135 }
 136
 137 int pthread_attr_getscope(const pthread_attr_t *attr, int *scope)
 138 {
 139   *scope = attr->scope;
 140   return 0;
 141 }
 142
 143 int __pthread_attr_setguardsize(pthread_attr_t *attr, size_t guardsize)
 144 {
 145   size_t ps = __getpagesize ();
 146
 147   /* First round up the guard size.  */
 148   guardsize = roundup (guardsize, ps);
 149
 150   /* The current implementation of LinuxThreads allocates 2MB stack space
 151      for each thread.  So the maximum guardsize is 2MB - pagesize.  */
 152   if (guardsize >= STACK_SIZE - ps)
 153     return EINVAL;
 154
 155   attr->guardsize = guardsize;
 156
 157   return 0;
 158 }
 159 weak_alias (__pthread_attr_setguardsize, pthread_attr_setguardsize)
 160
 161 int __pthread_attr_getguardsize(const pthread_attr_t *attr, size_t *guardsize)
 162 {
 163   *guardsize = attr->guardsize;
 164   return 0;
 165 }
 166 weak_alias (__pthread_attr_getguardsize, pthread_attr_getguardsize)
 167
 168 int __pthread_attr_setstackaddr(pthread_attr_t *attr, void *stackaddr)
 169 {
 170   attr->stackaddr = stackaddr;
 171   attr->stackaddr_set = 1;
 172   return 0;
 173 }
 174 weak_alias (__pthread_attr_setstackaddr, pthread_attr_setstackaddr)
 175
 176 int __pthread_attr_getstackaddr(const pthread_attr_t *attr, void **stackaddr)
 177 {
 178   /* XXX This function has a stupid definition.  The standard specifies
 179      no error value but what is if no stack address was set?  We simply
 180      return the value we have in the member.  */
 181   *stackaddr = attr->stackaddr;
 182   return 0;
 183 }
 184 weak_alias (__pthread_attr_getstackaddr, pthread_attr_etstackaddr)
 185
 186 int __pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize)
 187 {
 188   size_t ps = __getpagesize ();
 189
 190   /* We don't accept value smaller than PTHREAD_STACK_MIN or bigger than
 191      2MB - pagesize.  */
 192   if (stacksize < PTHREAD_STACK_MIN || stacksize > STACK_SIZE - ps)
 193     return EINVAL;
 194
 195   attr->stacksize = stacksize;
 196   return 0;
 197 }
 198 weak_alias (__pthread_attr_setstacksize, pthread_attr_setstacksize)
 199
 200 int __pthread_attr_getstacksize(const pthread_attr_t *attr, size_t *stacksize)
 201 {
 202   *stacksize = attr->stacksize;
 203   return 0;
 204 }
 205 weak_alias (__pthread_attr_getstacksize, pthread_attr_getstacksize)