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