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