1 /* $NetBSD: pthread_attr.c,v 1.3 2003/11/09 18:56:48 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.3 2003/11/09 18:56:48 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 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 pthread_attr_getstack(const pthread_attr_t *attr, void **addr, size_t *size) 272 { 273 struct pthread_attr_private *p; 274 275 if ((p = attr->pta_private) == NULL) { 276 *addr = NULL; 277 *size = PT_STACKSIZE; 278 } else { 279 *addr = p->ptap_stackaddr; 280 *size = p->ptap_stacksize; 281 } 282 283 return 0; 284 } 285 286 287 int 288 pthread_attr_setstack(pthread_attr_t *attr, void *addr, size_t size) 289 { 290 struct pthread_attr_private *p; 291 292 p = pthread__attr_init_private(attr); 293 if (p == NULL) 294 return ENOMEM; 295 296 p->ptap_stackaddr = addr; 297 p->ptap_stacksize = size; 298 299 return 0; 300 } 301 302 303 int 304 pthread_attr_getstacksize(const pthread_attr_t *attr, size_t *size) 305 { 306 struct pthread_attr_private *p; 307 308 if ((p = attr->pta_private) == NULL) 309 *size = PT_STACKSIZE; 310 else 311 *size = p->ptap_stacksize; 312 313 return 0; 314 } 315 316 317 int 318 pthread_attr_setstacksize(pthread_attr_t *attr, size_t size) 319 { 320 struct pthread_attr_private *p; 321 322 p = pthread__attr_init_private(attr); 323 if (p == NULL) 324 return ENOMEM; 325 326 p->ptap_stacksize = size; 327 328 return 0; 329 } 330 331 332 int 333 pthread_attr_getstackaddr(const pthread_attr_t *attr, void **addr) 334 { 335 struct pthread_attr_private *p; 336 337 if ((p = attr->pta_private) == NULL) 338 *addr = NULL; 339 else 340 *addr = p->ptap_stackaddr; 341 342 return 0; 343 } 344 345 346 int 347 pthread_attr_setstackaddr(pthread_attr_t *attr, void *addr) 348 { 349 struct pthread_attr_private *p; 350 351 p = pthread__attr_init_private(attr); 352 if (p == NULL) 353 return ENOMEM; 354 355 p->ptap_stackaddr = addr; 356 357 return 0; 358 } 359 360 361 int 362 pthread_attr_getname_np(const pthread_attr_t *attr, char *name, size_t len, 363 void **argp) 364 { 365 struct pthread_attr_private *p; 366 367 if ((p = attr->pta_private) == NULL) { 368 name[0] = '\0'; 369 if (argp != NULL) 370 *argp = NULL; 371 } else { 372 strlcpy(name, p->ptap_name, len); 373 if (argp != NULL) 374 *argp = p->ptap_namearg; 375 } 376 377 return 0; 378 } 379 380 381 int 382 pthread_attr_setname_np(pthread_attr_t *attr, const char *name, void *arg) 383 { 384 struct pthread_attr_private *p; 385 int namelen; 386 387 p = pthread__attr_init_private(attr); 388 if (p == NULL) 389 return ENOMEM; 390 391 namelen = snprintf(p->ptap_name, PTHREAD_MAX_NAMELEN_NP, name, arg); 392 if (namelen >= PTHREAD_MAX_NAMELEN_NP) { 393 p->ptap_name[0] = '\0'; 394 return EINVAL; 395 } 396 p->ptap_namearg = arg; 397 398 return 0; 399 } 400 401 int 402 pthread_attr_setcreatesuspend_np(pthread_attr_t *attr) 403 { 404 attr->pta_flags |= PT_FLAG_SUSPENDED; 405 return 0; 406 } 407