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