rayelliott
/
barrier
mirror of https://github.com/debauchee/barrier.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Use standard mutex APIs instead of the home-grown wrapper (#410) 

Use standard mutex APIs instead of the home-grown wrapper
This commit is contained in:
Adrian Lucrèce Céleste 2019-08-22 15:01:35 -04:00 committed by GitHub
parent 7bb541ea91 b0e415de03
commit fca05b9163
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
13 changed files with 125 additions and 152 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
src/lib/arch/IArchString.cpp
View File

@ -24,7 +24,9 @@
#include <cstring>
#include <cstdlib>
static ArchMutex s_mutex = NULL;
#include <mutex>
std::mutex s_mutex;
//
// use C library non-reentrant multibyte conversion with mutex
@ -32,16 +34,14 @@ static ArchMutex s_mutex = NULL;
IArchString::~IArchString()
{
if (s_mutex != NULL) {
ARCH->closeMutex(s_mutex);
s_mutex = NULL;
}
}
int
IArchString::convStringWCToMB(char* dst,
const wchar_t* src, UInt32 n, bool* errors)
{
std::lock_guard<std::mutex> lock(s_mutex);
ptrdiff_t len = 0;
bool dummyErrors;
@ -49,12 +49,6 @@ IArchString::convStringWCToMB(char* dst,
errors = &dummyErrors;
}
if (s_mutex == NULL) {
s_mutex = ARCH->newMutex();
}
ARCH->lockMutex(s_mutex);
if (dst == NULL) {
char dummy[MB_LEN_MAX];
for (const wchar_t* scan = src; n > 0; ++scan, --n) {
@ -89,7 +83,6 @@ IArchString::convStringWCToMB(char* dst,
}
len = dst - dst0;
}
ARCH->unlockMutex(s_mutex);
return (int)len;
}
@ -98,6 +91,8 @@ int
IArchString::convStringMBToWC(wchar_t* dst,
const char* src, UInt32 n_param, bool* errors)
{
std::lock_guard<std::mutex> lock(s_mutex);
ptrdiff_t n = (ptrdiff_t)n_param; // fix compiler warning
ptrdiff_t len = 0;
wchar_t dummy;
@ -107,12 +102,6 @@ IArchString::convStringMBToWC(wchar_t* dst,
errors = &dummyErrors;
}
if (s_mutex == NULL) {
s_mutex = ARCH->newMutex();
}
ARCH->lockMutex(s_mutex);
if (dst == NULL) {
for (const char* scan = src; n > 0; ) {
ptrdiff_t mblen = mbtowc(&dummy, scan, n);
@ -184,7 +173,6 @@ IArchString::convStringMBToWC(wchar_t* dst,
}
len = dst - dst0;
}
ARCH->unlockMutex(s_mutex);
return (int)len;
}

90
src/lib/arch/unix/ArchMultithreadPosix.cpp
View File

@ -114,9 +114,6 @@ ArchMultithreadPosix::ArchMultithreadPosix() :
m_signalUserData[i] = NULL;
}
// create mutex for thread list
m_threadMutex = newMutex();
// create thread for calling (main) thread and add it to our
// list. no need to lock the mutex since we're the only thread.
m_mainThread = new ArchThreadImpl;
@ -153,26 +150,22 @@ ArchMultithreadPosix::~ArchMultithreadPosix()
{
assert(s_instance != NULL);
closeMutex(m_threadMutex);
s_instance = NULL;
}
void
ArchMultithreadPosix::setNetworkDataForCurrentThread(void* data)
{
lockMutex(m_threadMutex);
std::lock_guard<std::mutex> lock(m_threadMutex);
ArchThreadImpl* thread = find(pthread_self());
thread->m_networkData = data;
unlockMutex(m_threadMutex);
}
void*
ArchMultithreadPosix::getNetworkDataForThread(ArchThread thread)
{
lockMutex(m_threadMutex);
void* data = thread->m_networkData;
unlockMutex(m_threadMutex);
return data;
std::lock_guard<std::mutex> lock(m_threadMutex);
return thread->m_networkData;
}
ArchMultithreadPosix*
@ -356,7 +349,8 @@ ArchMultithreadPosix::newThread(ThreadFunc func, void* data)
#endif
}
lockMutex(m_threadMutex);
// note that the child thread will wait until we release this mutex
std::lock_guard<std::mutex> lock(m_threadMutex);
// create thread impl for new thread
ArchThreadImpl* thread = new ArchThreadImpl;
@ -387,18 +381,15 @@ ArchMultithreadPosix::newThread(ThreadFunc func, void* data)
refThread(thread);
}
// note that the child thread will wait until we release this mutex
unlockMutex(m_threadMutex);
return thread;
}
ArchThread
ArchMultithreadPosix::newCurrentThread()
{
lockMutex(m_threadMutex);
std::lock_guard<std::mutex> lock(m_threadMutex);
ArchThreadImpl* thread = find(pthread_self());
unlockMutex(m_threadMutex);
assert(thread != NULL);
return thread;
}
@ -416,10 +407,11 @@ ArchMultithreadPosix::closeThread(ArchThread thread)
}
// remove thread from list
lockMutex(m_threadMutex);
{
std::lock_guard<std::mutex> lock(m_threadMutex);
assert(findNoRef(thread->m_thread) == thread);
erase(thread);
unlockMutex(m_threadMutex);
}
// done with thread
delete thread;
@ -440,12 +432,14 @@ ArchMultithreadPosix::cancelThread(ArchThread thread)
// set cancel and wakeup flags if thread can be cancelled
bool wakeup = false;
lockMutex(m_threadMutex);
{
std::lock_guard<std::mutex> lock(m_threadMutex);
if (!thread->m_exited && !thread->m_cancelling) {
thread->m_cancel = true;
wakeup = true;
}
unlockMutex(m_threadMutex);
}
// force thread to exit system calls if wakeup is true
if (wakeup) {
@ -465,9 +459,11 @@ void
ArchMultithreadPosix::testCancelThread()
{
// find current thread
lockMutex(m_threadMutex);
ArchThreadImpl* thread = findNoRef(pthread_self());
unlockMutex(m_threadMutex);
ArchThreadImpl* thread = nullptr;
{
std::lock_guard<std::mutex> lock(m_threadMutex);
thread = findNoRef(pthread_self());
}
// test cancel on thread
testCancelThreadImpl(thread);
@ -478,21 +474,22 @@ ArchMultithreadPosix::wait(ArchThread target, double timeout)
{
assert(target != NULL);
lockMutex(m_threadMutex);
ArchThreadImpl* self = nullptr;
{
std::lock_guard<std::mutex> lock(m_threadMutex);
// find current thread
ArchThreadImpl* self = findNoRef(pthread_self());
self = findNoRef(pthread_self());
// ignore wait if trying to wait on ourself
if (target == self) {
unlockMutex(m_threadMutex);
return false;
}
// ref the target so it can't go away while we're watching it
refThread(target);
unlockMutex(m_threadMutex);
}
try {
// do first test regardless of timeout
@ -538,19 +535,15 @@ ArchMultithreadPosix::isSameThread(ArchThread thread1, ArchThread thread2)
bool
ArchMultithreadPosix::isExitedThread(ArchThread thread)
{
lockMutex(m_threadMutex);
bool exited = thread->m_exited;
unlockMutex(m_threadMutex);
return exited;
std::lock_guard<std::mutex> lock(m_threadMutex);
return thread->m_exited;
}
void*
ArchMultithreadPosix::getResultOfThread(ArchThread thread)
{
lockMutex(m_threadMutex);
void* result = thread->m_result;
unlockMutex(m_threadMutex);
return result;
std::lock_guard<std::mutex> lock(m_threadMutex);
return thread->m_result;
}
IArchMultithread::ThreadID
@ -563,16 +556,15 @@ void
ArchMultithreadPosix::setSignalHandler(
ESignal signal, SignalFunc func, void* userData)
{
lockMutex(m_threadMutex);
std::lock_guard<std::mutex> lock(m_threadMutex);
m_signalFunc[signal] = func;
m_signalUserData[signal] = userData;
unlockMutex(m_threadMutex);
}
void
ArchMultithreadPosix::raiseSignal(ESignal signal)
{
lockMutex(m_threadMutex);
std::lock_guard<std::mutex> lock(m_threadMutex);
if (m_signalFunc[signal] != NULL) {
m_signalFunc[signal](signal, m_signalUserData[signal]);
pthread_kill(m_mainThread->m_thread, SIGWAKEUP);
@ -580,7 +572,6 @@ ArchMultithreadPosix::raiseSignal(ESignal signal)
else if (signal == kINTERRUPT || signal == kTERMINATE) {
ARCH->cancelThread(m_mainThread);
}
unlockMutex(m_threadMutex);
}
void
@ -677,15 +668,15 @@ ArchMultithreadPosix::testCancelThreadImpl(ArchThreadImpl* thread)
{
assert(thread != NULL);
std::lock_guard<std::mutex> lock(m_threadMutex);
// update cancel state
lockMutex(m_threadMutex);
bool cancel = false;
if (thread->m_cancel && !thread->m_cancelling) {
thread->m_cancelling = true;
thread->m_cancel = false;
cancel = true;
}
unlockMutex(m_threadMutex);
// unwind thread's stack if cancelling
if (cancel) {
@ -717,8 +708,9 @@ ArchMultithreadPosix::doThreadFunc(ArchThread thread)
setPriorityOfThread(thread, 1);
// wait for parent to initialize this object
lockMutex(m_threadMutex);
unlockMutex(m_threadMutex);
{
std::lock_guard<std::mutex> lock(m_threadMutex);
}
void* result = NULL;
try {
@ -731,18 +723,20 @@ ArchMultithreadPosix::doThreadFunc(ArchThread thread)
}
catch (...) {
// note -- don't catch (...) to avoid masking bugs
lockMutex(m_threadMutex);
{
std::lock_guard<std::mutex> lock(m_threadMutex);
thread->m_exited = true;
unlockMutex(m_threadMutex);
}
closeThread(thread);
throw;
}
// thread has exited
lockMutex(m_threadMutex);
{
std::lock_guard<std::mutex> lock(m_threadMutex);
thread->m_result = result;
thread->m_exited = true;
unlockMutex(m_threadMutex);
}
// done with thread
closeThread(thread);

3
src/lib/arch/unix/ArchMultithreadPosix.h
View File

@ -22,6 +22,7 @@
#include "common/stdlist.h"
#include <pthread.h>
#include <mutex>
#define ARCH_MULTITHREAD ArchMultithreadPosix
@ -104,7 +105,7 @@ private:
bool m_newThreadCalled;
ArchMutex m_threadMutex;
std::mutex m_threadMutex;
ArchThread m_mainThread;
ThreadList m_threadList;
ThreadID m_nextID;

24
src/lib/base/EventQueue.cpp
View File

@ -90,7 +90,6 @@ EventQueue::EventQueue() :
m_readyMutex(new Mutex),
m_readyCondVar(new CondVar<bool>(m_readyMutex, false))
{
m_mutex = ARCH->newMutex();
ARCH->setSignalHandler(Arch::kINTERRUPT, &interrupt, this);
ARCH->setSignalHandler(Arch::kTERMINATE, &interrupt, this);
m_buffer = new SimpleEventQueueBuffer;
@ -104,7 +103,6 @@ EventQueue::~EventQueue()
ARCH->setSignalHandler(Arch::kINTERRUPT, NULL, NULL);
ARCH->setSignalHandler(Arch::kTERMINATE, NULL, NULL);
ARCH->closeMutex(m_mutex);
}
void
@ -136,7 +134,7 @@ EventQueue::loop()
Event::Type
EventQueue::registerTypeOnce(Event::Type& type, const char* name)
{
ArchMutexLock lock(m_mutex);
std::lock_guard<std::mutex> lock(m_mutex);
if (type == Event::kUnknown) {
m_typeMap.insert(std::make_pair(m_nextType, name));
m_nameMap.insert(std::make_pair(name, m_nextType));
@ -176,7 +174,7 @@ EventQueue::getTypeName(Event::Type type)
void
EventQueue::adoptBuffer(IEventQueueBuffer* buffer)
{
ArchMutexLock lock(m_mutex);
std::lock_guard<std::mutex> lock(m_mutex);
LOG((CLOG_DEBUG "adopting new buffer"));
@ -261,7 +259,7 @@ retry:
case IEventQueueBuffer::kUser:
{
ArchMutexLock lock(m_mutex);
std::lock_guard<std::mutex> lock(m_mutex);
event = removeEvent(dataID);
return true;
}
@ -316,7 +314,7 @@ EventQueue::addEvent(const Event& event)
void
EventQueue::addEventToBuffer(const Event& event)
{
ArchMutexLock lock(m_mutex);
std::lock_guard<std::mutex> lock(m_mutex);
// store the event's data locally
UInt32 eventID = saveEvent(event);
@ -338,7 +336,7 @@ EventQueue::newTimer(double duration, void* target)
if (target == NULL) {
target = timer;
}
ArchMutexLock lock(m_mutex);
std::lock_guard<std::mutex> lock(m_mutex);
m_timers.insert(timer);
// initial duration is requested duration plus whatever's on
// the clock currently because the latter will be subtracted
@ -357,7 +355,7 @@ EventQueue::newOneShotTimer(double duration, void* target)
if (target == NULL) {
target = timer;
}
ArchMutexLock lock(m_mutex);
std::lock_guard<std::mutex> lock(m_mutex);
m_timers.insert(timer);
// initial duration is requested duration plus whatever's on
// the clock currently because the latter will be subtracted
@ -370,7 +368,7 @@ EventQueue::newOneShotTimer(double duration, void* target)
void
EventQueue::deleteTimer(EventQueueTimer* timer)
{
ArchMutexLock lock(m_mutex);
std::lock_guard<std::mutex> lock(m_mutex);
for (TimerQueue::iterator index = m_timerQueue.begin();
index != m_timerQueue.end(); ++index) {
if (index->getTimer() == timer) {
@ -388,7 +386,7 @@ EventQueue::deleteTimer(EventQueueTimer* timer)
void
EventQueue::adoptHandler(Event::Type type, void* target, IEventJob* handler)
{
ArchMutexLock lock(m_mutex);
std::lock_guard<std::mutex> lock(m_mutex);
IEventJob*& job = m_handlers[target][type];
delete job;
job = handler;
@ -399,7 +397,7 @@ EventQueue::removeHandler(Event::Type type, void* target)
{
IEventJob* handler = NULL;
{
ArchMutexLock lock(m_mutex);
std::lock_guard<std::mutex> lock(m_mutex);
HandlerTable::iterator index = m_handlers.find(target);
if (index != m_handlers.end()) {
TypeHandlerTable& typeHandlers = index->second;
@ -418,7 +416,7 @@ EventQueue::removeHandlers(void* target)
{
std::vector<IEventJob*> handlers;
{
ArchMutexLock lock(m_mutex);
std::lock_guard<std::mutex> lock(m_mutex);
HandlerTable::iterator index = m_handlers.find(target);
if (index != m_handlers.end()) {
// copy to handlers array and clear table for target
@ -447,7 +445,7 @@ EventQueue::isEmpty() const
IEventJob*
EventQueue::getHandler(Event::Type type, void* target) const
{
ArchMutexLock lock(m_mutex);
std::lock_guard<std::mutex> lock(m_mutex);
HandlerTable::const_iterator index = m_handlers.find(target);
if (index != m_handlers.end()) {
const TypeHandlerTable& typeHandlers = index->second;

5
src/lib/base/EventQueue.h
View File

@ -28,10 +28,9 @@
#include "common/stdset.h"
#include "base/NonBlockingStream.h"
#include <mutex>
#include <queue>
class Mutex;
//! Event queue
/*!
An event queue that implements the platform independent parts and
@ -114,7 +113,7 @@ private:
typedef std::map<void*, TypeHandlerTable> HandlerTable;
int m_systemTarget;
ArchMutex m_mutex;
mutable std::mutex m_mutex;
// registered events
Event::Type m_nextType;

16
src/lib/base/Log.cpp
View File

@ -63,9 +63,6 @@ Log::Log()
{
assert(s_log == NULL);
// create mutex for multithread safe operation
m_mutex = ARCH->newMutex();
// other initalization
m_maxPriority = g_defaultMaxPriority;
m_maxNewlineLength = 0;
@ -90,7 +87,6 @@ Log::~Log()
index != m_alwaysOutputters.end(); ++index) {
delete *index;
}
ARCH->closeMutex(m_mutex);
}
Log*
@ -214,7 +210,7 @@ Log::insert(ILogOutputter* outputter, bool alwaysAtHead)
{
assert(outputter != NULL);
ArchMutexLock lock(m_mutex);
std::lock_guard<std::mutex> lock(m_mutex);
if (alwaysAtHead) {
m_alwaysOutputters.push_front(outputter);
}
@ -237,7 +233,7 @@ Log::insert(ILogOutputter* outputter, bool alwaysAtHead)
void
Log::remove(ILogOutputter* outputter)
{
ArchMutexLock lock(m_mutex);
std::lock_guard<std::mutex> lock(m_mutex);
m_outputters.remove(outputter);
m_alwaysOutputters.remove(outputter);
}
@ -245,7 +241,7 @@ Log::remove(ILogOutputter* outputter)
void
Log::pop_front(bool alwaysAtHead)
{
ArchMutexLock lock(m_mutex);
std::lock_guard<std::mutex> lock(m_mutex);
OutputterList* list = alwaysAtHead ? &m_alwaysOutputters : &m_outputters;
if (!list->empty()) {
delete list->front();
@ -271,14 +267,14 @@ Log::setFilter(const char* maxPriority)
void
Log::setFilter(int maxPriority)
{
ArchMutexLock lock(m_mutex);
std::lock_guard<std::mutex> lock(m_mutex);
m_maxPriority = maxPriority;
}
int
Log::getFilter() const
{
ArchMutexLock lock(m_mutex);
std::lock_guard<std::mutex> lock(m_mutex);
return m_maxPriority;
}
@ -289,7 +285,7 @@ Log::output(ELevel priority, char* msg)
assert(msg != NULL);
if (!msg) return;
ArchMutexLock lock(m_mutex);
std::lock_guard<std::mutex> lock(m_mutex);
OutputterList::const_iterator i;

3
src/lib/base/Log.h
View File

@ -24,6 +24,7 @@
#include "common/stdlist.h"
#include <stdarg.h>
#include <mutex>
#define CLOG (Log::getInstance())
#define BYE "\nTry `%s --help' for more information."
@ -132,7 +133,7 @@ private:
static Log* s_log;
ArchMutex m_mutex;
mutable std::mutex m_mutex;
OutputterList m_outputters;
OutputterList m_alwaysOutputters;
int m_maxNewlineLength;

17
src/lib/ipc/IpcClientProxy.cpp
View File

@ -34,8 +34,6 @@ IpcClientProxy::IpcClientProxy(barrier::IStream& stream, IEventQueue* events) :
m_stream(stream),
m_clientType(kIpcClientUnknown),
m_disconnecting(false),
m_readMutex(ARCH->newMutex()),
m_writeMutex(ARCH->newMutex()),
m_events(events)
{
m_events->adoptHandler(
@ -71,14 +69,11 @@ IpcClientProxy::~IpcClientProxy()
m_events->forIStream().outputShutdown(), m_stream.getEventTarget());
// don't delete the stream while it's being used.
ARCH->lockMutex(m_readMutex);
ARCH->lockMutex(m_writeMutex);
{
std::lock_guard<std::mutex> lock_read(m_readMutex);
std::lock_guard<std::mutex> lock_write(m_writeMutex);
delete &m_stream;
ARCH->unlockMutex(m_readMutex);
ARCH->unlockMutex(m_writeMutex);
ARCH->closeMutex(m_readMutex);
ARCH->closeMutex(m_writeMutex);
}
}
void
@ -99,7 +94,7 @@ void
IpcClientProxy::handleData(const Event&, void*)
{
// don't allow the dtor to destroy the stream while we're using it.
ArchMutexLock lock(m_readMutex);
std::lock_guard<std::mutex> lock(m_readMutex);
LOG((CLOG_DEBUG "start ipc handle data"));
@ -139,7 +134,7 @@ IpcClientProxy::send(const IpcMessage& message)
// don't allow other threads to write until we've finished the entire
// message. stream write is locked, but only for that single write.
// also, don't allow the dtor to destroy the stream while we're using it.
ArchMutexLock lock(m_writeMutex);
std::lock_guard<std::mutex> lock(m_writeMutex);
LOG((CLOG_DEBUG4 "ipc write: %d", message.type()));

6
src/lib/ipc/IpcClientProxy.h
View File

@ -23,6 +23,8 @@
#include "base/EventTypes.h"
#include "base/Event.h"
#include <mutex>
namespace barrier { class IStream; }
class IpcMessage;
class IpcCommandMessage;
@ -49,7 +51,7 @@ private:
barrier::IStream& m_stream;
EIpcClientType m_clientType;
bool m_disconnecting;
ArchMutex m_readMutex;
ArchMutex m_writeMutex;
std::mutex m_readMutex;
std::mutex m_writeMutex;
IEventQueue* m_events;
};

14
src/lib/ipc/IpcLogOutputter.cpp
View File

@ -39,7 +39,6 @@ enum EIpcLogOutputter {
IpcLogOutputter::IpcLogOutputter(IpcServer& ipcServer, EIpcClientType clientType, bool useThread) :
m_ipcServer(ipcServer),
m_bufferMutex(ARCH->newMutex()),
m_sending(false),
m_bufferThread(nullptr),
m_running(false),
@ -52,8 +51,7 @@ IpcLogOutputter::IpcLogOutputter(IpcServer& ipcServer, EIpcClientType clientType
m_bufferRateTimeLimit(kBufferRateTimeLimit),
m_bufferWriteCount(0),
m_bufferRateStart(ARCH->time()),
m_clientType(clientType),
m_runningMutex(ARCH->newMutex())
m_clientType(clientType)
{
if (useThread) {
m_bufferThread = new Thread(new TMethodJob<IpcLogOutputter>(
@ -65,8 +63,6 @@ IpcLogOutputter::~IpcLogOutputter()
{
close();
ARCH->closeMutex(m_bufferMutex);
if (m_bufferThread != nullptr) {
m_bufferThread->cancel();
m_bufferThread->wait();
@ -86,7 +82,7 @@ void
IpcLogOutputter::close()
{
if (m_bufferThread != nullptr) {
ArchMutexLock lock(m_runningMutex);
std::lock_guard<std::mutex> lock(m_runningMutex);
m_running = false;
notifyBuffer();
m_bufferThread->wait(5);
@ -116,7 +112,7 @@ IpcLogOutputter::write(ELevel, const char* text)
void
IpcLogOutputter::appendBuffer(const String& text)
{
ArchMutexLock lock(m_bufferMutex);
std::lock_guard<std::mutex> lock(m_bufferMutex);
double elapsed = ARCH->time() - m_bufferRateStart;
if (elapsed < m_bufferRateTimeLimit) {
@ -143,7 +139,7 @@ IpcLogOutputter::appendBuffer(const String& text)
bool
IpcLogOutputter::isRunning()
{
ArchMutexLock lock(m_runningMutex);
std::lock_guard<std::mutex> lock(m_runningMutex);
return m_running;
}
@ -180,7 +176,7 @@ IpcLogOutputter::notifyBuffer()
String
IpcLogOutputter::getChunk(size_t count)
{
ArchMutexLock lock(m_bufferMutex);
std::lock_guard<std::mutex> lock(m_bufferMutex);
if (m_buffer.size() < count) {
count = m_buffer.size();

5
src/lib/ipc/IpcLogOutputter.h
View File

@ -24,6 +24,7 @@
#include "ipc/Ipc.h"
#include <deque>
#include <mutex>
class IpcServer;
class Event;
@ -100,7 +101,7 @@ private:
IpcServer& m_ipcServer;
Buffer m_buffer;
ArchMutex m_bufferMutex;
std::mutex m_bufferMutex;
bool m_sending;
Thread* m_bufferThread;
bool m_running;
@ -115,5 +116,5 @@ private:
UInt16 m_bufferWriteCount;
double m_bufferRateStart;
EIpcClientType m_clientType;
ArchMutex m_runningMutex;
std::mutex m_runningMutex;
};

21
src/lib/ipc/IpcServer.cpp
View File

@ -56,7 +56,6 @@ IpcServer::init()
{
m_socket = new TCPListenSocket(m_events, m_socketMultiplexer, IArchNetwork::kINET);
m_clientsMutex = ARCH->newMutex();
m_address.resolve();
m_events->adoptHandler(
@ -75,14 +74,14 @@ IpcServer::~IpcServer()
delete m_socket;
}
ARCH->lockMutex(m_clientsMutex);
{
std::lock_guard<std::mutex> lock(m_clientsMutex);
ClientList::iterator it;
for (it = m_clients.begin(); it != m_clients.end(); it++) {
deleteClient(*it);
}
m_clients.clear();
ARCH->unlockMutex(m_clientsMutex);
ARCH->closeMutex(m_clientsMutex);
}
m_events->removeHandler(m_events->forIListenSocket().connecting(), m_socket);
}
@ -103,10 +102,12 @@ IpcServer::handleClientConnecting(const Event&, void*)
LOG((CLOG_DEBUG "accepted ipc client connection"));
ARCH->lockMutex(m_clientsMutex);
IpcClientProxy* proxy = new IpcClientProxy(*stream, m_events);
IpcClientProxy* proxy = nullptr;
{
std::lock_guard<std::mutex> lock(m_clientsMutex);
proxy = new IpcClientProxy(*stream, m_events);
m_clients.push_back(proxy);
ARCH->unlockMutex(m_clientsMutex);
}
m_events->adoptHandler(
m_events->forIpcClientProxy().disconnected(), proxy,
@ -127,7 +128,7 @@ IpcServer::handleClientDisconnected(const Event& e, void*)
{
IpcClientProxy* proxy = static_cast<IpcClientProxy*>(e.getTarget());
ArchMutexLock lock(m_clientsMutex);
std::lock_guard<std::mutex> lock(m_clientsMutex);
m_clients.remove(proxy);
deleteClient(proxy);
@ -153,7 +154,7 @@ IpcServer::deleteClient(IpcClientProxy* proxy)
bool
IpcServer::hasClients(EIpcClientType clientType) const
{
ArchMutexLock lock(m_clientsMutex);
std::lock_guard<std::mutex> lock(m_clientsMutex);
if (m_clients.empty()) {
return false;
@ -175,7 +176,7 @@ IpcServer::hasClients(EIpcClientType clientType) const
void
IpcServer::send(const IpcMessage& message, EIpcClientType filterType)
{
ArchMutexLock lock(m_clientsMutex);
std::lock_guard<std::mutex> lock(m_clientsMutex);
ClientList::iterator it;
for (it = m_clients.begin(); it != m_clients.end(); it++) {

3
src/lib/ipc/IpcServer.h
View File

@ -25,6 +25,7 @@
#include "base/EventTypes.h"
#include <list>
#include <mutex>
class Event;
class IpcClientProxy;
@ -79,7 +80,7 @@ private:
TCPListenSocket* m_socket;
NetworkAddress m_address;
ClientList m_clients;
ArchMutex m_clientsMutex;
mutable std::mutex m_clientsMutex;
#ifdef TEST_ENV
public: