xref: /netbsd-src/lib/libpthread/pthread_attr.c (revision da5f4674a3fc214be3572d358b66af40ab9401e7)
1 /*	$NetBSD: pthread_attr.c,v 1.1 2003/07/18 22:33:46 nathanw Exp $	*/
2 
3 /*-
4  * Copyright (c) 2001,2002,2003 The NetBSD Foundation, Inc.
5  * All rights reserved.
6  *
7  * This code is derived from software contributed to The NetBSD Foundation
8  * by Nathan J. Williams.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  * 3. All advertising materials mentioning features or use of this software
19  *    must display the following acknowledgement:
20  *        This product includes software developed by the NetBSD
21  *        Foundation, Inc. and its contributors.
22  * 4. Neither the name of The NetBSD Foundation nor the names of its
23  *    contributors may be used to endorse or promote products derived
24  *    from this software without specific prior written permission.
25  *
26  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
27  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
28  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
29  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
30  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
31  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
32  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
33  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
34  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
35  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
36  * POSSIBILITY OF SUCH DAMAGE.
37  */
38 
39 #include <sys/cdefs.h>
40 __RCSID("$NetBSD: pthread_attr.c,v 1.1 2003/07/18 22:33:46 nathanw Exp $");
41 
42 #include <errno.h>
43 #include <stdio.h>
44 #include <stdlib.h>
45 #include <string.h>
46 #include <unistd.h>
47 
48 #include "pthread.h"
49 #include "pthread_int.h"
50 
51 
52 static struct pthread_attr_private *
53 pthread__attr_init_private(pthread_attr_t *attr)
54 {
55 	struct pthread_attr_private *p;
56 
57 	if ((p = attr->pta_private) != NULL)
58 		return p;
59 
60 	p = malloc(sizeof(*p));
61 	if (p != NULL) {
62 		memset(p, 0, sizeof(*p));
63 		attr->pta_private = p;
64 	}
65 	return p;
66 }
67 
68 
69 int
70 pthread_attr_init(pthread_attr_t *attr)
71 {
72 
73 	attr->pta_magic = PT_ATTR_MAGIC;
74 	attr->pta_flags = 0;
75 	attr->pta_private = NULL;
76 
77 	return 0;
78 }
79 
80 
81 int
82 pthread_attr_destroy(pthread_attr_t *attr)
83 {
84 	struct pthread_attr_private *p;
85 
86 	if ((p = attr->pta_private) != NULL)
87 		free(p);
88 
89 	return 0;
90 }
91 
92 
93 int
94 pthread_attr_get_np(pthread_t thread, pthread_attr_t *attr)
95 {
96 	struct pthread_attr_private *p;
97 
98 	p = pthread__attr_init_private(attr);
99 	if (p == NULL)
100 		return ENOMEM;
101 
102 	attr->pta_flags = thread->pt_flags &
103 	    (PT_FLAG_DETACHED | PT_FLAG_SCOPE_SYSTEM | PT_FLAG_EXPLICIT_SCHED);
104 
105 	p->ptap_namearg = thread->pt_name;
106 	p->ptap_stackaddr = thread->pt_stack.ss_sp;
107 	p->ptap_stacksize = thread->pt_stack.ss_size;
108 	p->ptap_guardsize = (size_t)sysconf(_SC_PAGESIZE);
109 
110 	return 0;
111 }
112 
113 
114 int
115 pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate)
116 {
117 
118 	if (attr->pta_flags & PT_FLAG_DETACHED)
119 		*detachstate = PTHREAD_CREATE_DETACHED;
120 	else
121 		*detachstate = PTHREAD_CREATE_JOINABLE;
122 
123 	return 0;
124 }
125 
126 
127 int
128 pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate)
129 {
130 
131 	switch (detachstate) {
132 	case PTHREAD_CREATE_JOINABLE:
133 		attr->pta_flags &= ~PT_FLAG_DETACHED;
134 		break;
135 	case PTHREAD_CREATE_DETACHED:
136 		attr->pta_flags |= PT_FLAG_DETACHED;
137 		break;
138 	default:
139 		return EINVAL;
140 	}
141 
142 	return 0;
143 }
144 
145 
146 int
147 pthread_attr_getguardsize(const pthread_attr_t *attr, size_t *guard)
148 {
149 	struct pthread_attr_private *p;
150 
151 	if ((p = attr->pta_private) == NULL)
152 		*guard = (size_t)sysconf(_SC_PAGESIZE);
153 	else
154 		*guard = p->ptap_guardsize;
155 
156 	return 0;
157 }
158 
159 
160 int
161 pthread_attr_setguardsize(pthread_attr_t *attr, size_t guard)
162 {
163 	struct pthread_attr_private *p;
164 
165 	p = pthread__attr_init_private(attr);
166 	if (p == NULL)
167 		return ENOMEM;
168 
169 	p->ptap_guardsize = guard;
170 
171 	return 0;
172 }
173 
174 
175 int
176 pthread_attr_getinheritsched(const pthread_attr_t *attr, int *inherit)
177 {
178 
179 	if (attr->pta_flags & PT_FLAG_EXPLICIT_SCHED)
180 		*inherit = PTHREAD_EXPLICIT_SCHED;
181 	else
182 		*inherit = PTHREAD_INHERIT_SCHED;
183 
184 	return 0;
185 }
186 
187 
188 int
189 pthread_attr_setinheritsched(pthread_attr_t *attr, int inherit)
190 {
191 
192 	switch (inherit) {
193 	case PTHREAD_INHERIT_SCHED:
194 		attr->pta_flags &= ~PT_FLAG_EXPLICIT_SCHED;
195 		break;
196 	case PTHREAD_EXPLICIT_SCHED:
197 		attr->pta_flags |= PT_FLAG_EXPLICIT_SCHED;
198 		break;
199 	default:
200 		return EINVAL;
201 	}
202 
203 	return 0;
204 }
205 
206 
207 int
208 pthread_attr_getscope(const pthread_attr_t *attr, int *scope)
209 {
210 
211 	if (attr->pta_flags & PT_FLAG_SCOPE_SYSTEM)
212 		*scope = PTHREAD_SCOPE_SYSTEM;
213 	else
214 		*scope = PTHREAD_SCOPE_PROCESS;
215 
216 	return 0;
217 }
218 
219 
220 int
221 pthread_attr_setscope(pthread_attr_t *attr, int scope)
222 {
223 
224 	switch (scope) {
225 	case PTHREAD_SCOPE_PROCESS:
226 		attr->pta_flags &= ~PT_FLAG_SCOPE_SYSTEM;
227 		break;
228 	case PTHREAD_SCOPE_SYSTEM:
229 		attr->pta_flags |= PT_FLAG_SCOPE_SYSTEM;
230 		break;
231 	default:
232 		return EINVAL;
233 	}
234 
235 	return 0;
236 }
237 
238 
239 int
240 pthread_attr_setschedparam(pthread_attr_t *attr,
241     const struct sched_param *param)
242 {
243 
244 	if (param == NULL)
245 		return EINVAL;
246 
247 	if (param->sched_priority != 0)
248 		return EINVAL;
249 
250 	return 0;
251 }
252 
253 
254 int
255 pthread_attr_getschedparam(const pthread_attr_t *attr,
256     struct sched_param *param)
257 {
258 
259 	if (param == NULL)
260 		return EINVAL;
261 
262 	param->sched_priority = 0;
263 
264 	return 0;
265 }
266 
267 
268 int
269 pthread_attr_getstack(const pthread_attr_t *attr, void **addr, size_t *size)
270 {
271 	struct pthread_attr_private *p;
272 
273 	if ((p = attr->pta_private) == NULL) {
274 		*addr = NULL;
275 		*size = PT_STACKSIZE;
276 	} else {
277 		*addr = p->ptap_stackaddr;
278 		*size = p->ptap_stacksize;
279 	}
280 
281 	return 0;
282 }
283 
284 
285 int
286 pthread_attr_setstack(pthread_attr_t *attr, void *addr, size_t size)
287 {
288 	struct pthread_attr_private *p;
289 
290 	p = pthread__attr_init_private(attr);
291 	if (p == NULL)
292 		return ENOMEM;
293 
294 	p->ptap_stackaddr = addr;
295 	p->ptap_stacksize = size;
296 
297 	return 0;
298 }
299 
300 
301 int
302 pthread_attr_getstacksize(const pthread_attr_t *attr, size_t *size)
303 {
304 	struct pthread_attr_private *p;
305 
306 	if ((p = attr->pta_private) == NULL)
307 		*size = PT_STACKSIZE;
308 	else
309 		*size = p->ptap_stacksize;
310 
311 	return 0;
312 }
313 
314 
315 int
316 pthread_attr_setstacksize(pthread_attr_t *attr, size_t size)
317 {
318 	struct pthread_attr_private *p;
319 
320 	p = pthread__attr_init_private(attr);
321 	if (p == NULL)
322 		return ENOMEM;
323 
324 	p->ptap_stacksize = size;
325 
326 	return 0;
327 }
328 
329 
330 int
331 pthread_attr_getstackaddr(const pthread_attr_t *attr, void **addr)
332 {
333 	struct pthread_attr_private *p;
334 
335 	if ((p = attr->pta_private) == NULL)
336 		*addr = NULL;
337 	else
338 		*addr = p->ptap_stackaddr;
339 
340 	return 0;
341 }
342 
343 
344 int
345 pthread_attr_setstackaddr(pthread_attr_t *attr, void *addr)
346 {
347 	struct pthread_attr_private *p;
348 
349 	p = pthread__attr_init_private(attr);
350 	if (p == NULL)
351 		return ENOMEM;
352 
353 	p->ptap_stackaddr = addr;
354 
355 	return 0;
356 }
357 
358 
359 int
360 pthread_attr_getname_np(const pthread_attr_t *attr, char *name, size_t len,
361     void **argp)
362 {
363 	struct pthread_attr_private *p;
364 
365 	if ((p = attr->pta_private) == NULL) {
366 		name[0] = '\0';
367 		if (argp != NULL)
368 			*argp = NULL;
369 	} else {
370 		strlcpy(name, p->ptap_name, len);
371 		if (argp != NULL)
372 			*argp = p->ptap_namearg;
373 	}
374 
375 	return 0;
376 }
377 
378 
379 int
380 pthread_attr_setname_np(pthread_attr_t *attr, const char *name, void *arg)
381 {
382 	struct pthread_attr_private *p;
383 	int namelen;
384 
385 	p = pthread__attr_init_private(attr);
386 	if (p == NULL)
387 		return ENOMEM;
388 
389 	namelen = snprintf(p->ptap_name, PTHREAD_MAX_NAMELEN_NP, name, arg);
390 	if (namelen >= PTHREAD_MAX_NAMELEN_NP) {
391 		p->ptap_name[0] = '\0';
392 		return EINVAL;
393 	}
394 	p->ptap_namearg = arg;
395 
396 	return 0;
397 }
398