pthread_test.cpp revision a36158a77d904aa65f50d5950b7608ef8fa3210f
1e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck/* 2e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck * Copyright (C) 2012 The Android Open Source Project 3e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck * 4e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck * Licensed under the Apache License, Version 2.0 (the "License"); 5e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck * you may not use this file except in compliance with the License. 6e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck * You may obtain a copy of the License at 7e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck * 8e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck * http://www.apache.org/licenses/LICENSE-2.0 9e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck * 10e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck * Unless required by applicable law or agreed to in writing, software 11e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck * distributed under the License is distributed on an "AS IS" BASIS, 12e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck * See the License for the specific language governing permissions and 14e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck * limitations under the License. 15e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck */ 16e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck 17e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck#include <gtest/gtest.h> 18e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck 19e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck#include <errno.h> 20e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck#include <inttypes.h> 21e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck#include <limits.h> 22e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck#include <malloc.h> 23e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck#include <pthread.h> 24e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck#include <signal.h> 25e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck#include <stdio.h> 26e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck#include <sys/mman.h> 27e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck#include <sys/syscall.h> 28e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck#include <time.h> 29e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck#include <unistd.h> 30e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck#include <unwind.h> 31e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck 32e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck#include <atomic> 33e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck#include <regex> 34e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck#include <vector> 35e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck 36e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck#include <base/file.h> 37e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck#include <base/stringprintf.h> 38e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck 39e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck#include "private/bionic_macros.h" 40e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck#include "private/ScopeGuard.h" 41e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck#include "BionicDeathTest.h" 42e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck#include "ScopedSignalHandler.h" 43e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck 44e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck#include "utils.h" 45e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck 46e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reckextern "C" pid_t gettid(); 47e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck 48e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn ReckTEST(pthread, pthread_key_create) { 49e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck pthread_key_t key; 50e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck ASSERT_EQ(0, pthread_key_create(&key, NULL)); 51e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck ASSERT_EQ(0, pthread_key_delete(key)); 52e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck // Can't delete a key that's already been deleted. 53e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck ASSERT_EQ(EINVAL, pthread_key_delete(key)); 54e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck} 55e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck 56e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn ReckTEST(pthread, pthread_keys_max) { 57e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck // POSIX says PTHREAD_KEYS_MAX should be at least _POSIX_THREAD_KEYS_MAX. 58e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck ASSERT_GE(PTHREAD_KEYS_MAX, _POSIX_THREAD_KEYS_MAX); 59e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck} 60e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck 61e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn ReckTEST(pthread, sysconf_SC_THREAD_KEYS_MAX_eq_PTHREAD_KEYS_MAX) { 62e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck int sysconf_max = sysconf(_SC_THREAD_KEYS_MAX); 63e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck ASSERT_EQ(sysconf_max, PTHREAD_KEYS_MAX); 64e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck} 65e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck 66e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn ReckTEST(pthread, pthread_key_many_distinct) { 67e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck // As gtest uses pthread keys, we can't allocate exactly PTHREAD_KEYS_MAX 68e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck // pthread keys, but We should be able to allocate at least this many keys. 69e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck int nkeys = PTHREAD_KEYS_MAX / 2; 70e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck std::vector<pthread_key_t> keys; 71e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck 72e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck auto scope_guard = make_scope_guard([&keys]{ 73e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck for (const auto& key : keys) { 74e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck EXPECT_EQ(0, pthread_key_delete(key)); 75e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck } 76e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck }); 77e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck 78e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck for (int i = 0; i < nkeys; ++i) { 79e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck pthread_key_t key; 80e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck // If this fails, it's likely that LIBC_PTHREAD_KEY_RESERVED_COUNT is wrong. 81e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck ASSERT_EQ(0, pthread_key_create(&key, NULL)) << i << " of " << nkeys; 82e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck keys.push_back(key); 83e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck ASSERT_EQ(0, pthread_setspecific(key, reinterpret_cast<void*>(i))); 84e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck } 85e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck 86e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck for (int i = keys.size() - 1; i >= 0; --i) { 87e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck ASSERT_EQ(reinterpret_cast<void*>(i), pthread_getspecific(keys.back())); 88e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck pthread_key_t key = keys.back(); 89e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck keys.pop_back(); 90e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck ASSERT_EQ(0, pthread_key_delete(key)); 91e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck } 92e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck} 93e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck 94e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn ReckTEST(pthread, pthread_key_not_exceed_PTHREAD_KEYS_MAX) { 95e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck std::vector<pthread_key_t> keys; 96e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck int rv = 0; 97e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck 98e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck // Pthread keys are used by gtest, so PTHREAD_KEYS_MAX should 99e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck // be more than we are allowed to allocate now. 100e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck for (int i = 0; i < PTHREAD_KEYS_MAX; i++) { 101e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck pthread_key_t key; 102e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck rv = pthread_key_create(&key, NULL); 103e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck if (rv == EAGAIN) { 104e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck break; 105e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck } 106e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck EXPECT_EQ(0, rv); 107e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck keys.push_back(key); 108e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck } 109e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck 110e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck // Don't leak keys. 111e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck for (const auto& key : keys) { 112e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck EXPECT_EQ(0, pthread_key_delete(key)); 113e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck } 114e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck keys.clear(); 115e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck 116e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck // We should have eventually reached the maximum number of keys and received 117e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck // EAGAIN. 118e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck ASSERT_EQ(EAGAIN, rv); 119e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck} 120e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck 121e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn ReckTEST(pthread, pthread_key_delete) { 122e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck void* expected = reinterpret_cast<void*>(1234); 123e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck pthread_key_t key; 124e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck ASSERT_EQ(0, pthread_key_create(&key, NULL)); 125e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck ASSERT_EQ(0, pthread_setspecific(key, expected)); 126e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck ASSERT_EQ(expected, pthread_getspecific(key)); 127e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck ASSERT_EQ(0, pthread_key_delete(key)); 128e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck // After deletion, pthread_getspecific returns NULL. 129e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck ASSERT_EQ(NULL, pthread_getspecific(key)); 130e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck // And you can't use pthread_setspecific with the deleted key. 131e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck ASSERT_EQ(EINVAL, pthread_setspecific(key, expected)); 132e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck} 133e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck 134e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn ReckTEST(pthread, pthread_key_fork) { 135e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck void* expected = reinterpret_cast<void*>(1234); 136e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck pthread_key_t key; 137e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck ASSERT_EQ(0, pthread_key_create(&key, NULL)); 138e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck ASSERT_EQ(0, pthread_setspecific(key, expected)); 139e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck ASSERT_EQ(expected, pthread_getspecific(key)); 140e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck 141e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck pid_t pid = fork(); 142e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck ASSERT_NE(-1, pid) << strerror(errno); 143e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck 144e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck if (pid == 0) { 145e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck // The surviving thread inherits all the forking thread's TLS values... 146e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck ASSERT_EQ(expected, pthread_getspecific(key)); 147e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck _exit(99); 148e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck } 149e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck 150e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck int status; 151e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck ASSERT_EQ(pid, waitpid(pid, &status, 0)); 152e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck ASSERT_TRUE(WIFEXITED(status)); 153e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck ASSERT_EQ(99, WEXITSTATUS(status)); 154e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck 155e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck ASSERT_EQ(expected, pthread_getspecific(key)); 156e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck ASSERT_EQ(0, pthread_key_delete(key)); 157e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck} 158e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck 159e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reckstatic void* DirtyKeyFn(void* key) { 160e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck return pthread_getspecific(*reinterpret_cast<pthread_key_t*>(key)); 161e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck} 162e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck 163e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn ReckTEST(pthread, pthread_key_dirty) { 164e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck pthread_key_t key; 165e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck ASSERT_EQ(0, pthread_key_create(&key, NULL)); 166e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck 167e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck size_t stack_size = 640 * 1024; 168e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck void* stack = mmap(NULL, stack_size, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0); 169e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck ASSERT_NE(MAP_FAILED, stack); 170e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck memset(stack, 0xff, stack_size); 171e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck 172e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck pthread_attr_t attr; 173e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck ASSERT_EQ(0, pthread_attr_init(&attr)); 174e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck ASSERT_EQ(0, pthread_attr_setstack(&attr, stack, stack_size)); 175e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck 176e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck pthread_t t; 177e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck ASSERT_EQ(0, pthread_create(&t, &attr, DirtyKeyFn, &key)); 178e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck 179e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck void* result; 180e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck ASSERT_EQ(0, pthread_join(t, &result)); 181e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck ASSERT_EQ(nullptr, result); // Not ~0! 182e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck 183e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck ASSERT_EQ(0, munmap(stack, stack_size)); 184e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck ASSERT_EQ(0, pthread_key_delete(key)); 185e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck} 186e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck 187e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn ReckTEST(pthread, static_pthread_key_used_before_creation) { 188e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck#if defined(__BIONIC__) 189e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck // See http://b/19625804. The bug is about a static/global pthread key being used before creation. 190e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck // So here tests if the static/global default value 0 can be detected as invalid key. 191e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck static pthread_key_t key; 192e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck ASSERT_EQ(nullptr, pthread_getspecific(key)); 193e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck ASSERT_EQ(EINVAL, pthread_setspecific(key, nullptr)); 194e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck ASSERT_EQ(EINVAL, pthread_key_delete(key)); 195e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck#else 196e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck GTEST_LOG_(INFO) << "This test tests bionic pthread key implementation detail.\n"; 197e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck#endif 198e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck} 199e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck 200e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reckstatic void* IdFn(void* arg) { 201e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck return arg; 202e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck} 203e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck 204e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reckclass SpinFunctionHelper { 205e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck public: 206e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck SpinFunctionHelper() { 207e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck SpinFunctionHelper::spin_flag_ = true; 208e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck } 209e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck ~SpinFunctionHelper() { 210e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck UnSpin(); 211e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck } 212e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck auto GetFunction() -> void* (*)(void*) { 213e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck return SpinFunctionHelper::SpinFn; 214e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck } 215e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck 216e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck void UnSpin() { 217e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck SpinFunctionHelper::spin_flag_ = false; 218e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck } 219e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck 220e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck private: 221e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck static void* SpinFn(void*) { 222e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck while (spin_flag_) {} 223e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck return NULL; 224e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck } 225e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck static std::atomic<bool> spin_flag_; 226e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck}; 227e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck 228e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck// It doesn't matter if spin_flag_ is used in several tests, 229e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck// because it is always set to false after each test. Each thread 230e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck// loops on spin_flag_ can find it becomes false at some time. 231e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reckstd::atomic<bool> SpinFunctionHelper::spin_flag_; 232e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck 233e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reckstatic void* JoinFn(void* arg) { 234e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck return reinterpret_cast<void*>(pthread_join(reinterpret_cast<pthread_t>(arg), NULL)); 235e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck} 236e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck 237e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reckstatic void AssertDetached(pthread_t t, bool is_detached) { 238e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck pthread_attr_t attr; 239e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck ASSERT_EQ(0, pthread_getattr_np(t, &attr)); 240e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck int detach_state; 241 ASSERT_EQ(0, pthread_attr_getdetachstate(&attr, &detach_state)); 242 pthread_attr_destroy(&attr); 243 ASSERT_EQ(is_detached, (detach_state == PTHREAD_CREATE_DETACHED)); 244} 245 246static void MakeDeadThread(pthread_t& t) { 247 ASSERT_EQ(0, pthread_create(&t, NULL, IdFn, NULL)); 248 ASSERT_EQ(0, pthread_join(t, NULL)); 249} 250 251TEST(pthread, pthread_create) { 252 void* expected_result = reinterpret_cast<void*>(123); 253 // Can we create a thread? 254 pthread_t t; 255 ASSERT_EQ(0, pthread_create(&t, NULL, IdFn, expected_result)); 256 // If we join, do we get the expected value back? 257 void* result; 258 ASSERT_EQ(0, pthread_join(t, &result)); 259 ASSERT_EQ(expected_result, result); 260} 261 262TEST(pthread, pthread_create_EAGAIN) { 263 pthread_attr_t attributes; 264 ASSERT_EQ(0, pthread_attr_init(&attributes)); 265 ASSERT_EQ(0, pthread_attr_setstacksize(&attributes, static_cast<size_t>(-1) & ~(getpagesize() - 1))); 266 267 pthread_t t; 268 ASSERT_EQ(EAGAIN, pthread_create(&t, &attributes, IdFn, NULL)); 269} 270 271TEST(pthread, pthread_no_join_after_detach) { 272 SpinFunctionHelper spinhelper; 273 274 pthread_t t1; 275 ASSERT_EQ(0, pthread_create(&t1, NULL, spinhelper.GetFunction(), NULL)); 276 277 // After a pthread_detach... 278 ASSERT_EQ(0, pthread_detach(t1)); 279 AssertDetached(t1, true); 280 281 // ...pthread_join should fail. 282 ASSERT_EQ(EINVAL, pthread_join(t1, NULL)); 283} 284 285TEST(pthread, pthread_no_op_detach_after_join) { 286 SpinFunctionHelper spinhelper; 287 288 pthread_t t1; 289 ASSERT_EQ(0, pthread_create(&t1, NULL, spinhelper.GetFunction(), NULL)); 290 291 // If thread 2 is already waiting to join thread 1... 292 pthread_t t2; 293 ASSERT_EQ(0, pthread_create(&t2, NULL, JoinFn, reinterpret_cast<void*>(t1))); 294 295 sleep(1); // (Give t2 a chance to call pthread_join.) 296 297#if defined(__BIONIC__) 298 ASSERT_EQ(EINVAL, pthread_detach(t1)); 299#else 300 ASSERT_EQ(0, pthread_detach(t1)); 301#endif 302 AssertDetached(t1, false); 303 304 spinhelper.UnSpin(); 305 306 // ...but t2's join on t1 still goes ahead (which we can tell because our join on t2 finishes). 307 void* join_result; 308 ASSERT_EQ(0, pthread_join(t2, &join_result)); 309 ASSERT_EQ(0U, reinterpret_cast<uintptr_t>(join_result)); 310} 311 312TEST(pthread, pthread_join_self) { 313 ASSERT_EQ(EDEADLK, pthread_join(pthread_self(), NULL)); 314} 315 316struct TestBug37410 { 317 pthread_t main_thread; 318 pthread_mutex_t mutex; 319 320 static void main() { 321 TestBug37410 data; 322 data.main_thread = pthread_self(); 323 ASSERT_EQ(0, pthread_mutex_init(&data.mutex, NULL)); 324 ASSERT_EQ(0, pthread_mutex_lock(&data.mutex)); 325 326 pthread_t t; 327 ASSERT_EQ(0, pthread_create(&t, NULL, TestBug37410::thread_fn, reinterpret_cast<void*>(&data))); 328 329 // Wait for the thread to be running... 330 ASSERT_EQ(0, pthread_mutex_lock(&data.mutex)); 331 ASSERT_EQ(0, pthread_mutex_unlock(&data.mutex)); 332 333 // ...and exit. 334 pthread_exit(NULL); 335 } 336 337 private: 338 static void* thread_fn(void* arg) { 339 TestBug37410* data = reinterpret_cast<TestBug37410*>(arg); 340 341 // Let the main thread know we're running. 342 pthread_mutex_unlock(&data->mutex); 343 344 // And wait for the main thread to exit. 345 pthread_join(data->main_thread, NULL); 346 347 return NULL; 348 } 349}; 350 351// Even though this isn't really a death test, we have to say "DeathTest" here so gtest knows to 352// run this test (which exits normally) in its own process. 353 354class pthread_DeathTest : public BionicDeathTest {}; 355 356TEST_F(pthread_DeathTest, pthread_bug_37410) { 357 // http://code.google.com/p/android/issues/detail?id=37410 358 ASSERT_EXIT(TestBug37410::main(), ::testing::ExitedWithCode(0), ""); 359} 360 361static void* SignalHandlerFn(void* arg) { 362 sigset_t wait_set; 363 sigfillset(&wait_set); 364 return reinterpret_cast<void*>(sigwait(&wait_set, reinterpret_cast<int*>(arg))); 365} 366 367TEST(pthread, pthread_sigmask) { 368 // Check that SIGUSR1 isn't blocked. 369 sigset_t original_set; 370 sigemptyset(&original_set); 371 ASSERT_EQ(0, pthread_sigmask(SIG_BLOCK, NULL, &original_set)); 372 ASSERT_FALSE(sigismember(&original_set, SIGUSR1)); 373 374 // Block SIGUSR1. 375 sigset_t set; 376 sigemptyset(&set); 377 sigaddset(&set, SIGUSR1); 378 ASSERT_EQ(0, pthread_sigmask(SIG_BLOCK, &set, NULL)); 379 380 // Check that SIGUSR1 is blocked. 381 sigset_t final_set; 382 sigemptyset(&final_set); 383 ASSERT_EQ(0, pthread_sigmask(SIG_BLOCK, NULL, &final_set)); 384 ASSERT_TRUE(sigismember(&final_set, SIGUSR1)); 385 // ...and that sigprocmask agrees with pthread_sigmask. 386 sigemptyset(&final_set); 387 ASSERT_EQ(0, sigprocmask(SIG_BLOCK, NULL, &final_set)); 388 ASSERT_TRUE(sigismember(&final_set, SIGUSR1)); 389 390 // Spawn a thread that calls sigwait and tells us what it received. 391 pthread_t signal_thread; 392 int received_signal = -1; 393 ASSERT_EQ(0, pthread_create(&signal_thread, NULL, SignalHandlerFn, &received_signal)); 394 395 // Send that thread SIGUSR1. 396 pthread_kill(signal_thread, SIGUSR1); 397 398 // See what it got. 399 void* join_result; 400 ASSERT_EQ(0, pthread_join(signal_thread, &join_result)); 401 ASSERT_EQ(SIGUSR1, received_signal); 402 ASSERT_EQ(0U, reinterpret_cast<uintptr_t>(join_result)); 403 404 // Restore the original signal mask. 405 ASSERT_EQ(0, pthread_sigmask(SIG_SETMASK, &original_set, NULL)); 406} 407 408TEST(pthread, pthread_setname_np__too_long) { 409 // The limit is 15 characters --- the kernel's buffer is 16, but includes a NUL. 410 ASSERT_EQ(0, pthread_setname_np(pthread_self(), "123456789012345")); 411 ASSERT_EQ(ERANGE, pthread_setname_np(pthread_self(), "1234567890123456")); 412} 413 414TEST(pthread, pthread_setname_np__self) { 415 ASSERT_EQ(0, pthread_setname_np(pthread_self(), "short 1")); 416} 417 418TEST(pthread, pthread_setname_np__other) { 419 SpinFunctionHelper spinhelper; 420 421 pthread_t t1; 422 ASSERT_EQ(0, pthread_create(&t1, NULL, spinhelper.GetFunction(), NULL)); 423 ASSERT_EQ(0, pthread_setname_np(t1, "short 2")); 424 spinhelper.UnSpin(); 425 ASSERT_EQ(0, pthread_join(t1, nullptr)); 426} 427 428TEST(pthread, pthread_setname_np__no_such_thread) { 429 pthread_t dead_thread; 430 MakeDeadThread(dead_thread); 431 432 // Call pthread_setname_np after thread has already exited. 433 ASSERT_EQ(ENOENT, pthread_setname_np(dead_thread, "short 3")); 434} 435 436TEST(pthread, pthread_kill__0) { 437 // Signal 0 just tests that the thread exists, so it's safe to call on ourselves. 438 ASSERT_EQ(0, pthread_kill(pthread_self(), 0)); 439} 440 441TEST(pthread, pthread_kill__invalid_signal) { 442 ASSERT_EQ(EINVAL, pthread_kill(pthread_self(), -1)); 443} 444 445static void pthread_kill__in_signal_handler_helper(int signal_number) { 446 static int count = 0; 447 ASSERT_EQ(SIGALRM, signal_number); 448 if (++count == 1) { 449 // Can we call pthread_kill from a signal handler? 450 ASSERT_EQ(0, pthread_kill(pthread_self(), SIGALRM)); 451 } 452} 453 454TEST(pthread, pthread_kill__in_signal_handler) { 455 ScopedSignalHandler ssh(SIGALRM, pthread_kill__in_signal_handler_helper); 456 ASSERT_EQ(0, pthread_kill(pthread_self(), SIGALRM)); 457} 458 459TEST(pthread, pthread_detach__no_such_thread) { 460 pthread_t dead_thread; 461 MakeDeadThread(dead_thread); 462 463 ASSERT_EQ(ESRCH, pthread_detach(dead_thread)); 464} 465 466TEST(pthread, pthread_getcpuclockid__clock_gettime) { 467 SpinFunctionHelper spinhelper; 468 469 pthread_t t; 470 ASSERT_EQ(0, pthread_create(&t, NULL, spinhelper.GetFunction(), NULL)); 471 472 clockid_t c; 473 ASSERT_EQ(0, pthread_getcpuclockid(t, &c)); 474 timespec ts; 475 ASSERT_EQ(0, clock_gettime(c, &ts)); 476 spinhelper.UnSpin(); 477 ASSERT_EQ(0, pthread_join(t, nullptr)); 478} 479 480TEST(pthread, pthread_getcpuclockid__no_such_thread) { 481 pthread_t dead_thread; 482 MakeDeadThread(dead_thread); 483 484 clockid_t c; 485 ASSERT_EQ(ESRCH, pthread_getcpuclockid(dead_thread, &c)); 486} 487 488TEST(pthread, pthread_getschedparam__no_such_thread) { 489 pthread_t dead_thread; 490 MakeDeadThread(dead_thread); 491 492 int policy; 493 sched_param param; 494 ASSERT_EQ(ESRCH, pthread_getschedparam(dead_thread, &policy, ¶m)); 495} 496 497TEST(pthread, pthread_setschedparam__no_such_thread) { 498 pthread_t dead_thread; 499 MakeDeadThread(dead_thread); 500 501 int policy = 0; 502 sched_param param; 503 ASSERT_EQ(ESRCH, pthread_setschedparam(dead_thread, policy, ¶m)); 504} 505 506TEST(pthread, pthread_join__no_such_thread) { 507 pthread_t dead_thread; 508 MakeDeadThread(dead_thread); 509 510 ASSERT_EQ(ESRCH, pthread_join(dead_thread, NULL)); 511} 512 513TEST(pthread, pthread_kill__no_such_thread) { 514 pthread_t dead_thread; 515 MakeDeadThread(dead_thread); 516 517 ASSERT_EQ(ESRCH, pthread_kill(dead_thread, 0)); 518} 519 520TEST(pthread, pthread_join__multijoin) { 521 SpinFunctionHelper spinhelper; 522 523 pthread_t t1; 524 ASSERT_EQ(0, pthread_create(&t1, NULL, spinhelper.GetFunction(), NULL)); 525 526 pthread_t t2; 527 ASSERT_EQ(0, pthread_create(&t2, NULL, JoinFn, reinterpret_cast<void*>(t1))); 528 529 sleep(1); // (Give t2 a chance to call pthread_join.) 530 531 // Multiple joins to the same thread should fail. 532 ASSERT_EQ(EINVAL, pthread_join(t1, NULL)); 533 534 spinhelper.UnSpin(); 535 536 // ...but t2's join on t1 still goes ahead (which we can tell because our join on t2 finishes). 537 void* join_result; 538 ASSERT_EQ(0, pthread_join(t2, &join_result)); 539 ASSERT_EQ(0U, reinterpret_cast<uintptr_t>(join_result)); 540} 541 542TEST(pthread, pthread_join__race) { 543 // http://b/11693195 --- pthread_join could return before the thread had actually exited. 544 // If the joiner unmapped the thread's stack, that could lead to SIGSEGV in the thread. 545 for (size_t i = 0; i < 1024; ++i) { 546 size_t stack_size = 640*1024; 547 void* stack = mmap(NULL, stack_size, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE, -1, 0); 548 549 pthread_attr_t a; 550 pthread_attr_init(&a); 551 pthread_attr_setstack(&a, stack, stack_size); 552 553 pthread_t t; 554 ASSERT_EQ(0, pthread_create(&t, &a, IdFn, NULL)); 555 ASSERT_EQ(0, pthread_join(t, NULL)); 556 ASSERT_EQ(0, munmap(stack, stack_size)); 557 } 558} 559 560static void* GetActualGuardSizeFn(void* arg) { 561 pthread_attr_t attributes; 562 pthread_getattr_np(pthread_self(), &attributes); 563 pthread_attr_getguardsize(&attributes, reinterpret_cast<size_t*>(arg)); 564 return NULL; 565} 566 567static size_t GetActualGuardSize(const pthread_attr_t& attributes) { 568 size_t result; 569 pthread_t t; 570 pthread_create(&t, &attributes, GetActualGuardSizeFn, &result); 571 pthread_join(t, NULL); 572 return result; 573} 574 575static void* GetActualStackSizeFn(void* arg) { 576 pthread_attr_t attributes; 577 pthread_getattr_np(pthread_self(), &attributes); 578 pthread_attr_getstacksize(&attributes, reinterpret_cast<size_t*>(arg)); 579 return NULL; 580} 581 582static size_t GetActualStackSize(const pthread_attr_t& attributes) { 583 size_t result; 584 pthread_t t; 585 pthread_create(&t, &attributes, GetActualStackSizeFn, &result); 586 pthread_join(t, NULL); 587 return result; 588} 589 590TEST(pthread, pthread_attr_setguardsize) { 591 pthread_attr_t attributes; 592 ASSERT_EQ(0, pthread_attr_init(&attributes)); 593 594 // Get the default guard size. 595 size_t default_guard_size; 596 ASSERT_EQ(0, pthread_attr_getguardsize(&attributes, &default_guard_size)); 597 598 // No such thing as too small: will be rounded up to one page by pthread_create. 599 ASSERT_EQ(0, pthread_attr_setguardsize(&attributes, 128)); 600 size_t guard_size; 601 ASSERT_EQ(0, pthread_attr_getguardsize(&attributes, &guard_size)); 602 ASSERT_EQ(128U, guard_size); 603 ASSERT_EQ(4096U, GetActualGuardSize(attributes)); 604 605 // Large enough and a multiple of the page size. 606 ASSERT_EQ(0, pthread_attr_setguardsize(&attributes, 32*1024)); 607 ASSERT_EQ(0, pthread_attr_getguardsize(&attributes, &guard_size)); 608 ASSERT_EQ(32*1024U, guard_size); 609 610 // Large enough but not a multiple of the page size; will be rounded up by pthread_create. 611 ASSERT_EQ(0, pthread_attr_setguardsize(&attributes, 32*1024 + 1)); 612 ASSERT_EQ(0, pthread_attr_getguardsize(&attributes, &guard_size)); 613 ASSERT_EQ(32*1024U + 1, guard_size); 614} 615 616TEST(pthread, pthread_attr_setstacksize) { 617 pthread_attr_t attributes; 618 ASSERT_EQ(0, pthread_attr_init(&attributes)); 619 620 // Get the default stack size. 621 size_t default_stack_size; 622 ASSERT_EQ(0, pthread_attr_getstacksize(&attributes, &default_stack_size)); 623 624 // Too small. 625 ASSERT_EQ(EINVAL, pthread_attr_setstacksize(&attributes, 128)); 626 size_t stack_size; 627 ASSERT_EQ(0, pthread_attr_getstacksize(&attributes, &stack_size)); 628 ASSERT_EQ(default_stack_size, stack_size); 629 ASSERT_GE(GetActualStackSize(attributes), default_stack_size); 630 631 // Large enough and a multiple of the page size; may be rounded up by pthread_create. 632 ASSERT_EQ(0, pthread_attr_setstacksize(&attributes, 32*1024)); 633 ASSERT_EQ(0, pthread_attr_getstacksize(&attributes, &stack_size)); 634 ASSERT_EQ(32*1024U, stack_size); 635 ASSERT_GE(GetActualStackSize(attributes), 32*1024U); 636 637 // Large enough but not aligned; will be rounded up by pthread_create. 638 ASSERT_EQ(0, pthread_attr_setstacksize(&attributes, 32*1024 + 1)); 639 ASSERT_EQ(0, pthread_attr_getstacksize(&attributes, &stack_size)); 640 ASSERT_EQ(32*1024U + 1, stack_size); 641#if defined(__BIONIC__) 642 ASSERT_GT(GetActualStackSize(attributes), 32*1024U + 1); 643#else // __BIONIC__ 644 // glibc rounds down, in violation of POSIX. They document this in their BUGS section. 645 ASSERT_EQ(GetActualStackSize(attributes), 32*1024U); 646#endif // __BIONIC__ 647} 648 649TEST(pthread, pthread_rwlockattr_smoke) { 650 pthread_rwlockattr_t attr; 651 ASSERT_EQ(0, pthread_rwlockattr_init(&attr)); 652 653 int pshared_value_array[] = {PTHREAD_PROCESS_PRIVATE, PTHREAD_PROCESS_SHARED}; 654 for (size_t i = 0; i < sizeof(pshared_value_array) / sizeof(pshared_value_array[0]); ++i) { 655 ASSERT_EQ(0, pthread_rwlockattr_setpshared(&attr, pshared_value_array[i])); 656 int pshared; 657 ASSERT_EQ(0, pthread_rwlockattr_getpshared(&attr, &pshared)); 658 ASSERT_EQ(pshared_value_array[i], pshared); 659 } 660 661 int kind_array[] = {PTHREAD_RWLOCK_PREFER_READER_NP, 662 PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP}; 663 for (size_t i = 0; i < sizeof(kind_array) / sizeof(kind_array[0]); ++i) { 664 ASSERT_EQ(0, pthread_rwlockattr_setkind_np(&attr, kind_array[i])); 665 int kind; 666 ASSERT_EQ(0, pthread_rwlockattr_getkind_np(&attr, &kind)); 667 ASSERT_EQ(kind_array[i], kind); 668 } 669 670 ASSERT_EQ(0, pthread_rwlockattr_destroy(&attr)); 671} 672 673TEST(pthread, pthread_rwlock_init_same_as_PTHREAD_RWLOCK_INITIALIZER) { 674 pthread_rwlock_t lock1 = PTHREAD_RWLOCK_INITIALIZER; 675 pthread_rwlock_t lock2; 676 ASSERT_EQ(0, pthread_rwlock_init(&lock2, NULL)); 677 ASSERT_EQ(0, memcmp(&lock1, &lock2, sizeof(lock1))); 678} 679 680TEST(pthread, pthread_rwlock_smoke) { 681 pthread_rwlock_t l; 682 ASSERT_EQ(0, pthread_rwlock_init(&l, NULL)); 683 684 // Single read lock 685 ASSERT_EQ(0, pthread_rwlock_rdlock(&l)); 686 ASSERT_EQ(0, pthread_rwlock_unlock(&l)); 687 688 // Multiple read lock 689 ASSERT_EQ(0, pthread_rwlock_rdlock(&l)); 690 ASSERT_EQ(0, pthread_rwlock_rdlock(&l)); 691 ASSERT_EQ(0, pthread_rwlock_unlock(&l)); 692 ASSERT_EQ(0, pthread_rwlock_unlock(&l)); 693 694 // Write lock 695 ASSERT_EQ(0, pthread_rwlock_wrlock(&l)); 696 ASSERT_EQ(0, pthread_rwlock_unlock(&l)); 697 698 // Try writer lock 699 ASSERT_EQ(0, pthread_rwlock_trywrlock(&l)); 700 ASSERT_EQ(EBUSY, pthread_rwlock_trywrlock(&l)); 701 ASSERT_EQ(EBUSY, pthread_rwlock_tryrdlock(&l)); 702 ASSERT_EQ(0, pthread_rwlock_unlock(&l)); 703 704 // Try reader lock 705 ASSERT_EQ(0, pthread_rwlock_tryrdlock(&l)); 706 ASSERT_EQ(0, pthread_rwlock_tryrdlock(&l)); 707 ASSERT_EQ(EBUSY, pthread_rwlock_trywrlock(&l)); 708 ASSERT_EQ(0, pthread_rwlock_unlock(&l)); 709 ASSERT_EQ(0, pthread_rwlock_unlock(&l)); 710 711 // Try writer lock after unlock 712 ASSERT_EQ(0, pthread_rwlock_wrlock(&l)); 713 ASSERT_EQ(0, pthread_rwlock_unlock(&l)); 714 715 // EDEADLK in "read after write" 716 ASSERT_EQ(0, pthread_rwlock_wrlock(&l)); 717 ASSERT_EQ(EDEADLK, pthread_rwlock_rdlock(&l)); 718 ASSERT_EQ(0, pthread_rwlock_unlock(&l)); 719 720 // EDEADLK in "write after write" 721 ASSERT_EQ(0, pthread_rwlock_wrlock(&l)); 722 ASSERT_EQ(EDEADLK, pthread_rwlock_wrlock(&l)); 723 ASSERT_EQ(0, pthread_rwlock_unlock(&l)); 724 725 ASSERT_EQ(0, pthread_rwlock_destroy(&l)); 726} 727 728static void WaitUntilThreadSleep(std::atomic<pid_t>& tid) { 729 while (tid == 0) { 730 usleep(1000); 731 } 732 std::string filename = android::base::StringPrintf("/proc/%d/stat", tid.load()); 733 std::regex regex {R"(\s+S\s+)"}; 734 735 while (true) { 736 std::string content; 737 ASSERT_TRUE(android::base::ReadFileToString(filename, &content)); 738 if (std::regex_search(content, regex)) { 739 break; 740 } 741 usleep(1000); 742 } 743} 744 745struct RwlockWakeupHelperArg { 746 pthread_rwlock_t lock; 747 enum Progress { 748 LOCK_INITIALIZED, 749 LOCK_WAITING, 750 LOCK_RELEASED, 751 LOCK_ACCESSED 752 }; 753 std::atomic<Progress> progress; 754 std::atomic<pid_t> tid; 755}; 756 757static void pthread_rwlock_reader_wakeup_writer_helper(RwlockWakeupHelperArg* arg) { 758 arg->tid = gettid(); 759 ASSERT_EQ(RwlockWakeupHelperArg::LOCK_INITIALIZED, arg->progress); 760 arg->progress = RwlockWakeupHelperArg::LOCK_WAITING; 761 762 ASSERT_EQ(EBUSY, pthread_rwlock_trywrlock(&arg->lock)); 763 ASSERT_EQ(0, pthread_rwlock_wrlock(&arg->lock)); 764 ASSERT_EQ(RwlockWakeupHelperArg::LOCK_RELEASED, arg->progress); 765 ASSERT_EQ(0, pthread_rwlock_unlock(&arg->lock)); 766 767 arg->progress = RwlockWakeupHelperArg::LOCK_ACCESSED; 768} 769 770TEST(pthread, pthread_rwlock_reader_wakeup_writer) { 771 RwlockWakeupHelperArg wakeup_arg; 772 ASSERT_EQ(0, pthread_rwlock_init(&wakeup_arg.lock, NULL)); 773 ASSERT_EQ(0, pthread_rwlock_rdlock(&wakeup_arg.lock)); 774 wakeup_arg.progress = RwlockWakeupHelperArg::LOCK_INITIALIZED; 775 wakeup_arg.tid = 0; 776 777 pthread_t thread; 778 ASSERT_EQ(0, pthread_create(&thread, NULL, 779 reinterpret_cast<void* (*)(void*)>(pthread_rwlock_reader_wakeup_writer_helper), &wakeup_arg)); 780 WaitUntilThreadSleep(wakeup_arg.tid); 781 ASSERT_EQ(RwlockWakeupHelperArg::LOCK_WAITING, wakeup_arg.progress); 782 783 wakeup_arg.progress = RwlockWakeupHelperArg::LOCK_RELEASED; 784 ASSERT_EQ(0, pthread_rwlock_unlock(&wakeup_arg.lock)); 785 786 ASSERT_EQ(0, pthread_join(thread, NULL)); 787 ASSERT_EQ(RwlockWakeupHelperArg::LOCK_ACCESSED, wakeup_arg.progress); 788 ASSERT_EQ(0, pthread_rwlock_destroy(&wakeup_arg.lock)); 789} 790 791static void pthread_rwlock_writer_wakeup_reader_helper(RwlockWakeupHelperArg* arg) { 792 arg->tid = gettid(); 793 ASSERT_EQ(RwlockWakeupHelperArg::LOCK_INITIALIZED, arg->progress); 794 arg->progress = RwlockWakeupHelperArg::LOCK_WAITING; 795 796 ASSERT_EQ(EBUSY, pthread_rwlock_tryrdlock(&arg->lock)); 797 ASSERT_EQ(0, pthread_rwlock_rdlock(&arg->lock)); 798 ASSERT_EQ(RwlockWakeupHelperArg::LOCK_RELEASED, arg->progress); 799 ASSERT_EQ(0, pthread_rwlock_unlock(&arg->lock)); 800 801 arg->progress = RwlockWakeupHelperArg::LOCK_ACCESSED; 802} 803 804TEST(pthread, pthread_rwlock_writer_wakeup_reader) { 805 RwlockWakeupHelperArg wakeup_arg; 806 ASSERT_EQ(0, pthread_rwlock_init(&wakeup_arg.lock, NULL)); 807 ASSERT_EQ(0, pthread_rwlock_wrlock(&wakeup_arg.lock)); 808 wakeup_arg.progress = RwlockWakeupHelperArg::LOCK_INITIALIZED; 809 wakeup_arg.tid = 0; 810 811 pthread_t thread; 812 ASSERT_EQ(0, pthread_create(&thread, NULL, 813 reinterpret_cast<void* (*)(void*)>(pthread_rwlock_writer_wakeup_reader_helper), &wakeup_arg)); 814 WaitUntilThreadSleep(wakeup_arg.tid); 815 ASSERT_EQ(RwlockWakeupHelperArg::LOCK_WAITING, wakeup_arg.progress); 816 817 wakeup_arg.progress = RwlockWakeupHelperArg::LOCK_RELEASED; 818 ASSERT_EQ(0, pthread_rwlock_unlock(&wakeup_arg.lock)); 819 820 ASSERT_EQ(0, pthread_join(thread, NULL)); 821 ASSERT_EQ(RwlockWakeupHelperArg::LOCK_ACCESSED, wakeup_arg.progress); 822 ASSERT_EQ(0, pthread_rwlock_destroy(&wakeup_arg.lock)); 823} 824 825class RwlockKindTestHelper { 826 private: 827 struct ThreadArg { 828 RwlockKindTestHelper* helper; 829 std::atomic<pid_t>& tid; 830 831 ThreadArg(RwlockKindTestHelper* helper, std::atomic<pid_t>& tid) 832 : helper(helper), tid(tid) { } 833 }; 834 835 public: 836 pthread_rwlock_t lock; 837 838 public: 839 RwlockKindTestHelper(int kind_type) { 840 InitRwlock(kind_type); 841 } 842 843 ~RwlockKindTestHelper() { 844 DestroyRwlock(); 845 } 846 847 void CreateWriterThread(pthread_t& thread, std::atomic<pid_t>& tid) { 848 tid = 0; 849 ThreadArg* arg = new ThreadArg(this, tid); 850 ASSERT_EQ(0, pthread_create(&thread, NULL, 851 reinterpret_cast<void* (*)(void*)>(WriterThreadFn), arg)); 852 } 853 854 void CreateReaderThread(pthread_t& thread, std::atomic<pid_t>& tid) { 855 tid = 0; 856 ThreadArg* arg = new ThreadArg(this, tid); 857 ASSERT_EQ(0, pthread_create(&thread, NULL, 858 reinterpret_cast<void* (*)(void*)>(ReaderThreadFn), arg)); 859 } 860 861 private: 862 void InitRwlock(int kind_type) { 863 pthread_rwlockattr_t attr; 864 ASSERT_EQ(0, pthread_rwlockattr_init(&attr)); 865 ASSERT_EQ(0, pthread_rwlockattr_setkind_np(&attr, kind_type)); 866 ASSERT_EQ(0, pthread_rwlock_init(&lock, &attr)); 867 ASSERT_EQ(0, pthread_rwlockattr_destroy(&attr)); 868 } 869 870 void DestroyRwlock() { 871 ASSERT_EQ(0, pthread_rwlock_destroy(&lock)); 872 } 873 874 static void WriterThreadFn(ThreadArg* arg) { 875 arg->tid = gettid(); 876 877 RwlockKindTestHelper* helper = arg->helper; 878 ASSERT_EQ(0, pthread_rwlock_wrlock(&helper->lock)); 879 ASSERT_EQ(0, pthread_rwlock_unlock(&helper->lock)); 880 delete arg; 881 } 882 883 static void ReaderThreadFn(ThreadArg* arg) { 884 arg->tid = gettid(); 885 886 RwlockKindTestHelper* helper = arg->helper; 887 ASSERT_EQ(0, pthread_rwlock_rdlock(&helper->lock)); 888 ASSERT_EQ(0, pthread_rwlock_unlock(&helper->lock)); 889 delete arg; 890 } 891}; 892 893TEST(pthread, pthread_rwlock_kind_PTHREAD_RWLOCK_PREFER_READER_NP) { 894 RwlockKindTestHelper helper(PTHREAD_RWLOCK_PREFER_READER_NP); 895 ASSERT_EQ(0, pthread_rwlock_rdlock(&helper.lock)); 896 897 pthread_t writer_thread; 898 std::atomic<pid_t> writer_tid; 899 helper.CreateWriterThread(writer_thread, writer_tid); 900 WaitUntilThreadSleep(writer_tid); 901 902 pthread_t reader_thread; 903 std::atomic<pid_t> reader_tid; 904 helper.CreateReaderThread(reader_thread, reader_tid); 905 ASSERT_EQ(0, pthread_join(reader_thread, NULL)); 906 907 ASSERT_EQ(0, pthread_rwlock_unlock(&helper.lock)); 908 ASSERT_EQ(0, pthread_join(writer_thread, NULL)); 909} 910 911TEST(pthread, pthread_rwlock_kind_PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP) { 912 RwlockKindTestHelper helper(PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP); 913 ASSERT_EQ(0, pthread_rwlock_rdlock(&helper.lock)); 914 915 pthread_t writer_thread; 916 std::atomic<pid_t> writer_tid; 917 helper.CreateWriterThread(writer_thread, writer_tid); 918 WaitUntilThreadSleep(writer_tid); 919 920 pthread_t reader_thread; 921 std::atomic<pid_t> reader_tid; 922 helper.CreateReaderThread(reader_thread, reader_tid); 923 WaitUntilThreadSleep(reader_tid); 924 925 ASSERT_EQ(0, pthread_rwlock_unlock(&helper.lock)); 926 ASSERT_EQ(0, pthread_join(writer_thread, NULL)); 927 ASSERT_EQ(0, pthread_join(reader_thread, NULL)); 928} 929 930static int g_once_fn_call_count = 0; 931static void OnceFn() { 932 ++g_once_fn_call_count; 933} 934 935TEST(pthread, pthread_once_smoke) { 936 pthread_once_t once_control = PTHREAD_ONCE_INIT; 937 ASSERT_EQ(0, pthread_once(&once_control, OnceFn)); 938 ASSERT_EQ(0, pthread_once(&once_control, OnceFn)); 939 ASSERT_EQ(1, g_once_fn_call_count); 940} 941 942static std::string pthread_once_1934122_result = ""; 943 944static void Routine2() { 945 pthread_once_1934122_result += "2"; 946} 947 948static void Routine1() { 949 pthread_once_t once_control_2 = PTHREAD_ONCE_INIT; 950 pthread_once_1934122_result += "1"; 951 pthread_once(&once_control_2, &Routine2); 952} 953 954TEST(pthread, pthread_once_1934122) { 955 // Very old versions of Android couldn't call pthread_once from a 956 // pthread_once init routine. http://b/1934122. 957 pthread_once_t once_control_1 = PTHREAD_ONCE_INIT; 958 ASSERT_EQ(0, pthread_once(&once_control_1, &Routine1)); 959 ASSERT_EQ("12", pthread_once_1934122_result); 960} 961 962static int g_atfork_prepare_calls = 0; 963static void AtForkPrepare1() { g_atfork_prepare_calls = (g_atfork_prepare_calls * 10) + 1; } 964static void AtForkPrepare2() { g_atfork_prepare_calls = (g_atfork_prepare_calls * 10) + 2; } 965static int g_atfork_parent_calls = 0; 966static void AtForkParent1() { g_atfork_parent_calls = (g_atfork_parent_calls * 10) + 1; } 967static void AtForkParent2() { g_atfork_parent_calls = (g_atfork_parent_calls * 10) + 2; } 968static int g_atfork_child_calls = 0; 969static void AtForkChild1() { g_atfork_child_calls = (g_atfork_child_calls * 10) + 1; } 970static void AtForkChild2() { g_atfork_child_calls = (g_atfork_child_calls * 10) + 2; } 971 972TEST(pthread, pthread_atfork_smoke) { 973 ASSERT_EQ(0, pthread_atfork(AtForkPrepare1, AtForkParent1, AtForkChild1)); 974 ASSERT_EQ(0, pthread_atfork(AtForkPrepare2, AtForkParent2, AtForkChild2)); 975 976 int pid = fork(); 977 ASSERT_NE(-1, pid) << strerror(errno); 978 979 // Child and parent calls are made in the order they were registered. 980 if (pid == 0) { 981 ASSERT_EQ(12, g_atfork_child_calls); 982 _exit(0); 983 } 984 ASSERT_EQ(12, g_atfork_parent_calls); 985 986 // Prepare calls are made in the reverse order. 987 ASSERT_EQ(21, g_atfork_prepare_calls); 988 int status; 989 ASSERT_EQ(pid, waitpid(pid, &status, 0)); 990} 991 992TEST(pthread, pthread_attr_getscope) { 993 pthread_attr_t attr; 994 ASSERT_EQ(0, pthread_attr_init(&attr)); 995 996 int scope; 997 ASSERT_EQ(0, pthread_attr_getscope(&attr, &scope)); 998 ASSERT_EQ(PTHREAD_SCOPE_SYSTEM, scope); 999} 1000 1001TEST(pthread, pthread_condattr_init) { 1002 pthread_condattr_t attr; 1003 pthread_condattr_init(&attr); 1004 1005 clockid_t clock; 1006 ASSERT_EQ(0, pthread_condattr_getclock(&attr, &clock)); 1007 ASSERT_EQ(CLOCK_REALTIME, clock); 1008 1009 int pshared; 1010 ASSERT_EQ(0, pthread_condattr_getpshared(&attr, &pshared)); 1011 ASSERT_EQ(PTHREAD_PROCESS_PRIVATE, pshared); 1012} 1013 1014TEST(pthread, pthread_condattr_setclock) { 1015 pthread_condattr_t attr; 1016 pthread_condattr_init(&attr); 1017 1018 ASSERT_EQ(0, pthread_condattr_setclock(&attr, CLOCK_REALTIME)); 1019 clockid_t clock; 1020 ASSERT_EQ(0, pthread_condattr_getclock(&attr, &clock)); 1021 ASSERT_EQ(CLOCK_REALTIME, clock); 1022 1023 ASSERT_EQ(0, pthread_condattr_setclock(&attr, CLOCK_MONOTONIC)); 1024 ASSERT_EQ(0, pthread_condattr_getclock(&attr, &clock)); 1025 ASSERT_EQ(CLOCK_MONOTONIC, clock); 1026 1027 ASSERT_EQ(EINVAL, pthread_condattr_setclock(&attr, CLOCK_PROCESS_CPUTIME_ID)); 1028} 1029 1030TEST(pthread, pthread_cond_broadcast__preserves_condattr_flags) { 1031#if defined(__BIONIC__) 1032 pthread_condattr_t attr; 1033 pthread_condattr_init(&attr); 1034 1035 ASSERT_EQ(0, pthread_condattr_setclock(&attr, CLOCK_MONOTONIC)); 1036 ASSERT_EQ(0, pthread_condattr_setpshared(&attr, PTHREAD_PROCESS_SHARED)); 1037 1038 pthread_cond_t cond_var; 1039 ASSERT_EQ(0, pthread_cond_init(&cond_var, &attr)); 1040 1041 ASSERT_EQ(0, pthread_cond_signal(&cond_var)); 1042 ASSERT_EQ(0, pthread_cond_broadcast(&cond_var)); 1043 1044 attr = static_cast<pthread_condattr_t>(*reinterpret_cast<uint32_t*>(cond_var.__private)); 1045 clockid_t clock; 1046 ASSERT_EQ(0, pthread_condattr_getclock(&attr, &clock)); 1047 ASSERT_EQ(CLOCK_MONOTONIC, clock); 1048 int pshared; 1049 ASSERT_EQ(0, pthread_condattr_getpshared(&attr, &pshared)); 1050 ASSERT_EQ(PTHREAD_PROCESS_SHARED, pshared); 1051#else // !defined(__BIONIC__) 1052 GTEST_LOG_(INFO) << "This tests a bionic implementation detail.\n"; 1053#endif // !defined(__BIONIC__) 1054} 1055 1056class pthread_CondWakeupTest : public ::testing::Test { 1057 protected: 1058 pthread_mutex_t mutex; 1059 pthread_cond_t cond; 1060 1061 enum Progress { 1062 INITIALIZED, 1063 WAITING, 1064 SIGNALED, 1065 FINISHED, 1066 }; 1067 std::atomic<Progress> progress; 1068 pthread_t thread; 1069 1070 protected: 1071 virtual void SetUp() { 1072 ASSERT_EQ(0, pthread_mutex_init(&mutex, NULL)); 1073 ASSERT_EQ(0, pthread_cond_init(&cond, NULL)); 1074 progress = INITIALIZED; 1075 ASSERT_EQ(0, 1076 pthread_create(&thread, NULL, reinterpret_cast<void* (*)(void*)>(WaitThreadFn), this)); 1077 } 1078 1079 virtual void TearDown() { 1080 ASSERT_EQ(0, pthread_join(thread, NULL)); 1081 ASSERT_EQ(FINISHED, progress); 1082 ASSERT_EQ(0, pthread_cond_destroy(&cond)); 1083 ASSERT_EQ(0, pthread_mutex_destroy(&mutex)); 1084 } 1085 1086 void SleepUntilProgress(Progress expected_progress) { 1087 while (progress != expected_progress) { 1088 usleep(5000); 1089 } 1090 usleep(5000); 1091 } 1092 1093 private: 1094 static void WaitThreadFn(pthread_CondWakeupTest* test) { 1095 ASSERT_EQ(0, pthread_mutex_lock(&test->mutex)); 1096 test->progress = WAITING; 1097 while (test->progress == WAITING) { 1098 ASSERT_EQ(0, pthread_cond_wait(&test->cond, &test->mutex)); 1099 } 1100 ASSERT_EQ(SIGNALED, test->progress); 1101 test->progress = FINISHED; 1102 ASSERT_EQ(0, pthread_mutex_unlock(&test->mutex)); 1103 } 1104}; 1105 1106TEST_F(pthread_CondWakeupTest, signal) { 1107 SleepUntilProgress(WAITING); 1108 progress = SIGNALED; 1109 pthread_cond_signal(&cond); 1110} 1111 1112TEST_F(pthread_CondWakeupTest, broadcast) { 1113 SleepUntilProgress(WAITING); 1114 progress = SIGNALED; 1115 pthread_cond_broadcast(&cond); 1116} 1117 1118TEST(pthread, pthread_mutex_timedlock) { 1119 pthread_mutex_t m; 1120 ASSERT_EQ(0, pthread_mutex_init(&m, NULL)); 1121 1122 // If the mutex is already locked, pthread_mutex_timedlock should time out. 1123 ASSERT_EQ(0, pthread_mutex_lock(&m)); 1124 1125 timespec ts; 1126 ASSERT_EQ(0, clock_gettime(CLOCK_REALTIME, &ts)); 1127 ts.tv_nsec += 1; 1128 ASSERT_EQ(ETIMEDOUT, pthread_mutex_timedlock(&m, &ts)); 1129 1130 // If the mutex is unlocked, pthread_mutex_timedlock should succeed. 1131 ASSERT_EQ(0, pthread_mutex_unlock(&m)); 1132 1133 ASSERT_EQ(0, clock_gettime(CLOCK_REALTIME, &ts)); 1134 ts.tv_nsec += 1; 1135 ASSERT_EQ(0, pthread_mutex_timedlock(&m, &ts)); 1136 1137 ASSERT_EQ(0, pthread_mutex_unlock(&m)); 1138 ASSERT_EQ(0, pthread_mutex_destroy(&m)); 1139} 1140 1141TEST(pthread, pthread_attr_getstack__main_thread) { 1142 // This test is only meaningful for the main thread, so make sure we're running on it! 1143 ASSERT_EQ(getpid(), syscall(__NR_gettid)); 1144 1145 // Get the main thread's attributes. 1146 pthread_attr_t attributes; 1147 ASSERT_EQ(0, pthread_getattr_np(pthread_self(), &attributes)); 1148 1149 // Check that we correctly report that the main thread has no guard page. 1150 size_t guard_size; 1151 ASSERT_EQ(0, pthread_attr_getguardsize(&attributes, &guard_size)); 1152 ASSERT_EQ(0U, guard_size); // The main thread has no guard page. 1153 1154 // Get the stack base and the stack size (both ways). 1155 void* stack_base; 1156 size_t stack_size; 1157 ASSERT_EQ(0, pthread_attr_getstack(&attributes, &stack_base, &stack_size)); 1158 size_t stack_size2; 1159 ASSERT_EQ(0, pthread_attr_getstacksize(&attributes, &stack_size2)); 1160 1161 // The two methods of asking for the stack size should agree. 1162 EXPECT_EQ(stack_size, stack_size2); 1163 1164#if defined(__BIONIC__) 1165 // What does /proc/self/maps' [stack] line say? 1166 void* maps_stack_hi = NULL; 1167 std::vector<map_record> maps; 1168 ASSERT_TRUE(Maps::parse_maps(&maps)); 1169 for (const auto& map : maps) { 1170 if (map.pathname == "[stack]") { 1171 maps_stack_hi = reinterpret_cast<void*>(map.addr_end); 1172 break; 1173 } 1174 } 1175 1176 // The high address of the /proc/self/maps [stack] region should equal stack_base + stack_size. 1177 // Remember that the stack grows down (and is mapped in on demand), so the low address of the 1178 // region isn't very interesting. 1179 EXPECT_EQ(maps_stack_hi, reinterpret_cast<uint8_t*>(stack_base) + stack_size); 1180 1181 // The stack size should correspond to RLIMIT_STACK. 1182 rlimit rl; 1183 ASSERT_EQ(0, getrlimit(RLIMIT_STACK, &rl)); 1184 uint64_t original_rlim_cur = rl.rlim_cur; 1185 if (rl.rlim_cur == RLIM_INFINITY) { 1186 rl.rlim_cur = 8 * 1024 * 1024; // Bionic reports unlimited stacks as 8MiB. 1187 } 1188 EXPECT_EQ(rl.rlim_cur, stack_size); 1189 1190 auto guard = make_scope_guard([&rl, original_rlim_cur]() { 1191 rl.rlim_cur = original_rlim_cur; 1192 ASSERT_EQ(0, setrlimit(RLIMIT_STACK, &rl)); 1193 }); 1194 1195 // 1196 // What if RLIMIT_STACK is smaller than the stack's current extent? 1197 // 1198 rl.rlim_cur = rl.rlim_max = 1024; // 1KiB. We know the stack must be at least a page already. 1199 rl.rlim_max = RLIM_INFINITY; 1200 ASSERT_EQ(0, setrlimit(RLIMIT_STACK, &rl)); 1201 1202 ASSERT_EQ(0, pthread_getattr_np(pthread_self(), &attributes)); 1203 ASSERT_EQ(0, pthread_attr_getstack(&attributes, &stack_base, &stack_size)); 1204 ASSERT_EQ(0, pthread_attr_getstacksize(&attributes, &stack_size2)); 1205 1206 EXPECT_EQ(stack_size, stack_size2); 1207 ASSERT_EQ(1024U, stack_size); 1208 1209 // 1210 // What if RLIMIT_STACK isn't a whole number of pages? 1211 // 1212 rl.rlim_cur = rl.rlim_max = 6666; // Not a whole number of pages. 1213 rl.rlim_max = RLIM_INFINITY; 1214 ASSERT_EQ(0, setrlimit(RLIMIT_STACK, &rl)); 1215 1216 ASSERT_EQ(0, pthread_getattr_np(pthread_self(), &attributes)); 1217 ASSERT_EQ(0, pthread_attr_getstack(&attributes, &stack_base, &stack_size)); 1218 ASSERT_EQ(0, pthread_attr_getstacksize(&attributes, &stack_size2)); 1219 1220 EXPECT_EQ(stack_size, stack_size2); 1221 ASSERT_EQ(6666U, stack_size); 1222#endif 1223} 1224 1225struct GetStackSignalHandlerArg { 1226 volatile bool done; 1227 void* signal_handler_sp; 1228 void* main_stack_base; 1229 size_t main_stack_size; 1230}; 1231 1232static GetStackSignalHandlerArg getstack_signal_handler_arg; 1233 1234static void getstack_signal_handler(int sig) { 1235 ASSERT_EQ(SIGUSR1, sig); 1236 // Use sleep() to make current thread be switched out by the kernel to provoke the error. 1237 sleep(1); 1238 pthread_attr_t attr; 1239 ASSERT_EQ(0, pthread_getattr_np(pthread_self(), &attr)); 1240 void* stack_base; 1241 size_t stack_size; 1242 ASSERT_EQ(0, pthread_attr_getstack(&attr, &stack_base, &stack_size)); 1243 getstack_signal_handler_arg.signal_handler_sp = &attr; 1244 getstack_signal_handler_arg.main_stack_base = stack_base; 1245 getstack_signal_handler_arg.main_stack_size = stack_size; 1246 getstack_signal_handler_arg.done = true; 1247} 1248 1249// The previous code obtained the main thread's stack by reading the entry in 1250// /proc/self/task/<pid>/maps that was labeled [stack]. Unfortunately, on x86/x86_64, the kernel 1251// relies on sp0 in task state segment(tss) to label the stack map with [stack]. If the kernel 1252// switches a process while the main thread is in an alternate stack, then the kernel will label 1253// the wrong map with [stack]. This test verifies that when the above situation happens, the main 1254// thread's stack is found correctly. 1255TEST(pthread, pthread_attr_getstack_in_signal_handler) { 1256 const size_t sig_stack_size = 16 * 1024; 1257 void* sig_stack = mmap(NULL, sig_stack_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, 1258 -1, 0); 1259 ASSERT_NE(MAP_FAILED, sig_stack); 1260 stack_t ss; 1261 ss.ss_sp = sig_stack; 1262 ss.ss_size = sig_stack_size; 1263 ss.ss_flags = 0; 1264 stack_t oss; 1265 ASSERT_EQ(0, sigaltstack(&ss, &oss)); 1266 1267 ScopedSignalHandler handler(SIGUSR1, getstack_signal_handler, SA_ONSTACK); 1268 getstack_signal_handler_arg.done = false; 1269 kill(getpid(), SIGUSR1); 1270 ASSERT_EQ(true, getstack_signal_handler_arg.done); 1271 1272 // Verify if the stack used by the signal handler is the alternate stack just registered. 1273 ASSERT_LE(sig_stack, getstack_signal_handler_arg.signal_handler_sp); 1274 ASSERT_GE(reinterpret_cast<char*>(sig_stack) + sig_stack_size, 1275 getstack_signal_handler_arg.signal_handler_sp); 1276 1277 // Verify if the main thread's stack got in the signal handler is correct. 1278 ASSERT_LE(getstack_signal_handler_arg.main_stack_base, &ss); 1279 ASSERT_GE(reinterpret_cast<char*>(getstack_signal_handler_arg.main_stack_base) + 1280 getstack_signal_handler_arg.main_stack_size, reinterpret_cast<void*>(&ss)); 1281 1282 ASSERT_EQ(0, sigaltstack(&oss, nullptr)); 1283 ASSERT_EQ(0, munmap(sig_stack, sig_stack_size)); 1284} 1285 1286static void pthread_attr_getstack_18908062_helper(void*) { 1287 char local_variable; 1288 pthread_attr_t attributes; 1289 pthread_getattr_np(pthread_self(), &attributes); 1290 void* stack_base; 1291 size_t stack_size; 1292 pthread_attr_getstack(&attributes, &stack_base, &stack_size); 1293 1294 // Test whether &local_variable is in [stack_base, stack_base + stack_size). 1295 ASSERT_LE(reinterpret_cast<char*>(stack_base), &local_variable); 1296 ASSERT_LT(&local_variable, reinterpret_cast<char*>(stack_base) + stack_size); 1297} 1298 1299// Check whether something on stack is in the range of 1300// [stack_base, stack_base + stack_size). see b/18908062. 1301TEST(pthread, pthread_attr_getstack_18908062) { 1302 pthread_t t; 1303 ASSERT_EQ(0, pthread_create(&t, NULL, 1304 reinterpret_cast<void* (*)(void*)>(pthread_attr_getstack_18908062_helper), 1305 NULL)); 1306 pthread_join(t, NULL); 1307} 1308 1309#if defined(__BIONIC__) 1310static pthread_mutex_t pthread_gettid_np_mutex = PTHREAD_MUTEX_INITIALIZER; 1311 1312static void* pthread_gettid_np_helper(void* arg) { 1313 *reinterpret_cast<pid_t*>(arg) = gettid(); 1314 1315 // Wait for our parent to call pthread_gettid_np on us before exiting. 1316 pthread_mutex_lock(&pthread_gettid_np_mutex); 1317 pthread_mutex_unlock(&pthread_gettid_np_mutex); 1318 return NULL; 1319} 1320#endif 1321 1322TEST(pthread, pthread_gettid_np) { 1323#if defined(__BIONIC__) 1324 ASSERT_EQ(gettid(), pthread_gettid_np(pthread_self())); 1325 1326 // Ensure the other thread doesn't exit until after we've called 1327 // pthread_gettid_np on it. 1328 pthread_mutex_lock(&pthread_gettid_np_mutex); 1329 1330 pid_t t_gettid_result; 1331 pthread_t t; 1332 pthread_create(&t, NULL, pthread_gettid_np_helper, &t_gettid_result); 1333 1334 pid_t t_pthread_gettid_np_result = pthread_gettid_np(t); 1335 1336 // Release the other thread and wait for it to exit. 1337 pthread_mutex_unlock(&pthread_gettid_np_mutex); 1338 pthread_join(t, NULL); 1339 1340 ASSERT_EQ(t_gettid_result, t_pthread_gettid_np_result); 1341#else 1342 GTEST_LOG_(INFO) << "This test does nothing.\n"; 1343#endif 1344} 1345 1346static size_t cleanup_counter = 0; 1347 1348static void AbortCleanupRoutine(void*) { 1349 abort(); 1350} 1351 1352static void CountCleanupRoutine(void*) { 1353 ++cleanup_counter; 1354} 1355 1356static void PthreadCleanupTester() { 1357 pthread_cleanup_push(CountCleanupRoutine, NULL); 1358 pthread_cleanup_push(CountCleanupRoutine, NULL); 1359 pthread_cleanup_push(AbortCleanupRoutine, NULL); 1360 1361 pthread_cleanup_pop(0); // Pop the abort without executing it. 1362 pthread_cleanup_pop(1); // Pop one count while executing it. 1363 ASSERT_EQ(1U, cleanup_counter); 1364 // Exit while the other count is still on the cleanup stack. 1365 pthread_exit(NULL); 1366 1367 // Calls to pthread_cleanup_pop/pthread_cleanup_push must always be balanced. 1368 pthread_cleanup_pop(0); 1369} 1370 1371static void* PthreadCleanupStartRoutine(void*) { 1372 PthreadCleanupTester(); 1373 return NULL; 1374} 1375 1376TEST(pthread, pthread_cleanup_push__pthread_cleanup_pop) { 1377 pthread_t t; 1378 ASSERT_EQ(0, pthread_create(&t, NULL, PthreadCleanupStartRoutine, NULL)); 1379 pthread_join(t, NULL); 1380 ASSERT_EQ(2U, cleanup_counter); 1381} 1382 1383TEST(pthread, PTHREAD_MUTEX_DEFAULT_is_PTHREAD_MUTEX_NORMAL) { 1384 ASSERT_EQ(PTHREAD_MUTEX_NORMAL, PTHREAD_MUTEX_DEFAULT); 1385} 1386 1387TEST(pthread, pthread_mutexattr_gettype) { 1388 pthread_mutexattr_t attr; 1389 ASSERT_EQ(0, pthread_mutexattr_init(&attr)); 1390 1391 int attr_type; 1392 1393 ASSERT_EQ(0, pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL)); 1394 ASSERT_EQ(0, pthread_mutexattr_gettype(&attr, &attr_type)); 1395 ASSERT_EQ(PTHREAD_MUTEX_NORMAL, attr_type); 1396 1397 ASSERT_EQ(0, pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK)); 1398 ASSERT_EQ(0, pthread_mutexattr_gettype(&attr, &attr_type)); 1399 ASSERT_EQ(PTHREAD_MUTEX_ERRORCHECK, attr_type); 1400 1401 ASSERT_EQ(0, pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE)); 1402 ASSERT_EQ(0, pthread_mutexattr_gettype(&attr, &attr_type)); 1403 ASSERT_EQ(PTHREAD_MUTEX_RECURSIVE, attr_type); 1404 1405 ASSERT_EQ(0, pthread_mutexattr_destroy(&attr)); 1406} 1407 1408struct PthreadMutex { 1409 pthread_mutex_t lock; 1410 1411 PthreadMutex(int mutex_type) { 1412 init(mutex_type); 1413 } 1414 1415 ~PthreadMutex() { 1416 destroy(); 1417 } 1418 1419 private: 1420 void init(int mutex_type) { 1421 pthread_mutexattr_t attr; 1422 ASSERT_EQ(0, pthread_mutexattr_init(&attr)); 1423 ASSERT_EQ(0, pthread_mutexattr_settype(&attr, mutex_type)); 1424 ASSERT_EQ(0, pthread_mutex_init(&lock, &attr)); 1425 ASSERT_EQ(0, pthread_mutexattr_destroy(&attr)); 1426 } 1427 1428 void destroy() { 1429 ASSERT_EQ(0, pthread_mutex_destroy(&lock)); 1430 } 1431 1432 DISALLOW_COPY_AND_ASSIGN(PthreadMutex); 1433}; 1434 1435TEST(pthread, pthread_mutex_lock_NORMAL) { 1436 PthreadMutex m(PTHREAD_MUTEX_NORMAL); 1437 1438 ASSERT_EQ(0, pthread_mutex_lock(&m.lock)); 1439 ASSERT_EQ(0, pthread_mutex_unlock(&m.lock)); 1440} 1441 1442TEST(pthread, pthread_mutex_lock_ERRORCHECK) { 1443 PthreadMutex m(PTHREAD_MUTEX_ERRORCHECK); 1444 1445 ASSERT_EQ(0, pthread_mutex_lock(&m.lock)); 1446 ASSERT_EQ(EDEADLK, pthread_mutex_lock(&m.lock)); 1447 ASSERT_EQ(0, pthread_mutex_unlock(&m.lock)); 1448 ASSERT_EQ(0, pthread_mutex_trylock(&m.lock)); 1449 ASSERT_EQ(EBUSY, pthread_mutex_trylock(&m.lock)); 1450 ASSERT_EQ(0, pthread_mutex_unlock(&m.lock)); 1451 ASSERT_EQ(EPERM, pthread_mutex_unlock(&m.lock)); 1452} 1453 1454TEST(pthread, pthread_mutex_lock_RECURSIVE) { 1455 PthreadMutex m(PTHREAD_MUTEX_RECURSIVE); 1456 1457 ASSERT_EQ(0, pthread_mutex_lock(&m.lock)); 1458 ASSERT_EQ(0, pthread_mutex_lock(&m.lock)); 1459 ASSERT_EQ(0, pthread_mutex_unlock(&m.lock)); 1460 ASSERT_EQ(0, pthread_mutex_unlock(&m.lock)); 1461 ASSERT_EQ(0, pthread_mutex_trylock(&m.lock)); 1462 ASSERT_EQ(0, pthread_mutex_unlock(&m.lock)); 1463 ASSERT_EQ(EPERM, pthread_mutex_unlock(&m.lock)); 1464} 1465 1466TEST(pthread, pthread_mutex_init_same_as_static_initializers) { 1467 pthread_mutex_t lock_normal = PTHREAD_MUTEX_INITIALIZER; 1468 PthreadMutex m1(PTHREAD_MUTEX_NORMAL); 1469 ASSERT_EQ(0, memcmp(&lock_normal, &m1.lock, sizeof(pthread_mutex_t))); 1470 pthread_mutex_destroy(&lock_normal); 1471 1472 pthread_mutex_t lock_errorcheck = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP; 1473 PthreadMutex m2(PTHREAD_MUTEX_ERRORCHECK); 1474 ASSERT_EQ(0, memcmp(&lock_errorcheck, &m2.lock, sizeof(pthread_mutex_t))); 1475 pthread_mutex_destroy(&lock_errorcheck); 1476 1477 pthread_mutex_t lock_recursive = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP; 1478 PthreadMutex m3(PTHREAD_MUTEX_RECURSIVE); 1479 ASSERT_EQ(0, memcmp(&lock_recursive, &m3.lock, sizeof(pthread_mutex_t))); 1480 ASSERT_EQ(0, pthread_mutex_destroy(&lock_recursive)); 1481} 1482class MutexWakeupHelper { 1483 private: 1484 PthreadMutex m; 1485 enum Progress { 1486 LOCK_INITIALIZED, 1487 LOCK_WAITING, 1488 LOCK_RELEASED, 1489 LOCK_ACCESSED 1490 }; 1491 std::atomic<Progress> progress; 1492 std::atomic<pid_t> tid; 1493 1494 static void thread_fn(MutexWakeupHelper* helper) { 1495 helper->tid = gettid(); 1496 ASSERT_EQ(LOCK_INITIALIZED, helper->progress); 1497 helper->progress = LOCK_WAITING; 1498 1499 ASSERT_EQ(0, pthread_mutex_lock(&helper->m.lock)); 1500 ASSERT_EQ(LOCK_RELEASED, helper->progress); 1501 ASSERT_EQ(0, pthread_mutex_unlock(&helper->m.lock)); 1502 1503 helper->progress = LOCK_ACCESSED; 1504 } 1505 1506 public: 1507 MutexWakeupHelper(int mutex_type) : m(mutex_type) { 1508 } 1509 1510 void test() { 1511 ASSERT_EQ(0, pthread_mutex_lock(&m.lock)); 1512 progress = LOCK_INITIALIZED; 1513 tid = 0; 1514 1515 pthread_t thread; 1516 ASSERT_EQ(0, pthread_create(&thread, NULL, 1517 reinterpret_cast<void* (*)(void*)>(MutexWakeupHelper::thread_fn), this)); 1518 1519 WaitUntilThreadSleep(tid); 1520 ASSERT_EQ(LOCK_WAITING, progress); 1521 1522 progress = LOCK_RELEASED; 1523 ASSERT_EQ(0, pthread_mutex_unlock(&m.lock)); 1524 1525 ASSERT_EQ(0, pthread_join(thread, NULL)); 1526 ASSERT_EQ(LOCK_ACCESSED, progress); 1527 } 1528}; 1529 1530TEST(pthread, pthread_mutex_NORMAL_wakeup) { 1531 MutexWakeupHelper helper(PTHREAD_MUTEX_NORMAL); 1532 helper.test(); 1533} 1534 1535TEST(pthread, pthread_mutex_ERRORCHECK_wakeup) { 1536 MutexWakeupHelper helper(PTHREAD_MUTEX_ERRORCHECK); 1537 helper.test(); 1538} 1539 1540TEST(pthread, pthread_mutex_RECURSIVE_wakeup) { 1541 MutexWakeupHelper helper(PTHREAD_MUTEX_RECURSIVE); 1542 helper.test(); 1543} 1544 1545TEST(pthread, pthread_mutex_owner_tid_limit) { 1546#if defined(__BIONIC__) && !defined(__LP64__) 1547 FILE* fp = fopen("/proc/sys/kernel/pid_max", "r"); 1548 ASSERT_TRUE(fp != NULL); 1549 long pid_max; 1550 ASSERT_EQ(1, fscanf(fp, "%ld", &pid_max)); 1551 fclose(fp); 1552 // Bionic's pthread_mutex implementation on 32-bit devices uses 16 bits to represent owner tid. 1553 ASSERT_LE(pid_max, 65536); 1554#else 1555 GTEST_LOG_(INFO) << "This test does nothing as 32-bit tid is supported by pthread_mutex.\n"; 1556#endif 1557} 1558 1559class StrictAlignmentAllocator { 1560 public: 1561 void* allocate(size_t size, size_t alignment) { 1562 char* p = new char[size + alignment * 2]; 1563 allocated_array.push_back(p); 1564 while (!is_strict_aligned(p, alignment)) { 1565 ++p; 1566 } 1567 return p; 1568 } 1569 1570 ~StrictAlignmentAllocator() { 1571 for (const auto& p : allocated_array) { 1572 delete[] p; 1573 } 1574 } 1575 1576 private: 1577 bool is_strict_aligned(char* p, size_t alignment) { 1578 return (reinterpret_cast<uintptr_t>(p) % (alignment * 2)) == alignment; 1579 } 1580 1581 std::vector<char*> allocated_array; 1582}; 1583 1584TEST(pthread, pthread_types_allow_four_bytes_alignment) { 1585#if defined(__BIONIC__) 1586 // For binary compatibility with old version, we need to allow 4-byte aligned data for pthread types. 1587 StrictAlignmentAllocator allocator; 1588 pthread_mutex_t* mutex = reinterpret_cast<pthread_mutex_t*>( 1589 allocator.allocate(sizeof(pthread_mutex_t), 4)); 1590 ASSERT_EQ(0, pthread_mutex_init(mutex, NULL)); 1591 ASSERT_EQ(0, pthread_mutex_lock(mutex)); 1592 ASSERT_EQ(0, pthread_mutex_unlock(mutex)); 1593 ASSERT_EQ(0, pthread_mutex_destroy(mutex)); 1594 1595 pthread_cond_t* cond = reinterpret_cast<pthread_cond_t*>( 1596 allocator.allocate(sizeof(pthread_cond_t), 4)); 1597 ASSERT_EQ(0, pthread_cond_init(cond, NULL)); 1598 ASSERT_EQ(0, pthread_cond_signal(cond)); 1599 ASSERT_EQ(0, pthread_cond_broadcast(cond)); 1600 ASSERT_EQ(0, pthread_cond_destroy(cond)); 1601 1602 pthread_rwlock_t* rwlock = reinterpret_cast<pthread_rwlock_t*>( 1603 allocator.allocate(sizeof(pthread_rwlock_t), 4)); 1604 ASSERT_EQ(0, pthread_rwlock_init(rwlock, NULL)); 1605 ASSERT_EQ(0, pthread_rwlock_rdlock(rwlock)); 1606 ASSERT_EQ(0, pthread_rwlock_unlock(rwlock)); 1607 ASSERT_EQ(0, pthread_rwlock_wrlock(rwlock)); 1608 ASSERT_EQ(0, pthread_rwlock_unlock(rwlock)); 1609 ASSERT_EQ(0, pthread_rwlock_destroy(rwlock)); 1610 1611#else 1612 GTEST_LOG_(INFO) << "This test tests bionic implementation details."; 1613#endif 1614} 1615 1616TEST(pthread, pthread_mutex_lock_null_32) { 1617#if defined(__BIONIC__) && !defined(__LP64__) 1618 ASSERT_EQ(EINVAL, pthread_mutex_lock(NULL)); 1619#else 1620 GTEST_LOG_(INFO) << "This test tests bionic implementation details on 32 bit devices."; 1621#endif 1622} 1623 1624TEST(pthread, pthread_mutex_unlock_null_32) { 1625#if defined(__BIONIC__) && !defined(__LP64__) 1626 ASSERT_EQ(EINVAL, pthread_mutex_unlock(NULL)); 1627#else 1628 GTEST_LOG_(INFO) << "This test tests bionic implementation details on 32 bit devices."; 1629#endif 1630} 1631 1632TEST_F(pthread_DeathTest, pthread_mutex_lock_null_64) { 1633#if defined(__BIONIC__) && defined(__LP64__) 1634 pthread_mutex_t* null_value = nullptr; 1635 ASSERT_EXIT(pthread_mutex_lock(null_value), testing::KilledBySignal(SIGSEGV), ""); 1636#else 1637 GTEST_LOG_(INFO) << "This test tests bionic implementation details on 64 bit devices."; 1638#endif 1639} 1640 1641TEST_F(pthread_DeathTest, pthread_mutex_unlock_null_64) { 1642#if defined(__BIONIC__) && defined(__LP64__) 1643 pthread_mutex_t* null_value = nullptr; 1644 ASSERT_EXIT(pthread_mutex_unlock(null_value), testing::KilledBySignal(SIGSEGV), ""); 1645#else 1646 GTEST_LOG_(INFO) << "This test tests bionic implementation details on 64 bit devices."; 1647#endif 1648} 1649 1650extern _Unwind_Reason_Code FrameCounter(_Unwind_Context* ctx, void* arg); 1651 1652static volatile bool signal_handler_on_altstack_done; 1653 1654static void SignalHandlerOnAltStack(int signo, siginfo_t*, void*) { 1655 ASSERT_EQ(SIGUSR1, signo); 1656 // Check if we have enough stack space for unwinding. 1657 int count = 0; 1658 _Unwind_Backtrace(FrameCounter, &count); 1659 ASSERT_GT(count, 0); 1660 // Check if we have enough stack space for logging. 1661 std::string s(2048, '*'); 1662 GTEST_LOG_(INFO) << s; 1663 signal_handler_on_altstack_done = true; 1664} 1665 1666TEST(pthread, big_enough_signal_stack_for_64bit_arch) { 1667 signal_handler_on_altstack_done = false; 1668 ScopedSignalHandler handler(SIGUSR1, SignalHandlerOnAltStack, SA_SIGINFO | SA_ONSTACK); 1669 kill(getpid(), SIGUSR1); 1670 ASSERT_TRUE(signal_handler_on_altstack_done); 1671} 1672 1673TEST(pthread, pthread_barrierattr_smoke) { 1674 pthread_barrierattr_t attr; 1675 ASSERT_EQ(0, pthread_barrierattr_init(&attr)); 1676 int pshared; 1677 ASSERT_EQ(0, pthread_barrierattr_getpshared(&attr, &pshared)); 1678 ASSERT_EQ(PTHREAD_PROCESS_PRIVATE, pshared); 1679 ASSERT_EQ(0, pthread_barrierattr_setpshared(&attr, PTHREAD_PROCESS_SHARED)); 1680 ASSERT_EQ(0, pthread_barrierattr_getpshared(&attr, &pshared)); 1681 ASSERT_EQ(PTHREAD_PROCESS_SHARED, pshared); 1682 ASSERT_EQ(0, pthread_barrierattr_destroy(&attr)); 1683} 1684 1685struct BarrierTestHelperArg { 1686 std::atomic<pid_t> tid; 1687 pthread_barrier_t* barrier; 1688 size_t iteration_count; 1689}; 1690 1691static void BarrierTestHelper(BarrierTestHelperArg* arg) { 1692 arg->tid = gettid(); 1693 for (size_t i = 0; i < arg->iteration_count; ++i) { 1694 ASSERT_EQ(0, pthread_barrier_wait(arg->barrier)); 1695 } 1696} 1697 1698TEST(pthread, pthread_barrier_smoke) { 1699 const size_t BARRIER_ITERATION_COUNT = 10; 1700 const size_t BARRIER_THREAD_COUNT = 10; 1701 pthread_barrier_t barrier; 1702 ASSERT_EQ(0, pthread_barrier_init(&barrier, nullptr, BARRIER_THREAD_COUNT + 1)); 1703 std::vector<pthread_t> threads(BARRIER_THREAD_COUNT); 1704 std::vector<BarrierTestHelperArg> args(threads.size()); 1705 for (size_t i = 0; i < threads.size(); ++i) { 1706 args[i].tid = 0; 1707 args[i].barrier = &barrier; 1708 args[i].iteration_count = BARRIER_ITERATION_COUNT; 1709 ASSERT_EQ(0, pthread_create(&threads[i], nullptr, 1710 reinterpret_cast<void* (*)(void*)>(BarrierTestHelper), &args[i])); 1711 } 1712 for (size_t iteration = 0; iteration < BARRIER_ITERATION_COUNT; ++iteration) { 1713 for (size_t i = 0; i < threads.size(); ++i) { 1714 WaitUntilThreadSleep(args[i].tid); 1715 } 1716 ASSERT_EQ(PTHREAD_BARRIER_SERIAL_THREAD, pthread_barrier_wait(&barrier)); 1717 } 1718 for (size_t i = 0; i < threads.size(); ++i) { 1719 ASSERT_EQ(0, pthread_join(threads[i], nullptr)); 1720 } 1721 ASSERT_EQ(0, pthread_barrier_destroy(&barrier)); 1722} 1723 1724TEST(pthread, pthread_barrier_destroy) { 1725 pthread_barrier_t barrier; 1726 ASSERT_EQ(0, pthread_barrier_init(&barrier, nullptr, 2)); 1727 pthread_t thread; 1728 BarrierTestHelperArg arg; 1729 arg.tid = 0; 1730 arg.barrier = &barrier; 1731 arg.iteration_count = 1; 1732 ASSERT_EQ(0, pthread_create(&thread, nullptr, 1733 reinterpret_cast<void* (*)(void*)>(BarrierTestHelper), &arg)); 1734 WaitUntilThreadSleep(arg.tid); 1735 ASSERT_EQ(EBUSY, pthread_barrier_destroy(&barrier)); 1736 ASSERT_EQ(PTHREAD_BARRIER_SERIAL_THREAD, pthread_barrier_wait(&barrier)); 1737 // Verify if the barrier can be destroyed directly after pthread_barrier_wait(). 1738 ASSERT_EQ(0, pthread_barrier_destroy(&barrier)); 1739 ASSERT_EQ(0, pthread_join(thread, nullptr)); 1740#if defined(__BIONIC__) 1741 ASSERT_EQ(EINVAL, pthread_barrier_destroy(&barrier)); 1742#endif 1743} 1744 1745struct BarrierOrderingTestHelperArg { 1746 pthread_barrier_t* barrier; 1747 size_t* array; 1748 size_t array_length; 1749 size_t id; 1750}; 1751 1752void BarrierOrderingTestHelper(BarrierOrderingTestHelperArg* arg) { 1753 const size_t ITERATION_COUNT = 10000; 1754 for (size_t i = 1; i <= ITERATION_COUNT; ++i) { 1755 arg->array[arg->id] = i; 1756 int ret = pthread_barrier_wait(arg->barrier); 1757 ASSERT_TRUE(ret == 0 || ret == PTHREAD_BARRIER_SERIAL_THREAD); 1758 for (size_t j = 0; j < arg->array_length; ++j) { 1759 ASSERT_EQ(i, arg->array[j]); 1760 } 1761 ret = pthread_barrier_wait(arg->barrier); 1762 ASSERT_TRUE(ret == 0 || ret == PTHREAD_BARRIER_SERIAL_THREAD); 1763 } 1764} 1765 1766TEST(pthread, pthread_barrier_check_ordering) { 1767 const size_t THREAD_COUNT = 4; 1768 pthread_barrier_t barrier; 1769 ASSERT_EQ(0, pthread_barrier_init(&barrier, nullptr, THREAD_COUNT)); 1770 size_t array[THREAD_COUNT]; 1771 std::vector<pthread_t> threads(THREAD_COUNT); 1772 std::vector<BarrierOrderingTestHelperArg> args(THREAD_COUNT); 1773 for (size_t i = 0; i < THREAD_COUNT; ++i) { 1774 args[i].barrier = &barrier; 1775 args[i].array = array; 1776 args[i].array_length = THREAD_COUNT; 1777 args[i].id = i; 1778 ASSERT_EQ(0, pthread_create(&threads[i], nullptr, 1779 reinterpret_cast<void* (*)(void*)>(BarrierOrderingTestHelper), 1780 &args[i])); 1781 } 1782 for (size_t i = 0; i < THREAD_COUNT; ++i) { 1783 ASSERT_EQ(0, pthread_join(threads[i], nullptr)); 1784 } 1785} 1786