libc/bionic/pthread_internal.cpp

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