pthread_attr.cpp revision f0870c3bfeba99482392fafe6d5f49615393c2b1 
1/*
2 * Copyright (C) 2008 The Android Open Source Project
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *  * Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 *  * Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in
12 *    the documentation and/or other materials provided with the
13 *    distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
18 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
19 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
22 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
23 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
25 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29#include <pthread.h>
30
31#include "pthread_internal.h"
32
33int pthread_attr_init(pthread_attr_t* attr) {
34  attr->flags = 0;
35  attr->stack_base = NULL;
36  attr->stack_size = PTHREAD_STACK_SIZE_DEFAULT;
37  attr->guard_size = PAGE_SIZE;
38  attr->sched_policy = SCHED_NORMAL;
39  attr->sched_priority = 0;
40  return 0;
41}
42
43int pthread_attr_destroy(pthread_attr_t* attr) {
44  memset(attr, 0x42, sizeof(pthread_attr_t));
45  return 0;
46}
47
48int pthread_attr_setdetachstate(pthread_attr_t* attr, int state) {
49  if (state == PTHREAD_CREATE_DETACHED) {
50    attr->flags |= PTHREAD_ATTR_FLAG_DETACHED;
51  } else if (state == PTHREAD_CREATE_JOINABLE) {
52    attr->flags &= ~PTHREAD_ATTR_FLAG_DETACHED;
53  } else {
54    return EINVAL;
55  }
56  return 0;
57}
58
59int pthread_attr_getdetachstate(const pthread_attr_t* attr, int* state) {
60  *state = (attr->flags & PTHREAD_ATTR_FLAG_DETACHED) ? PTHREAD_CREATE_DETACHED : PTHREAD_CREATE_JOINABLE;
61  return 0;
62}
63
64int pthread_attr_setschedpolicy(pthread_attr_t* attr, int policy) {
65  attr->sched_policy = policy;
66  return 0;
67}
68
69int pthread_attr_getschedpolicy(const pthread_attr_t* attr, int* policy) {
70  *policy = attr->sched_policy;
71  return 0;
72}
73
74int pthread_attr_setschedparam(pthread_attr_t* attr, const sched_param* param) {
75  attr->sched_priority = param->sched_priority;
76  return 0;
77}
78
79int pthread_attr_getschedparam(const pthread_attr_t* attr, sched_param* param) {
80  param->sched_priority = attr->sched_priority;
81  return 0;
82}
83
84int pthread_attr_setstacksize(pthread_attr_t* attr, size_t stack_size) {
85  if (stack_size < PTHREAD_STACK_MIN) {
86    return EINVAL;
87  }
88  attr->stack_size = stack_size;
89  return 0;
90}
91
92int pthread_attr_getstacksize(const pthread_attr_t* attr, size_t* stack_size) {
93  *stack_size = attr->stack_size;
94  return 0;
95}
96
97#if !defined(__LP64__)
98// TODO: this exists only for backward binary compatibility on 32 bit platforms.
99extern "C" int pthread_attr_setstackaddr(pthread_attr_t*, void*) {
100  // This was removed from POSIX.1-2008, and is not implemented on bionic.
101  // Needed for ABI compatibility with the NDK.
102  return ENOSYS;
103}
104
105extern "C" int pthread_attr_getstackaddr(const pthread_attr_t* attr, void** stack_addr) {
106  // This was removed from POSIX.1-2008.
107  // Needed for ABI compatibility with the NDK.
108  *stack_addr = (char*)attr->stack_base + attr->stack_size;
109  return 0;
110}
111#endif // !defined(__LP64__)
112
113int pthread_attr_setstack(pthread_attr_t* attr, void* stack_base, size_t stack_size) {
114  if ((stack_size & (PAGE_SIZE - 1) || stack_size < PTHREAD_STACK_MIN)) {
115    return EINVAL;
116  }
117  if (reinterpret_cast<uintptr_t>(stack_base) & (PAGE_SIZE - 1)) {
118    return EINVAL;
119  }
120  attr->stack_base = stack_base;
121  attr->stack_size = stack_size;
122  return 0;
123}
124
125int pthread_attr_getstack(const pthread_attr_t* attr, void** stack_base, size_t* stack_size) {
126  *stack_base = attr->stack_base;
127  *stack_size = attr->stack_size;
128  return 0;
129}
130
131int pthread_attr_setguardsize(pthread_attr_t* attr, size_t guard_size) {
132  attr->guard_size = guard_size;
133  return 0;
134}
135
136int pthread_attr_getguardsize(const pthread_attr_t* attr, size_t* guard_size) {
137  *guard_size = attr->guard_size;
138  return 0;
139}
140
141int pthread_getattr_np(pthread_t thid, pthread_attr_t* attr) {
142  pthread_internal_t* thread = (pthread_internal_t*) thid;
143  *attr = thread->attr;
144  return 0;
145}
146
147int pthread_attr_setscope(pthread_attr_t*, int scope) {
148  if (scope == PTHREAD_SCOPE_SYSTEM) {
149    return 0;
150  }
151  if (scope == PTHREAD_SCOPE_PROCESS) {
152    return ENOTSUP;
153  }
154  return EINVAL;
155}
156
157int pthread_attr_getscope(const pthread_attr_t*, int* scope) {
158  *scope = PTHREAD_SCOPE_SYSTEM;
159  return 0;
160}
161