blob: 74a0ce5a6b937c38407613fa1d251789f14a5c55 [file] [log] [blame]
// Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/win/wait_chain.h"
#include <memory>
#include <string>
#include "base/bind.h"
#include "base/callback.h"
#include "base/command_line.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_piece.h"
#include "base/test/multiprocess_test.h"
#include "base/threading/simple_thread.h"
#include "base/win/win_util.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "testing/multiprocess_func_list.h"
namespace base {
namespace win {
namespace {
// Appends |handle| as a command line switch.
void AppendSwitchHandle(CommandLine* command_line,
StringPiece switch_name,
HANDLE handle) {
command_line->AppendSwitchASCII(switch_name.as_string(),
UintToString(HandleToUint32(handle)));
}
// Retrieves the |handle| associated to |switch_name| from the command line.
ScopedHandle GetSwitchValueHandle(CommandLine* command_line,
StringPiece switch_name) {
std::string switch_string =
command_line->GetSwitchValueASCII(switch_name.as_string());
unsigned int switch_uint = 0;
if (switch_string.empty() || !StringToUint(switch_string, &switch_uint)) {
DLOG(ERROR) << "Missing or invalid " << switch_name << " argument.";
return ScopedHandle();
}
return ScopedHandle(reinterpret_cast<HANDLE>(switch_uint));
}
// Helper function to create a mutex.
ScopedHandle CreateMutex(bool inheritable) {
SECURITY_ATTRIBUTES security_attributes = {sizeof(SECURITY_ATTRIBUTES),
nullptr, inheritable};
return ScopedHandle(::CreateMutex(&security_attributes, FALSE, NULL));
}
// Helper function to create an event.
ScopedHandle CreateEvent(bool inheritable) {
SECURITY_ATTRIBUTES security_attributes = {sizeof(SECURITY_ATTRIBUTES),
nullptr, inheritable};
return ScopedHandle(
::CreateEvent(&security_attributes, FALSE, FALSE, nullptr));
}
// Helper thread class that runs the callback then stops.
class SingleTaskThread : public SimpleThread {
public:
explicit SingleTaskThread(const Closure& task)
: SimpleThread("WaitChainTest SingleTaskThread"), task_(task) {}
void Run() override { task_.Run(); }
private:
Closure task_;
DISALLOW_COPY_AND_ASSIGN(SingleTaskThread);
};
// Helper thread to cause a deadlock by acquiring 2 mutexes in a given order.
class DeadlockThread : public SimpleThread {
public:
DeadlockThread(HANDLE mutex_1, HANDLE mutex_2)
: SimpleThread("WaitChainTest DeadlockThread"),
wait_event_(CreateEvent(false)),
mutex_acquired_event_(CreateEvent(false)),
mutex_1_(mutex_1),
mutex_2_(mutex_2) {}
void Run() override {
// Acquire the mutex then signal the main thread.
EXPECT_EQ(WAIT_OBJECT_0, ::WaitForSingleObject(mutex_1_, INFINITE));
EXPECT_TRUE(::SetEvent(mutex_acquired_event_.Get()));
// Wait until both threads are holding their mutex before trying to acquire
// the other one.
EXPECT_EQ(WAIT_OBJECT_0,
::WaitForSingleObject(wait_event_.Get(), INFINITE));
// To unblock the deadlock, one of the threads will get terminated (via
// TerminateThread()) without releasing the mutex. This causes the other
// thread to wake up with WAIT_ABANDONED.
EXPECT_EQ(WAIT_ABANDONED, ::WaitForSingleObject(mutex_2_, INFINITE));
}
// Blocks until a mutex is acquired.
void WaitForMutexAcquired() {
EXPECT_EQ(WAIT_OBJECT_0,
::WaitForSingleObject(mutex_acquired_event_.Get(), INFINITE));
}
// Signal the thread to acquire the second mutex.
void SignalToAcquireMutex() { EXPECT_TRUE(::SetEvent(wait_event_.Get())); }
// Terminates the thread.
bool Terminate() {
ScopedHandle thread_handle(::OpenThread(THREAD_TERMINATE, FALSE, tid()));
return ::TerminateThread(thread_handle.Get(), 0);
}
private:
ScopedHandle wait_event_;
ScopedHandle mutex_acquired_event_;
// The 2 mutex to acquire.
HANDLE mutex_1_;
HANDLE mutex_2_;
DISALLOW_COPY_AND_ASSIGN(DeadlockThread);
};
// Creates a thread that joins |thread_to_join| and then terminates when it
// finishes execution.
std::unique_ptr<SingleTaskThread> CreateJoiningThread(
SimpleThread* thread_to_join) {
std::unique_ptr<SingleTaskThread> thread(new SingleTaskThread(
Bind(&SimpleThread::Join, Unretained(thread_to_join))));
thread->Start();
return thread;
}
// Creates a thread that calls WaitForSingleObject() on the handle and then
// terminates when it unblocks.
std::unique_ptr<SingleTaskThread> CreateWaitingThread(HANDLE handle) {
std::unique_ptr<SingleTaskThread> thread(new SingleTaskThread(
Bind(IgnoreResult(&::WaitForSingleObject), handle, INFINITE)));
thread->Start();
return thread;
}
// Creates a thread that blocks on |mutex_2| after acquiring |mutex_1|.
std::unique_ptr<DeadlockThread> CreateDeadlockThread(HANDLE mutex_1,
HANDLE mutex_2) {
std::unique_ptr<DeadlockThread> thread(new DeadlockThread(mutex_1, mutex_2));
thread->Start();
// Wait until the first mutex is acquired before returning.
thread->WaitForMutexAcquired();
return thread;
}
// Child process to test the cross-process capability of the WCT api.
// This process will simulate a hang while holding a mutex that the parent
// process is waiting on.
MULTIPROCESS_TEST_MAIN(WaitChainTestProc) {
CommandLine* command_line = CommandLine::ForCurrentProcess();
ScopedHandle mutex = GetSwitchValueHandle(command_line, "mutex");
CHECK(mutex.IsValid());
ScopedHandle sync_event(GetSwitchValueHandle(command_line, "sync_event"));
CHECK(sync_event.IsValid());
// Acquire mutex.
CHECK(::WaitForSingleObject(mutex.Get(), INFINITE) == WAIT_OBJECT_0);
// Signal back to the parent process that the mutex is hold.
CHECK(::SetEvent(sync_event.Get()));
// Wait on a signal from the parent process before terminating.
CHECK(::WaitForSingleObject(sync_event.Get(), INFINITE) == WAIT_OBJECT_0);
return 0;
}
// Start a child process and passes the |mutex| and the |sync_event| to the
// command line.
Process StartChildProcess(HANDLE mutex, HANDLE sync_event) {
CommandLine command_line = GetMultiProcessTestChildBaseCommandLine();
AppendSwitchHandle(&command_line, "mutex", mutex);
AppendSwitchHandle(&command_line, "sync_event", sync_event);
LaunchOptions options;
options.handles_to_inherit.push_back(mutex);
options.handles_to_inherit.push_back(sync_event);
return SpawnMultiProcessTestChild("WaitChainTestProc", command_line, options);
}
// Returns true if the |wait_chain| is an alternating sequence of thread objects
// and synchronization objects.
bool WaitChainStructureIsCorrect(const WaitChainNodeVector& wait_chain) {
// Checks thread objects.
for (size_t i = 0; i < wait_chain.size(); i += 2) {
if (wait_chain[i].ObjectType != WctThreadType)
return false;
}
// Check synchronization objects.
for (size_t i = 1; i < wait_chain.size(); i += 2) {
if (wait_chain[i].ObjectType == WctThreadType)
return false;
}
return true;
}
// Returns true if the |wait_chain| goes through more than 1 process.
bool WaitChainIsCrossProcess(const WaitChainNodeVector& wait_chain) {
if (wait_chain.size() == 0)
return false;
// Just check that the process id changes somewhere in the chain.
// Note: ThreadObjects are every 2 nodes.
DWORD first_process = wait_chain[0].ThreadObject.ProcessId;
for (size_t i = 2; i < wait_chain.size(); i += 2) {
if (first_process != wait_chain[i].ThreadObject.ProcessId)
return true;
}
return false;
}
} // namespace
// Creates 2 threads that acquire their designated mutex and then try to
// acquire each others' mutex to cause a deadlock.
TEST(WaitChainTest, Deadlock) {
// 2 mutexes are needed to get a deadlock.
ScopedHandle mutex_1 = CreateMutex(false);
ASSERT_TRUE(mutex_1.IsValid());
ScopedHandle mutex_2 = CreateMutex(false);
ASSERT_TRUE(mutex_2.IsValid());
std::unique_ptr<DeadlockThread> deadlock_thread_1 =
CreateDeadlockThread(mutex_1.Get(), mutex_2.Get());
std::unique_ptr<DeadlockThread> deadlock_thread_2 =
CreateDeadlockThread(mutex_2.Get(), mutex_1.Get());
// Signal the threads to try to acquire the other mutex.
deadlock_thread_1->SignalToAcquireMutex();
deadlock_thread_2->SignalToAcquireMutex();
// Sleep to make sure the 2 threads got a chance to execute.
Sleep(10);
// Create a few waiting threads to get a longer wait chain.
std::unique_ptr<SingleTaskThread> waiting_thread_1 =
CreateJoiningThread(deadlock_thread_1.get());
std::unique_ptr<SingleTaskThread> waiting_thread_2 =
CreateJoiningThread(waiting_thread_1.get());
WaitChainNodeVector wait_chain;
bool is_deadlock;
ASSERT_TRUE(GetThreadWaitChain(waiting_thread_2->tid(), &wait_chain,
&is_deadlock, nullptr, nullptr));
EXPECT_EQ(9U, wait_chain.size());
EXPECT_TRUE(is_deadlock);
EXPECT_TRUE(WaitChainStructureIsCorrect(wait_chain));
EXPECT_FALSE(WaitChainIsCrossProcess(wait_chain));
ASSERT_TRUE(deadlock_thread_1->Terminate());
// The SimpleThread API expect Join() to be called before destruction.
deadlock_thread_2->Join();
waiting_thread_2->Join();
}
// Creates a child process that acquires a mutex and then blocks. A chain of
// threads then blocks on that mutex.
TEST(WaitChainTest, CrossProcess) {
ScopedHandle mutex = CreateMutex(true);
ASSERT_TRUE(mutex.IsValid());
ScopedHandle sync_event = CreateEvent(true);
ASSERT_TRUE(sync_event.IsValid());
Process child_process = StartChildProcess(mutex.Get(), sync_event.Get());
ASSERT_TRUE(child_process.IsValid());
// Wait for the child process to signal when it's holding the mutex.
EXPECT_EQ(WAIT_OBJECT_0, ::WaitForSingleObject(sync_event.Get(), INFINITE));
// Create a few waiting threads to get a longer wait chain.
std::unique_ptr<SingleTaskThread> waiting_thread_1 =
CreateWaitingThread(mutex.Get());
std::unique_ptr<SingleTaskThread> waiting_thread_2 =
CreateJoiningThread(waiting_thread_1.get());
std::unique_ptr<SingleTaskThread> waiting_thread_3 =
CreateJoiningThread(waiting_thread_2.get());
WaitChainNodeVector wait_chain;
bool is_deadlock;
ASSERT_TRUE(GetThreadWaitChain(waiting_thread_3->tid(), &wait_chain,
&is_deadlock, nullptr, nullptr));
EXPECT_EQ(7U, wait_chain.size());
EXPECT_FALSE(is_deadlock);
EXPECT_TRUE(WaitChainStructureIsCorrect(wait_chain));
EXPECT_TRUE(WaitChainIsCrossProcess(wait_chain));
// Unblock child process and wait for it to terminate.
ASSERT_TRUE(::SetEvent(sync_event.Get()));
ASSERT_TRUE(child_process.WaitForExit(nullptr));
// The SimpleThread API expect Join() to be called before destruction.
waiting_thread_3->Join();
}
} // namespace win
} // namespace base