//===-- sanitizer_linux_test.cpp ------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// Tests for sanitizer_linux.h
//
//===----------------------------------------------------------------------===//
#include "sanitizer_common/sanitizer_platform.h"
#if SANITIZER_LINUX
# include <pthread.h>
# include <sched.h>
# include <stdlib.h>
# include <algorithm>
# include <vector>
# include "gtest/gtest.h"
# include "sanitizer_common/sanitizer_common.h"
# include "sanitizer_common/sanitizer_file.h"
# include "sanitizer_common/sanitizer_linux.h"
namespace __sanitizer {
struct TidReporterArgument {
TidReporterArgument() {
pthread_mutex_init(&terminate_thread_mutex, NULL);
pthread_mutex_init(&tid_reported_mutex, NULL);
pthread_cond_init(&terminate_thread_cond, NULL);
pthread_cond_init(&tid_reported_cond, NULL);
terminate_thread = false;
}
~TidReporterArgument() {
pthread_mutex_destroy(&terminate_thread_mutex);
pthread_mutex_destroy(&tid_reported_mutex);
pthread_cond_destroy(&terminate_thread_cond);
pthread_cond_destroy(&tid_reported_cond);
}
tid_t reported_tid;
// For signaling to spawned threads that they should terminate.
pthread_cond_t terminate_thread_cond;
pthread_mutex_t terminate_thread_mutex;
bool terminate_thread;
// For signaling to main thread that a child thread has reported its tid.
pthread_cond_t tid_reported_cond;
pthread_mutex_t tid_reported_mutex;
private:
// Disallow evil constructors
TidReporterArgument(const TidReporterArgument &);
void operator=(const TidReporterArgument &);
};
class ThreadListerTest : public ::testing::Test {
protected:
virtual void SetUp() {
pthread_t pthread_id;
tid_t tid;
for (uptr i = 0; i < kThreadCount; i++) {
SpawnTidReporter(&pthread_id, &tid);
pthread_ids_.push_back(pthread_id);
tids_.push_back(tid);
}
}
virtual void TearDown() {
pthread_mutex_lock(&thread_arg.terminate_thread_mutex);
thread_arg.terminate_thread = true;
pthread_cond_broadcast(&thread_arg.terminate_thread_cond);
pthread_mutex_unlock(&thread_arg.terminate_thread_mutex);
for (uptr i = 0; i < pthread_ids_.size(); i++)
pthread_join(pthread_ids_[i], NULL);
}
void SpawnTidReporter(pthread_t *pthread_id, tid_t *tid);
static const uptr kThreadCount = 20;
std::vector<pthread_t> pthread_ids_;
std::vector<tid_t> tids_;
TidReporterArgument thread_arg;
};
// Writes its TID once to reported_tid and waits until signaled to terminate.
void *TidReporterThread(void *argument) {
TidReporterArgument *arg = reinterpret_cast<TidReporterArgument *>(argument);
pthread_mutex_lock(&arg->tid_reported_mutex);
arg->reported_tid = GetTid();
pthread_cond_broadcast(&arg->tid_reported_cond);
pthread_mutex_unlock(&arg->tid_reported_mutex);
pthread_mutex_lock(&arg->terminate_thread_mutex);
while (!arg->terminate_thread)
pthread_cond_wait(&arg->terminate_thread_cond,
&arg->terminate_thread_mutex);
pthread_mutex_unlock(&arg->terminate_thread_mutex);
return NULL;
}
void ThreadListerTest::SpawnTidReporter(pthread_t *pthread_id, tid_t *tid) {
pthread_mutex_lock(&thread_arg.tid_reported_mutex);
thread_arg.reported_tid = -1;
ASSERT_EQ(0,
pthread_create(pthread_id, NULL, TidReporterThread, &thread_arg));
while (thread_arg.reported_tid == (tid_t)(-1))
pthread_cond_wait(&thread_arg.tid_reported_cond,
&thread_arg.tid_reported_mutex);
pthread_mutex_unlock(&thread_arg.tid_reported_mutex);
*tid = thread_arg.reported_tid;
}
static std::vector<tid_t> ReadTidsToVector(ThreadLister *thread_lister) {
std::vector<tid_t> listed_tids;
InternalMmapVector<tid_t> threads(128);
EXPECT_TRUE(thread_lister->ListThreads(&threads));
return std::vector<tid_t>(threads.begin(), threads.end());
}
static bool Includes(std::vector<tid_t> first, std::vector<tid_t> second) {
std::sort(first.begin(), first.end());
std::sort(second.begin(), second.end());
return std::includes(first.begin(), first.end(), second.begin(),
second.end());
}
static bool HasElement(const std::vector<tid_t> &vector, tid_t element) {
return std::find(vector.begin(), vector.end(), element) != vector.end();
}
// ThreadLister's output should include the current thread's TID and the TID of
// every thread we spawned.
TEST_F(ThreadListerTest, ThreadListerSeesAllSpawnedThreads) {
tid_t self_tid = GetTid();
ThreadLister thread_lister(getpid());
std::vector<tid_t> listed_tids = ReadTidsToVector(&thread_lister);
ASSERT_TRUE(HasElement(listed_tids, self_tid));
ASSERT_TRUE(Includes(listed_tids, tids_));
}
TEST_F(ThreadListerTest, DoNotForgetThreads) {
ThreadLister thread_lister(getpid());
// Run the loop body twice, because ThreadLister might behave differently if
// called on a freshly created object.
for (uptr i = 0; i < 2; i++) {
std::vector<tid_t> listed_tids = ReadTidsToVector(&thread_lister);
ASSERT_TRUE(Includes(listed_tids, tids_));
}
}
// If new threads have spawned during ThreadLister object's lifetime, calling
// relisting should cause ThreadLister to recognize their existence.
TEST_F(ThreadListerTest, NewThreads) {
ThreadLister thread_lister(getpid());
std::vector<tid_t> threads_before_extra = ReadTidsToVector(&thread_lister);
pthread_t extra_pthread_id;
tid_t extra_tid;
SpawnTidReporter(&extra_pthread_id, &extra_tid);
// Register the new thread so it gets terminated in TearDown().
pthread_ids_.push_back(extra_pthread_id);
// It would be very bizarre if the new TID had been listed before we even
// spawned that thread, but it would also cause a false success in this test,
// so better check for that.
ASSERT_FALSE(HasElement(threads_before_extra, extra_tid));
std::vector<tid_t> threads_after_extra = ReadTidsToVector(&thread_lister);
ASSERT_TRUE(HasElement(threads_after_extra, extra_tid));
}
TEST(SanitizerCommon, SetEnvTest) {
const char kEnvName[] = "ENV_FOO";
SetEnv(kEnvName, "value");
EXPECT_STREQ("value", getenv(kEnvName));
unsetenv(kEnvName);
EXPECT_EQ(0, getenv(kEnvName));
}
# if (defined(__x86_64__) || defined(__i386__)) && !SANITIZER_ANDROID
// libpthread puts the thread descriptor at the end of stack space.
void *thread_descriptor_size_test_func(void *arg) {
uptr descr_addr = (uptr)pthread_self();
pthread_attr_t attr;
pthread_getattr_np(pthread_self(), &attr);
void *stackaddr;
size_t stacksize;
pthread_attr_getstack(&attr, &stackaddr, &stacksize);
return (void *)((uptr)stackaddr + stacksize - descr_addr);
}
TEST(SanitizerLinux, ThreadDescriptorSize) {
pthread_t tid;
void *result;
ASSERT_EQ(0, pthread_create(&tid, 0, thread_descriptor_size_test_func, 0));
ASSERT_EQ(0, pthread_join(tid, &result));
EXPECT_EQ(0u, ThreadDescriptorSize());
InitTlsSize();
EXPECT_EQ((uptr)result, ThreadDescriptorSize());
}
# endif
TEST(SanitizerCommon, LibraryNameIs) {
EXPECT_FALSE(LibraryNameIs("", ""));
char full_name[256];
const char *paths[] = {"", "/", "/path/to/"};
const char *suffixes[] = {"", "-linux", ".1.2", "-linux.1.2"};
const char *base_names[] = {"lib", "lib.0", "lib-i386"};
const char *wrong_names[] = {"", "lib.9", "lib-x86_64"};
for (uptr i = 0; i < ARRAY_SIZE(paths); i++)
for (uptr j = 0; j < ARRAY_SIZE(suffixes); j++) {
for (uptr k = 0; k < ARRAY_SIZE(base_names); k++) {
internal_snprintf(full_name, ARRAY_SIZE(full_name), "%s%s%s.so",
paths[i], base_names[k], suffixes[j]);
EXPECT_TRUE(LibraryNameIs(full_name, base_names[k]))
<< "Full name " << full_name << " doesn't match base name "
<< base_names[k];
for (uptr m = 0; m < ARRAY_SIZE(wrong_names); m++)
EXPECT_FALSE(LibraryNameIs(full_name, wrong_names[m]))
<< "Full name " << full_name << " matches base name "
<< wrong_names[m];
}
}
}
# if defined(__mips64)
// Effectively, this is a test for ThreadDescriptorSize() which is used to
// compute ThreadSelf().
TEST(SanitizerLinux, ThreadSelfTest) {
ASSERT_EQ(pthread_self(), ThreadSelf());
}
# endif
TEST(SanitizerCommon, StartSubprocessTest) {
int pipe_fds[2];
ASSERT_EQ(0, pipe(pipe_fds));
# if SANITIZER_ANDROID
const char *shell = "/system/bin/sh";
# else
const char *shell = "/bin/sh";
# endif
const char *argv[] = {shell, "-c", "echo -n 'hello'", (char *)NULL};
int pid = StartSubprocess(shell, argv, GetEnviron(),
/* stdin */ kInvalidFd, /* stdout */ pipe_fds[1]);
ASSERT_GT(pid, 0);
// wait for process to finish.
while (IsProcessRunning(pid)) {
}
ASSERT_FALSE(IsProcessRunning(pid));
char buffer[256];
{
char *ptr = buffer;
uptr bytes_read;
while (ReadFromFile(pipe_fds[0], ptr, 256, &bytes_read)) {
if (!bytes_read) {
break;
}
ptr += bytes_read;
}
ASSERT_EQ(5, ptr - buffer);
*ptr = 0;
}
ASSERT_EQ(0, strcmp(buffer, "hello")) << "Buffer: " << buffer;
internal_close(pipe_fds[0]);
}
} // namespace __sanitizer
#endif // SANITIZER_LINUX
Codebase Browser
llvm