#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)
{
pthread_mutex_t *mutex_ptr = mutex.GetMutex();
if (m_mutex_ptr == mutex_ptr)
return;
Unlock ();
if (mutex_ptr)
{
m_mutex_ptr = mutex_ptr;
Mutex::Lock (m_mutex_ptr);
}
}
void
Mutex::Locker::Unlock ()
{
if (m_mutex_ptr)
{
Mutex::Unlock (m_mutex_ptr);
m_mutex_ptr = NULL;
}
}
bool
Mutex::Locker::TryLock (Mutex &mutex)
{
pthread_mutex_t *mutex_ptr = mutex.GetMutex();
if (m_mutex_ptr == mutex_ptr)
return m_mutex_ptr != NULL;
Unlock ();
if (mutex_ptr)
{
if (Mutex::TryLock (mutex_ptr) == 0)
m_mutex_ptr = mutex_ptr;
}
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 (pthread_mutex_t *mutex_ptr)
{
DEBUG_LOG ("[%4.4x/%4.4x] pthread_mutex_lock (%p)...\n", Host::GetCurrentProcessID(), Host::GetCurrentThreadID(), mutex_ptr);
#if ENABLE_MUTEX_ERROR_CHECKING
error_check_mutex (mutex_ptr, eMutexActionAssertInitialized);
#endif
int err = ::pthread_mutex_lock (mutex_ptr);
#if ENABLE_MUTEX_ERROR_CHECKING
if (err)
{
Host::SetCrashDescriptionWithFormat ("%s error: pthread_mutex_lock(%p) => err = %i (%s)", __PRETTY_FUNCTION__, mutex_ptr, err, strerror(err));
assert(err == 0);
}
#endif
DEBUG_LOG ("[%4.4x/%4.4x] pthread_mutex_lock (%p) => %i\n", Host::GetCurrentProcessID(), Host::GetCurrentThreadID(), mutex_ptr, err);
return err;
}
int
Mutex::TryLock (pthread_mutex_t *mutex_ptr)
{
#if ENABLE_MUTEX_ERROR_CHECKING
error_check_mutex (mutex_ptr, eMutexActionAssertInitialized);
#endif
int err = ::pthread_mutex_trylock (mutex_ptr);
DEBUG_LOG ("[%4.4x/%4.4x] pthread_mutex_trylock (%p) => %i\n", Host::GetCurrentProcessID(), Host::GetCurrentThreadID(), mutex_ptr, err);
return err;
}
int
Mutex::Unlock (pthread_mutex_t *mutex_ptr)
{
#if ENABLE_MUTEX_ERROR_CHECKING
error_check_mutex (mutex_ptr, eMutexActionAssertInitialized);
#endif
int err = ::pthread_mutex_unlock (mutex_ptr);
#if ENABLE_MUTEX_ERROR_CHECKING
if (err)
{
Host::SetCrashDescriptionWithFormat ("%s error: pthread_mutex_unlock(%p) => err = %i (%s)", __PRETTY_FUNCTION__, mutex_ptr, err, strerror(err));
assert(err == 0);
}
#endif
DEBUG_LOG ("[%4.4x/%4.4x] pthread_mutex_unlock (%p) => %i\n", Host::GetCurrentProcessID(), Host::GetCurrentThreadID(), mutex_ptr, err);
return err;
}
int
Mutex::Lock()
{
return Mutex::Lock (&m_mutex);
}
int
Mutex::TryLock()
{
return Mutex::TryLock (&m_mutex);
}
int
Mutex::Unlock()
{
return Mutex::Unlock (&m_mutex);
}