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_internal.h"
30
31#include <errno.h>
32#include <stdlib.h>
33#include <string.h>
34#include <sys/mman.h>
35
36#include <async_safe/log.h>
37
38#include "private/bionic_futex.h"
39#include "private/bionic_sdk_version.h"
40#include "private/bionic_tls.h"
41
42static pthread_internal_t* g_thread_list = nullptr;
43static pthread_rwlock_t g_thread_list_lock = PTHREAD_RWLOCK_INITIALIZER;
44
45template <bool write> class ScopedRWLock {
46 public:
47  ScopedRWLock(pthread_rwlock_t* rwlock) : rwlock_(rwlock) {
48    (write ? pthread_rwlock_wrlock : pthread_rwlock_rdlock)(rwlock_);
49  }
50
51  ~ScopedRWLock() {
52    pthread_rwlock_unlock(rwlock_);
53  }
54
55 private:
56  pthread_rwlock_t* rwlock_;
57  DISALLOW_IMPLICIT_CONSTRUCTORS(ScopedRWLock);
58};
59
60typedef ScopedRWLock<true> ScopedWriteLock;
61typedef ScopedRWLock<false> ScopedReadLock;
62
63pthread_t __pthread_internal_add(pthread_internal_t* thread) {
64  ScopedWriteLock locker(&g_thread_list_lock);
65
66  // We insert at the head.
67  thread->next = g_thread_list;
68  thread->prev = nullptr;
69  if (thread->next != nullptr) {
70    thread->next->prev = thread;
71  }
72  g_thread_list = thread;
73  return reinterpret_cast<pthread_t>(thread);
74}
75
76void __pthread_internal_remove(pthread_internal_t* thread) {
77  ScopedWriteLock locker(&g_thread_list_lock);
78
79  if (thread->next != nullptr) {
80    thread->next->prev = thread->prev;
81  }
82  if (thread->prev != nullptr) {
83    thread->prev->next = thread->next;
84  } else {
85    g_thread_list = thread->next;
86  }
87}
88
89static void __pthread_internal_free(pthread_internal_t* thread) {
90  if (thread->mmap_size != 0) {
91    // Free mapped space, including thread stack and pthread_internal_t.
92    munmap(thread->attr.stack_base, thread->mmap_size);
93  }
94}
95
96void __pthread_internal_remove_and_free(pthread_internal_t* thread) {
97  __pthread_internal_remove(thread);
98  __pthread_internal_free(thread);
99}
100
101pthread_internal_t* __pthread_internal_find(pthread_t thread_id) {
102  pthread_internal_t* thread = reinterpret_cast<pthread_internal_t*>(thread_id);
103
104  // Check if we're looking for ourselves before acquiring the lock.
105  if (thread == __get_thread()) return thread;
106
107  {
108    // Make sure to release the lock before the abort below. Otherwise,
109    // some apps might deadlock in their own crash handlers (see b/6565627).
110    ScopedReadLock locker(&g_thread_list_lock);
111    for (pthread_internal_t* t = g_thread_list; t != nullptr; t = t->next) {
112      if (t == thread) return thread;
113    }
114  }
115
116  // Historically we'd return null, but
117  if (bionic_get_application_target_sdk_version() >= __ANDROID_API_O__) {
118    if (thread == nullptr) {
119      // This seems to be a common mistake, and it's relatively harmless because
120      // there will never be a valid thread at address 0, whereas other invalid
121      // addresses might sometimes contain threads or things that look enough like
122      // threads for us to do some real damage by continuing.
123      // TODO: try getting rid of this when Treble lets us keep vendor blobs on an old API level.
124      async_safe_format_log(ANDROID_LOG_WARN, "libc", "invalid pthread_t (0) passed to libc");
125    } else {
126      async_safe_fatal("invalid pthread_t %p passed to libc", thread);
127    }
128  }
129  return nullptr;
130}
131