#include "lldb/Host/Mutex.h"
#include "lldb/Host/Host.h"
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#if 0
#include <cstdio>
#define DEBUG_LOG(fmt, ...) printf(fmt, ## __VA_ARGS__)
#else
#define DEBUG_LOG(fmt, ...)
#endif
#ifdef LLDB_CONFIGURATION_DEBUG
#define ENABLE_MUTEX_ERROR_CHECKING 1
#endif
#if ENABLE_MUTEX_ERROR_CHECKING
#include <set>
enum MutexAction
{
eMutexActionInitialized,
eMutexActionDestroyed,
eMutexActionAssertInitialized
};
static bool
error_check_mutex (pthread_mutex_t *m, MutexAction action)
{
typedef std::set<pthread_mutex_t *> mutex_set;
static pthread_mutex_t g_mutex_set_mutex = PTHREAD_MUTEX_INITIALIZER;
static mutex_set g_initialized_mutex_set;
static mutex_set g_destroyed_mutex_set;
bool success = true;
int err;
err = ::pthread_mutex_lock (&g_mutex_set_mutex);
assert(err == 0);
switch (action)
{
case eMutexActionInitialized:
assert (g_initialized_mutex_set.find(m) == g_initialized_mutex_set.end());
g_destroyed_mutex_set.erase(m);
g_initialized_mutex_set.insert(m);
break;
case eMutexActionDestroyed:
assert (g_destroyed_mutex_set.find(m) == g_destroyed_mutex_set.end());
g_initialized_mutex_set.erase(m);
g_destroyed_mutex_set.insert(m);
break;
case eMutexActionAssertInitialized:
success = g_initialized_mutex_set.find(m) != g_initialized_mutex_set.end();
assert (success);
break;
}
err = ::pthread_mutex_unlock (&g_mutex_set_mutex);
assert(err == 0);
return success;
}
#endif
using namespace lldb_private;
Mutex::Locker::Locker () :
m_mutex_ptr(NULL)
{
}
Mutex::Locker::Locker (Mutex& m) :
m_mutex_ptr(NULL)
{
Lock (m);
}
Mutex::Locker::Locker (Mutex* m) :
m_mutex_ptr(NULL)
{
if (m)
Lock (m);
}
Mutex::Locker::~Locker ()
{
Unlock();
}
void
Mutex::Locker::Lock (Mutex &mutex)
{
if (m_mutex_ptr == &mutex)
return;
Unlock ();
m_mutex_ptr = &mutex;
m_mutex_ptr->Lock();
}
void
Mutex::Locker::Unlock ()
{
if (m_mutex_ptr)
{
m_mutex_ptr->Unlock ();
m_mutex_ptr = NULL;
}
}
bool
Mutex::Locker::TryLock (Mutex &mutex, const char *failure_message)
{
if (m_mutex_ptr == &mutex)
return true;
Unlock ();
if (mutex.TryLock(failure_message) == 0)
m_mutex_ptr = &mutex;
return m_mutex_ptr != NULL;
}
Mutex::Mutex () :
m_mutex()
{
int err;
err = ::pthread_mutex_init (&m_mutex, NULL);
#if ENABLE_MUTEX_ERROR_CHECKING
if (err == 0)
error_check_mutex (&m_mutex, eMutexActionInitialized);
#endif
assert(err == 0);
}
Mutex::Mutex (Mutex::Type type) :
m_mutex()
{
int err;
::pthread_mutexattr_t attr;
err = ::pthread_mutexattr_init (&attr);
assert(err == 0);
switch (type)
{
case eMutexTypeNormal:
#if ENABLE_MUTEX_ERROR_CHECKING
err = ::pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_ERRORCHECK);
#else
err = ::pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_NORMAL);
#endif
break;
case eMutexTypeRecursive:
err = ::pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_RECURSIVE);
break;
default:
err = -1;
break;
}
assert(err == 0);
err = ::pthread_mutex_init (&m_mutex, &attr);
#if ENABLE_MUTEX_ERROR_CHECKING
if (err == 0)
error_check_mutex (&m_mutex, eMutexActionInitialized);
#endif
assert(err == 0);
err = ::pthread_mutexattr_destroy (&attr);
assert(err == 0);
}
Mutex::~Mutex()
{
int err;
err = ::pthread_mutex_destroy (&m_mutex);
#if ENABLE_MUTEX_ERROR_CHECKING
if (err == 0)
error_check_mutex (&m_mutex, eMutexActionDestroyed);
else
{
Host::SetCrashDescriptionWithFormat ("%s error: pthread_mutex_destroy() => err = %i (%s)", __PRETTY_FUNCTION__, err, strerror(err));
assert(err == 0);
}
memset (&m_mutex, '\xba', sizeof(m_mutex));
#endif
}
pthread_mutex_t *
Mutex::GetMutex()
{
return &m_mutex;
}
int
Mutex::Lock()
{
DEBUG_LOG ("[%4.4" PRIx64 "/%4.4" PRIx64 "] pthread_mutex_lock (%p)...\n", Host::GetCurrentProcessID(), Host::GetCurrentThreadID(), &m_mutex);
#if ENABLE_MUTEX_ERROR_CHECKING
error_check_mutex (&m_mutex, eMutexActionAssertInitialized);
#endif
int err = ::pthread_mutex_lock (&m_mutex);
#if ENABLE_MUTEX_ERROR_CHECKING
if (err)
{
Host::SetCrashDescriptionWithFormat ("%s error: pthread_mutex_lock(%p) => err = %i (%s)", __PRETTY_FUNCTION__, &m_mutex, err, strerror(err));
assert(err == 0);
}
#endif
DEBUG_LOG ("[%4.4" PRIx64 "/%4.4" PRIx64 "] pthread_mutex_lock (%p) => %i\n", Host::GetCurrentProcessID(), Host::GetCurrentThreadID(), &m_mutex, err);
return err;
}
int
Mutex::TryLock(const char *failure_message)
{
#if ENABLE_MUTEX_ERROR_CHECKING
error_check_mutex (&m_mutex, eMutexActionAssertInitialized);
#endif
int err = ::pthread_mutex_trylock (&m_mutex);
DEBUG_LOG ("[%4.4" PRIx64 "/%4.4" PRIx64 "] pthread_mutex_trylock (%p) => %i\n", Host::GetCurrentProcessID(), Host::GetCurrentThreadID(), &m_mutex, err);
return err;
}
int
Mutex::Unlock()
{
#if ENABLE_MUTEX_ERROR_CHECKING
error_check_mutex (&m_mutex, eMutexActionAssertInitialized);
#endif
int err = ::pthread_mutex_unlock (&m_mutex);
#if ENABLE_MUTEX_ERROR_CHECKING
if (err)
{
Host::SetCrashDescriptionWithFormat ("%s error: pthread_mutex_unlock(%p) => err = %i (%s)", __PRETTY_FUNCTION__, &m_mutex, err, strerror(err));
assert(err == 0);
}
#endif
DEBUG_LOG ("[%4.4" PRIx64 "/%4.4" PRIx64 "] pthread_mutex_unlock (%p) => %i\n", Host::GetCurrentProcessID(), Host::GetCurrentThreadID(), &m_mutex, err);
return err;
}
#ifdef LLDB_CONFIGURATION_DEBUG
int
TrackingMutex::Unlock ()
{
if (!m_failure_message.empty())
Host::SetCrashDescriptionWithFormat ("Unlocking lock (on thread %p) that thread: %p failed to get: %s",
pthread_self(),
m_thread_that_tried,
m_failure_message.c_str());
assert (m_failure_message.empty());
return Mutex::Unlock();
}
#endif