1//===-- sanitizer_linux_test.cc -------------------------------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// Tests for sanitizer_linux.h
11//
12//===----------------------------------------------------------------------===//
13
14#include "sanitizer_common/sanitizer_platform.h"
15#if SANITIZER_LINUX
16
17#include "sanitizer_common/sanitizer_linux.h"
18
19#include "sanitizer_common/sanitizer_common.h"
20#include "gtest/gtest.h"
21
22#include <pthread.h>
23#include <sched.h>
24#include <stdlib.h>
25
26#include <algorithm>
27#include <vector>
28
29namespace __sanitizer {
30
31struct TidReporterArgument {
32  TidReporterArgument() {
33    pthread_mutex_init(&terminate_thread_mutex, NULL);
34    pthread_mutex_init(&tid_reported_mutex, NULL);
35    pthread_cond_init(&terminate_thread_cond, NULL);
36    pthread_cond_init(&tid_reported_cond, NULL);
37    terminate_thread = false;
38  }
39
40  ~TidReporterArgument() {
41    pthread_mutex_destroy(&terminate_thread_mutex);
42    pthread_mutex_destroy(&tid_reported_mutex);
43    pthread_cond_destroy(&terminate_thread_cond);
44    pthread_cond_destroy(&tid_reported_cond);
45  }
46
47  pid_t reported_tid;
48  // For signaling to spawned threads that they should terminate.
49  pthread_cond_t terminate_thread_cond;
50  pthread_mutex_t terminate_thread_mutex;
51  bool terminate_thread;
52  // For signaling to main thread that a child thread has reported its tid.
53  pthread_cond_t tid_reported_cond;
54  pthread_mutex_t tid_reported_mutex;
55
56 private:
57  // Disallow evil constructors
58  TidReporterArgument(const TidReporterArgument &);
59  void operator=(const TidReporterArgument &);
60};
61
62class ThreadListerTest : public ::testing::Test {
63 protected:
64  virtual void SetUp() {
65    pthread_t pthread_id;
66    pid_t tid;
67    for (uptr i = 0; i < kThreadCount; i++) {
68      SpawnTidReporter(&pthread_id, &tid);
69      pthread_ids_.push_back(pthread_id);
70      tids_.push_back(tid);
71    }
72  }
73
74  virtual void TearDown() {
75    pthread_mutex_lock(&thread_arg.terminate_thread_mutex);
76    thread_arg.terminate_thread = true;
77    pthread_cond_broadcast(&thread_arg.terminate_thread_cond);
78    pthread_mutex_unlock(&thread_arg.terminate_thread_mutex);
79    for (uptr i = 0; i < pthread_ids_.size(); i++)
80      pthread_join(pthread_ids_[i], NULL);
81  }
82
83  void SpawnTidReporter(pthread_t *pthread_id, pid_t *tid);
84
85  static const uptr kThreadCount = 20;
86
87  std::vector<pthread_t> pthread_ids_;
88  std::vector<pid_t> tids_;
89
90  TidReporterArgument thread_arg;
91};
92
93// Writes its TID once to reported_tid and waits until signaled to terminate.
94void *TidReporterThread(void *argument) {
95  TidReporterArgument *arg = reinterpret_cast<TidReporterArgument *>(argument);
96  pthread_mutex_lock(&arg->tid_reported_mutex);
97  arg->reported_tid = GetTid();
98  pthread_cond_broadcast(&arg->tid_reported_cond);
99  pthread_mutex_unlock(&arg->tid_reported_mutex);
100
101  pthread_mutex_lock(&arg->terminate_thread_mutex);
102  while (!arg->terminate_thread)
103    pthread_cond_wait(&arg->terminate_thread_cond,
104                      &arg->terminate_thread_mutex);
105  pthread_mutex_unlock(&arg->terminate_thread_mutex);
106  return NULL;
107}
108
109void ThreadListerTest::SpawnTidReporter(pthread_t *pthread_id,
110                                        pid_t *tid) {
111  pthread_mutex_lock(&thread_arg.tid_reported_mutex);
112  thread_arg.reported_tid = -1;
113  ASSERT_EQ(0, pthread_create(pthread_id, NULL,
114                              TidReporterThread,
115                              &thread_arg));
116  while (thread_arg.reported_tid == -1)
117    pthread_cond_wait(&thread_arg.tid_reported_cond,
118                      &thread_arg.tid_reported_mutex);
119  pthread_mutex_unlock(&thread_arg.tid_reported_mutex);
120  *tid = thread_arg.reported_tid;
121}
122
123static std::vector<pid_t> ReadTidsToVector(ThreadLister *thread_lister) {
124  std::vector<pid_t> listed_tids;
125  pid_t tid;
126  while ((tid = thread_lister->GetNextTID()) >= 0)
127    listed_tids.push_back(tid);
128  EXPECT_FALSE(thread_lister->error());
129  return listed_tids;
130}
131
132static bool Includes(std::vector<pid_t> first, std::vector<pid_t> second) {
133  std::sort(first.begin(), first.end());
134  std::sort(second.begin(), second.end());
135  return std::includes(first.begin(), first.end(),
136                       second.begin(), second.end());
137}
138
139static bool HasElement(std::vector<pid_t> vector, pid_t element) {
140  return std::find(vector.begin(), vector.end(), element) != vector.end();
141}
142
143// ThreadLister's output should include the current thread's TID and the TID of
144// every thread we spawned.
145TEST_F(ThreadListerTest, ThreadListerSeesAllSpawnedThreads) {
146  pid_t self_tid = GetTid();
147  ThreadLister thread_lister(getpid());
148  std::vector<pid_t> listed_tids = ReadTidsToVector(&thread_lister);
149  ASSERT_TRUE(HasElement(listed_tids, self_tid));
150  ASSERT_TRUE(Includes(listed_tids, tids_));
151}
152
153// Calling Reset() should not cause ThreadLister to forget any threads it's
154// supposed to know about.
155TEST_F(ThreadListerTest, ResetDoesNotForgetThreads) {
156  ThreadLister thread_lister(getpid());
157
158  // Run the loop body twice, because Reset() might behave differently if called
159  // on a freshly created object.
160  for (uptr i = 0; i < 2; i++) {
161    thread_lister.Reset();
162    std::vector<pid_t> listed_tids = ReadTidsToVector(&thread_lister);
163    ASSERT_TRUE(Includes(listed_tids, tids_));
164  }
165}
166
167// If new threads have spawned during ThreadLister object's lifetime, calling
168// Reset() should cause ThreadLister to recognize their existence.
169TEST_F(ThreadListerTest, ResetMakesNewThreadsKnown) {
170  ThreadLister thread_lister(getpid());
171  std::vector<pid_t> threads_before_extra = ReadTidsToVector(&thread_lister);
172
173  pthread_t extra_pthread_id;
174  pid_t extra_tid;
175  SpawnTidReporter(&extra_pthread_id, &extra_tid);
176  // Register the new thread so it gets terminated in TearDown().
177  pthread_ids_.push_back(extra_pthread_id);
178
179  // It would be very bizarre if the new TID had been listed before we even
180  // spawned that thread, but it would also cause a false success in this test,
181  // so better check for that.
182  ASSERT_FALSE(HasElement(threads_before_extra, extra_tid));
183
184  thread_lister.Reset();
185
186  std::vector<pid_t> threads_after_extra = ReadTidsToVector(&thread_lister);
187  ASSERT_TRUE(HasElement(threads_after_extra, extra_tid));
188}
189
190TEST(SanitizerCommon, SetEnvTest) {
191  const char kEnvName[] = "ENV_FOO";
192  SetEnv(kEnvName, "value");
193  EXPECT_STREQ("value", getenv(kEnvName));
194  unsetenv(kEnvName);
195  EXPECT_EQ(0, getenv(kEnvName));
196}
197
198#if defined(__x86_64__) || defined(__i386__)
199void *thread_self_offset_test_func(void *arg) {
200  bool result =
201      *(uptr *)((char *)ThreadSelf() + ThreadSelfOffset()) == ThreadSelf();
202  return (void *)result;
203}
204
205TEST(SanitizerLinux, ThreadSelfOffset) {
206  EXPECT_TRUE((bool)thread_self_offset_test_func(0));
207  pthread_t tid;
208  void *result;
209  ASSERT_EQ(0, pthread_create(&tid, 0, thread_self_offset_test_func, 0));
210  ASSERT_EQ(0, pthread_join(tid, &result));
211  EXPECT_TRUE((bool)result);
212}
213
214// libpthread puts the thread descriptor at the end of stack space.
215void *thread_descriptor_size_test_func(void *arg) {
216  uptr descr_addr = ThreadSelf();
217  pthread_attr_t attr;
218  pthread_getattr_np(pthread_self(), &attr);
219  void *stackaddr;
220  size_t stacksize;
221  pthread_attr_getstack(&attr, &stackaddr, &stacksize);
222  return (void *)((uptr)stackaddr + stacksize - descr_addr);
223}
224
225TEST(SanitizerLinux, ThreadDescriptorSize) {
226  pthread_t tid;
227  void *result;
228  ASSERT_EQ(0, pthread_create(&tid, 0, thread_descriptor_size_test_func, 0));
229  ASSERT_EQ(0, pthread_join(tid, &result));
230  EXPECT_EQ((uptr)result, ThreadDescriptorSize());
231}
232#endif
233
234TEST(SanitizerCommon, LibraryNameIs) {
235  EXPECT_FALSE(LibraryNameIs("", ""));
236
237  char full_name[256];
238  const char *paths[] = { "", "/", "/path/to/" };
239  const char *suffixes[] = { "", "-linux", ".1.2", "-linux.1.2" };
240  const char *base_names[] = { "lib", "lib.0", "lib-i386" };
241  const char *wrong_names[] = { "", "lib.9", "lib-x86_64" };
242  for (uptr i = 0; i < ARRAY_SIZE(paths); i++)
243    for (uptr j = 0; j < ARRAY_SIZE(suffixes); j++) {
244      for (uptr k = 0; k < ARRAY_SIZE(base_names); k++) {
245        internal_snprintf(full_name, ARRAY_SIZE(full_name), "%s%s%s.so",
246                          paths[i], base_names[k], suffixes[j]);
247        EXPECT_TRUE(LibraryNameIs(full_name, base_names[k]))
248            << "Full name " << full_name
249            << " doesn't match base name " << base_names[k];
250        for (uptr m = 0; m < ARRAY_SIZE(wrong_names); m++)
251          EXPECT_FALSE(LibraryNameIs(full_name, wrong_names[m]))
252            << "Full name " << full_name
253            << " matches base name " << wrong_names[m];
254      }
255    }
256}
257
258}  // namespace __sanitizer
259
260#endif  // SANITIZER_LINUX
261