1 /* $NetBSD: pthread_attr.c,v 1.7 2008/01/08 20:56:08 christos 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.7 2008/01/08 20:56:08 christos 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 static struct pthread_attr_private *pthread__attr_init_private( 52 pthread_attr_t *); 53 54 static struct pthread_attr_private * 55 pthread__attr_init_private(pthread_attr_t *attr) 56 { 57 struct pthread_attr_private *p; 58 59 if ((p = attr->pta_private) != NULL) 60 return p; 61 62 p = malloc(sizeof(*p)); 63 if (p != NULL) { 64 memset(p, 0, sizeof(*p)); 65 attr->pta_private = p; 66 } 67 return p; 68 } 69 70 71 int 72 pthread_attr_init(pthread_attr_t *attr) 73 { 74 75 attr->pta_magic = PT_ATTR_MAGIC; 76 attr->pta_flags = 0; 77 attr->pta_private = NULL; 78 79 return 0; 80 } 81 82 83 int 84 pthread_attr_destroy(pthread_attr_t *attr) 85 { 86 struct pthread_attr_private *p; 87 88 if ((p = attr->pta_private) != NULL) 89 free(p); 90 91 return 0; 92 } 93 94 95 int 96 pthread_attr_get_np(pthread_t thread, pthread_attr_t *attr) 97 { 98 struct pthread_attr_private *p; 99 100 p = pthread__attr_init_private(attr); 101 if (p == NULL) 102 return ENOMEM; 103 104 attr->pta_flags = thread->pt_flags & 105 (PT_FLAG_DETACHED | PT_FLAG_SCOPE_SYSTEM | PT_FLAG_EXPLICIT_SCHED); 106 107 p->ptap_namearg = thread->pt_name; 108 p->ptap_stackaddr = thread->pt_stack.ss_sp; 109 p->ptap_stacksize = thread->pt_stack.ss_size; 110 p->ptap_guardsize = (size_t)sysconf(_SC_PAGESIZE); 111 112 return 0; 113 } 114 115 116 int 117 pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate) 118 { 119 120 if (attr->pta_flags & PT_FLAG_DETACHED) 121 *detachstate = PTHREAD_CREATE_DETACHED; 122 else 123 *detachstate = PTHREAD_CREATE_JOINABLE; 124 125 return 0; 126 } 127 128 129 int 130 pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate) 131 { 132 133 switch (detachstate) { 134 case PTHREAD_CREATE_JOINABLE: 135 attr->pta_flags &= ~PT_FLAG_DETACHED; 136 break; 137 case PTHREAD_CREATE_DETACHED: 138 attr->pta_flags |= PT_FLAG_DETACHED; 139 break; 140 default: 141 return EINVAL; 142 } 143 144 return 0; 145 } 146 147 148 int 149 pthread_attr_getguardsize(const pthread_attr_t *attr, size_t *guard) 150 { 151 struct pthread_attr_private *p; 152 153 if ((p = attr->pta_private) == NULL) 154 *guard = (size_t)sysconf(_SC_PAGESIZE); 155 else 156 *guard = p->ptap_guardsize; 157 158 return 0; 159 } 160 161 162 int 163 pthread_attr_setguardsize(pthread_attr_t *attr, size_t guard) 164 { 165 struct pthread_attr_private *p; 166 167 p = pthread__attr_init_private(attr); 168 if (p == NULL) 169 return ENOMEM; 170 171 p->ptap_guardsize = guard; 172 173 return 0; 174 } 175 176 177 int 178 pthread_attr_getinheritsched(const pthread_attr_t *attr, int *inherit) 179 { 180 181 if (attr->pta_flags & PT_FLAG_EXPLICIT_SCHED) 182 *inherit = PTHREAD_EXPLICIT_SCHED; 183 else 184 *inherit = PTHREAD_INHERIT_SCHED; 185 186 return 0; 187 } 188 189 190 int 191 pthread_attr_setinheritsched(pthread_attr_t *attr, int inherit) 192 { 193 194 switch (inherit) { 195 case PTHREAD_INHERIT_SCHED: 196 attr->pta_flags &= ~PT_FLAG_EXPLICIT_SCHED; 197 break; 198 case PTHREAD_EXPLICIT_SCHED: 199 attr->pta_flags |= PT_FLAG_EXPLICIT_SCHED; 200 break; 201 default: 202 return EINVAL; 203 } 204 205 return 0; 206 } 207 208 209 int 210 pthread_attr_getscope(const pthread_attr_t *attr, int *scope) 211 { 212 213 if (attr->pta_flags & PT_FLAG_SCOPE_SYSTEM) 214 *scope = PTHREAD_SCOPE_SYSTEM; 215 else 216 *scope = PTHREAD_SCOPE_PROCESS; 217 218 return 0; 219 } 220 221 222 int 223 pthread_attr_setscope(pthread_attr_t *attr, int scope) 224 { 225 226 switch (scope) { 227 case PTHREAD_SCOPE_PROCESS: 228 attr->pta_flags &= ~PT_FLAG_SCOPE_SYSTEM; 229 break; 230 case PTHREAD_SCOPE_SYSTEM: 231 attr->pta_flags |= PT_FLAG_SCOPE_SYSTEM; 232 break; 233 default: 234 return EINVAL; 235 } 236 237 return 0; 238 } 239 240 241 int 242 /*ARGSUSED*/ 243 pthread_attr_setschedparam(pthread_attr_t *attr, 244 const struct sched_param *param) 245 { 246 247 if (param == NULL) 248 return EINVAL; 249 250 if (param->sched_priority != 0) 251 return EINVAL; 252 253 return 0; 254 } 255 256 257 int 258 /*ARGSUSED*/ 259 pthread_attr_getschedparam(const pthread_attr_t *attr, 260 struct sched_param *param) 261 { 262 263 if (param == NULL) 264 return EINVAL; 265 266 param->sched_priority = 0; 267 268 return 0; 269 } 270 271 272 int 273 /*ARGSUSED*/ 274 pthread_attr_setschedpolicy(pthread_attr_t *attr, 275 int policy) 276 { 277 278 if (policy != SCHED_OTHER) 279 return ENOTSUP; 280 281 return 0; 282 } 283 284 285 int 286 /*ARGSUSED*/ 287 pthread_attr_getschedpolicy(const pthread_attr_t *attr, 288 int *policy) 289 { 290 291 *policy = SCHED_OTHER; 292 293 return 0; 294 } 295 296 297 int 298 pthread_attr_getstack(const pthread_attr_t *attr, void **addr, size_t *size) 299 { 300 struct pthread_attr_private *p; 301 302 if ((p = attr->pta_private) == NULL) { 303 *addr = NULL; 304 *size = pthread__stacksize; 305 } else { 306 *addr = p->ptap_stackaddr; 307 *size = p->ptap_stacksize; 308 } 309 310 return 0; 311 } 312 313 314 int 315 pthread_attr_setstack(pthread_attr_t *attr, void *addr, size_t size) 316 { 317 struct pthread_attr_private *p; 318 319 p = pthread__attr_init_private(attr); 320 if (p == NULL) 321 return ENOMEM; 322 323 p->ptap_stackaddr = addr; 324 p->ptap_stacksize = size; 325 326 return 0; 327 } 328 329 330 int 331 pthread_attr_getstacksize(const pthread_attr_t *attr, size_t *size) 332 { 333 struct pthread_attr_private *p; 334 335 if ((p = attr->pta_private) == NULL) 336 *size = pthread__stacksize; 337 else 338 *size = p->ptap_stacksize; 339 340 return 0; 341 } 342 343 344 int 345 pthread_attr_setstacksize(pthread_attr_t *attr, size_t size) 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_stacksize = size; 354 355 return 0; 356 } 357 358 359 int 360 pthread_attr_getstackaddr(const pthread_attr_t *attr, void **addr) 361 { 362 struct pthread_attr_private *p; 363 364 if ((p = attr->pta_private) == NULL) 365 *addr = NULL; 366 else 367 *addr = p->ptap_stackaddr; 368 369 return 0; 370 } 371 372 373 int 374 pthread_attr_setstackaddr(pthread_attr_t *attr, void *addr) 375 { 376 struct pthread_attr_private *p; 377 378 p = pthread__attr_init_private(attr); 379 if (p == NULL) 380 return ENOMEM; 381 382 p->ptap_stackaddr = addr; 383 384 return 0; 385 } 386 387 388 int 389 pthread_attr_getname_np(const pthread_attr_t *attr, char *name, size_t len, 390 void **argp) 391 { 392 struct pthread_attr_private *p; 393 394 if ((p = attr->pta_private) == NULL) { 395 name[0] = '\0'; 396 if (argp != NULL) 397 *argp = NULL; 398 } else { 399 strlcpy(name, p->ptap_name, len); 400 if (argp != NULL) 401 *argp = p->ptap_namearg; 402 } 403 404 return 0; 405 } 406 407 408 int 409 pthread_attr_setname_np(pthread_attr_t *attr, const char *name, void *arg) 410 { 411 struct pthread_attr_private *p; 412 int namelen; 413 414 p = pthread__attr_init_private(attr); 415 if (p == NULL) 416 return ENOMEM; 417 418 namelen = snprintf(p->ptap_name, PTHREAD_MAX_NAMELEN_NP, name, arg); 419 if (namelen >= PTHREAD_MAX_NAMELEN_NP) { 420 p->ptap_name[0] = '\0'; 421 return EINVAL; 422 } 423 p->ptap_namearg = arg; 424 425 return 0; 426 } 427 428 int 429 pthread_attr_setcreatesuspend_np(pthread_attr_t *attr) 430 { 431 attr->pta_flags |= PT_FLAG_SUSPENDED; 432 return 0; 433 } 434