Use shlib-compat macros.
[kopensolaris-gnu/glibc.git] / 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)