Home | History | Annotate | Line # | Download | only in libpthread
pthread_attr.c revision 1.6 
      1 /*	$NetBSD: pthread_attr.c,v 1.6 2007/08/16 01:09:34 ad 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.6 2007/08/16 01:09:34 ad 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 /*ARGSUSED*/
    241 pthread_attr_setschedparam(pthread_attr_t *attr,
    242     const struct sched_param *param)
    243 {
    244 
    245 	if (param == NULL)
    246 		return EINVAL;
    247 
    248 	if (param->sched_priority != 0)
    249 		return EINVAL;
    250 
    251 	return 0;
    252 }
    253 
    254 
    255 int
    256 /*ARGSUSED*/
    257 pthread_attr_getschedparam(const pthread_attr_t *attr,
    258     struct sched_param *param)
    259 {
    260 
    261 	if (param == NULL)
    262 		return EINVAL;
    263 
    264 	param->sched_priority = 0;
    265 
    266 	return 0;
    267 }
    268 
    269 
    270 int
    271 /*ARGSUSED*/
    272 pthread_attr_setschedpolicy(pthread_attr_t *attr,
    273     int policy)
    274 {
    275 
    276 	if (policy != SCHED_OTHER)
    277 		return ENOTSUP;
    278 
    279 	return 0;
    280 }
    281 
    282 
    283 int
    284 /*ARGSUSED*/
    285 pthread_attr_getschedpolicy(const pthread_attr_t *attr,
    286     int *policy)
    287 {
    288 
    289 	*policy = SCHED_OTHER;
    290 
    291 	return 0;
    292 }
    293 
    294 
    295 int
    296 pthread_attr_getstack(const pthread_attr_t *attr, void **addr, size_t *size)
    297 {
    298 	struct pthread_attr_private *p;
    299 
    300 	if ((p = attr->pta_private) == NULL) {
    301 		*addr = NULL;
    302 		*size = pthread__stacksize;
    303 	} else {
    304 		*addr = p->ptap_stackaddr;
    305 		*size = p->ptap_stacksize;
    306 	}
    307 
    308 	return 0;
    309 }
    310 
    311 
    312 int
    313 pthread_attr_setstack(pthread_attr_t *attr, void *addr, size_t size)
    314 {
    315 	struct pthread_attr_private *p;
    316 
    317 	p = pthread__attr_init_private(attr);
    318 	if (p == NULL)
    319 		return ENOMEM;
    320 
    321 	p->ptap_stackaddr = addr;
    322 	p->ptap_stacksize = size;
    323 
    324 	return 0;
    325 }
    326 
    327 
    328 int
    329 pthread_attr_getstacksize(const pthread_attr_t *attr, size_t *size)
    330 {
    331 	struct pthread_attr_private *p;
    332 
    333 	if ((p = attr->pta_private) == NULL)
    334 		*size = pthread__stacksize;
    335 	else
    336 		*size = p->ptap_stacksize;
    337 
    338 	return 0;
    339 }
    340 
    341 
    342 int
    343 pthread_attr_setstacksize(pthread_attr_t *attr, size_t size)
    344 {
    345 	struct pthread_attr_private *p;
    346 
    347 	p = pthread__attr_init_private(attr);
    348 	if (p == NULL)
    349 		return ENOMEM;
    350 
    351 	p->ptap_stacksize = size;
    352 
    353 	return 0;
    354 }
    355 
    356 
    357 int
    358 pthread_attr_getstackaddr(const pthread_attr_t *attr, void **addr)
    359 {
    360 	struct pthread_attr_private *p;
    361 
    362 	if ((p = attr->pta_private) == NULL)
    363 		*addr = NULL;
    364 	else
    365 		*addr = p->ptap_stackaddr;
    366 
    367 	return 0;
    368 }
    369 
    370 
    371 int
    372 pthread_attr_setstackaddr(pthread_attr_t *attr, void *addr)
    373 {
    374 	struct pthread_attr_private *p;
    375 
    376 	p = pthread__attr_init_private(attr);
    377 	if (p == NULL)
    378 		return ENOMEM;
    379 
    380 	p->ptap_stackaddr = addr;
    381 
    382 	return 0;
    383 }
    384 
    385 
    386 int
    387 pthread_attr_getname_np(const pthread_attr_t *attr, char *name, size_t len,
    388     void **argp)
    389 {
    390 	struct pthread_attr_private *p;
    391 
    392 	if ((p = attr->pta_private) == NULL) {
    393 		name[0] = '\0';
    394 		if (argp != NULL)
    395 			*argp = NULL;
    396 	} else {
    397 		strlcpy(name, p->ptap_name, len);
    398 		if (argp != NULL)
    399 			*argp = p->ptap_namearg;
    400 	}
    401 
    402 	return 0;
    403 }
    404 
    405 
    406 int
    407 pthread_attr_setname_np(pthread_attr_t *attr, const char *name, void *arg)
    408 {
    409 	struct pthread_attr_private *p;
    410 	int namelen;
    411 
    412 	p = pthread__attr_init_private(attr);
    413 	if (p == NULL)
    414 		return ENOMEM;
    415 
    416 	namelen = snprintf(p->ptap_name, PTHREAD_MAX_NAMELEN_NP, name, arg);
    417 	if (namelen >= PTHREAD_MAX_NAMELEN_NP) {
    418 		p->ptap_name[0] = '\0';
    419 		return EINVAL;
    420 	}
    421 	p->ptap_namearg = arg;
    422 
    423 	return 0;
    424 }
    425 
    426 int
    427 pthread_attr_setcreatesuspend_np(pthread_attr_t *attr)
    428 {
    429 	attr->pta_flags |= PT_FLAG_SUSPENDED;
    430 	return 0;
    431 }
    432