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 <inttypes.h>
32#include <stdio.h>
33#include <sys/resource.h>
34#include <unistd.h>
35
36#include "private/bionic_string_utils.h"
37#include "private/ErrnoRestorer.h"
38#include "private/libc_logging.h"
39#include "pthread_internal.h"
40
41int pthread_attr_init(pthread_attr_t* attr) {
42  attr->flags = 0;
43  attr->stack_base = NULL;
44  attr->stack_size = PTHREAD_STACK_SIZE_DEFAULT;
45  attr->guard_size = PAGE_SIZE;
46  attr->sched_policy = SCHED_NORMAL;
47  attr->sched_priority = 0;
48  return 0;
49}
50
51int pthread_attr_destroy(pthread_attr_t* attr) {
52  memset(attr, 0x42, sizeof(pthread_attr_t));
53  return 0;
54}
55
56int pthread_attr_setdetachstate(pthread_attr_t* attr, int state) {
57  if (state == PTHREAD_CREATE_DETACHED) {
58    attr->flags |= PTHREAD_ATTR_FLAG_DETACHED;
59  } else if (state == PTHREAD_CREATE_JOINABLE) {
60    attr->flags &= ~PTHREAD_ATTR_FLAG_DETACHED;
61  } else {
62    return EINVAL;
63  }
64  return 0;
65}
66
67int pthread_attr_getdetachstate(const pthread_attr_t* attr, int* state) {
68  *state = (attr->flags & PTHREAD_ATTR_FLAG_DETACHED) ? PTHREAD_CREATE_DETACHED : PTHREAD_CREATE_JOINABLE;
69  return 0;
70}
71
72int pthread_attr_setschedpolicy(pthread_attr_t* attr, int policy) {
73  attr->sched_policy = policy;
74  return 0;
75}
76
77int pthread_attr_getschedpolicy(const pthread_attr_t* attr, int* policy) {
78  *policy = attr->sched_policy;
79  return 0;
80}
81
82int pthread_attr_setschedparam(pthread_attr_t* attr, const sched_param* param) {
83  attr->sched_priority = param->sched_priority;
84  return 0;
85}
86
87int pthread_attr_getschedparam(const pthread_attr_t* attr, sched_param* param) {
88  param->sched_priority = attr->sched_priority;
89  return 0;
90}
91
92int pthread_attr_setstacksize(pthread_attr_t* attr, size_t stack_size) {
93  if (stack_size < PTHREAD_STACK_MIN) {
94    return EINVAL;
95  }
96  attr->stack_size = stack_size;
97  return 0;
98}
99
100int pthread_attr_getstacksize(const pthread_attr_t* attr, size_t* stack_size) {
101  void* unused;
102  return pthread_attr_getstack(attr, &unused, stack_size);
103}
104
105int pthread_attr_setstack(pthread_attr_t* attr, void* stack_base, size_t stack_size) {
106  if ((stack_size & (PAGE_SIZE - 1) || stack_size < PTHREAD_STACK_MIN)) {
107    return EINVAL;
108  }
109  if (reinterpret_cast<uintptr_t>(stack_base) & (PAGE_SIZE - 1)) {
110    return EINVAL;
111  }
112  attr->stack_base = stack_base;
113  attr->stack_size = stack_size;
114  return 0;
115}
116
117static uintptr_t __get_main_stack_startstack() {
118  FILE* fp = fopen("/proc/self/stat", "re");
119  if (fp == nullptr) {
120    __libc_fatal("couldn't open /proc/self/stat: %s", strerror(errno));
121  }
122
123  char line[BUFSIZ];
124  if (fgets(line, sizeof(line), fp) == nullptr) {
125    __libc_fatal("couldn't read /proc/self/stat: %s", strerror(errno));
126  }
127
128  fclose(fp);
129
130  // See man 5 proc. There's no reason comm can't contain ' ' or ')',
131  // so we search backwards for the end of it. We're looking for this field:
132  //
133  //  startstack %lu (28) The address of the start (i.e., bottom) of the stack.
134  uintptr_t startstack = 0;
135  const char* end_of_comm = strrchr(line, ')');
136  if (sscanf(end_of_comm + 1, " %*c "
137             "%*d %*d %*d %*d %*d "
138             "%*u %*u %*u %*u %*u %*u %*u "
139             "%*d %*d %*d %*d %*d %*d "
140             "%*u %*u %*d %*u %*u %*u %" SCNuPTR, &startstack) != 1) {
141    __libc_fatal("couldn't parse /proc/self/stat");
142  }
143
144  return startstack;
145}
146
147static int __pthread_attr_getstack_main_thread(void** stack_base, size_t* stack_size) {
148  ErrnoRestorer errno_restorer;
149
150  rlimit stack_limit;
151  if (getrlimit(RLIMIT_STACK, &stack_limit) == -1) {
152    return errno;
153  }
154
155  // If the current RLIMIT_STACK is RLIM_INFINITY, only admit to an 8MiB stack for sanity's sake.
156  if (stack_limit.rlim_cur == RLIM_INFINITY) {
157    stack_limit.rlim_cur = 8 * 1024 * 1024;
158  }
159
160  // Ask the kernel where our main thread's stack started.
161  uintptr_t startstack = __get_main_stack_startstack();
162
163  // Hunt for the region that contains that address.
164  FILE* fp = fopen("/proc/self/maps", "re");
165  if (fp == nullptr) {
166    __libc_fatal("couldn't open /proc/self/maps");
167  }
168  char line[BUFSIZ];
169  while (fgets(line, sizeof(line), fp) != NULL) {
170    uintptr_t lo, hi;
171    if (sscanf(line, "%" SCNxPTR "-%" SCNxPTR, &lo, &hi) == 2) {
172      if (lo <= startstack && startstack <= hi) {
173        *stack_size = stack_limit.rlim_cur;
174        *stack_base = reinterpret_cast<void*>(hi - *stack_size);
175        fclose(fp);
176        return 0;
177      }
178    }
179  }
180  __libc_fatal("Stack not found in /proc/self/maps");
181}
182
183int pthread_attr_getstack(const pthread_attr_t* attr, void** stack_base, size_t* stack_size) {
184  *stack_base = attr->stack_base;
185  *stack_size = attr->stack_size;
186  return 0;
187}
188
189int pthread_attr_setguardsize(pthread_attr_t* attr, size_t guard_size) {
190  attr->guard_size = guard_size;
191  return 0;
192}
193
194int pthread_attr_getguardsize(const pthread_attr_t* attr, size_t* guard_size) {
195  *guard_size = attr->guard_size;
196  return 0;
197}
198
199int pthread_getattr_np(pthread_t t, pthread_attr_t* attr) {
200  pthread_internal_t* thread = reinterpret_cast<pthread_internal_t*>(t);
201  *attr = thread->attr;
202  // We prefer reading join_state here to setting thread->attr.flags in pthread_detach.
203  // Because data race exists in the latter case.
204  if (atomic_load(&thread->join_state) == THREAD_DETACHED) {
205    attr->flags |= PTHREAD_ATTR_FLAG_DETACHED;
206  }
207  // The main thread's stack information is not stored in thread->attr, and we need to
208  // collect that at runtime.
209  if (thread->tid == getpid()) {
210    return __pthread_attr_getstack_main_thread(&attr->stack_base, &attr->stack_size);
211  }
212  return 0;
213}
214
215int pthread_attr_setscope(pthread_attr_t*, int scope) {
216  if (scope == PTHREAD_SCOPE_SYSTEM) {
217    return 0;
218  }
219  if (scope == PTHREAD_SCOPE_PROCESS) {
220    return ENOTSUP;
221  }
222  return EINVAL;
223}
224
225int pthread_attr_getscope(const pthread_attr_t*, int* scope) {
226  *scope = PTHREAD_SCOPE_SYSTEM;
227  return 0;
228}
229