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