#include "configreader.h"
#include "inspstring.h"
#include "protocol.h"
+#include "threadengine.h"
#ifndef PATH_MAX
#warning Potentially broken system, PATH_MAX undefined
*/
std::map<BufferedSocket*,BufferedSocket*> SocketCull;
- Mutex* RehashFinishMutex;
+ Mutex RehashFinishMutex;
/** Globally accessible fake user record. This is used to force mode changes etc across s2s, etc.. bit ugly, but.. better than how this was done in 1.1
* Reason for it:
*/
ThreadEngine* Threads;
- /** Mutex engine, handles mutexes for threading where required
- */
- MutexFactory* Mutexes;
-
/** The thread/class used to read config files in REHASH and on startup
*/
ConfigReaderThread* ConfigThread;
#include "inspircd_config.h"
#include "base.h"
-class InspIRCd;
-class Thread;
-
-/** The ThreadEngine class has the responsibility of initialising
- * Thread derived classes. It does this by creating operating system
- * level threads which are then associated with the class transparently.
- * This allows Thread classes to be derived without needing to know how
- * the OS implements threads. You should ensure that any sections of code
- * that use threads are threadsafe and do not interact with any other
- * parts of the code which are NOT known threadsafe! If you really MUST
- * access non-threadsafe code from a Thread, use the Mutex class to wrap
- * access to the code carefully.
- */
-class CoreExport ThreadEngine : public Extensible
-{
- protected:
-
- /** Creator instance
- */
- InspIRCd* ServerInstance;
-
- public:
-
- /** Constructor.
- * @param Instance Creator object
- */
- ThreadEngine(InspIRCd* Instance);
-
- /** Destructor
- */
- virtual ~ThreadEngine();
-
- /** Create a new thread. This takes an already allocated
- * Thread* pointer and initializes it to use this threading
- * engine. On failure, this function may throw a CoreException.
- * @param thread_to_init Pointer to a newly allocated Thread
- * derived object.
- */
- virtual void Start(Thread* thread_to_init) = 0;
-
- /** Returns the thread engine's name for display purposes
- * @return The thread engine name
- */
- virtual const std::string GetName()
- {
- return "<pure-virtual>";
- }
-};
-
-/** The Mutex class represents a mutex, which can be used to keep threads
- * properly synchronised. Use mutexes sparingly, as they are a good source
- * of thread deadlocks etc, and should be avoided except where absolutely
- * neccessary. Note that the internal behaviour of the mutex varies from OS
- * to OS depending on the thread engine, for example in windows a Mutex
- * in InspIRCd uses critical sections, as they are faster and simpler to
- * manage.
- */
-class CoreExport Mutex
-{
- protected:
- /** Enable or disable the Mutex. This method has somewhat confusing
- * wording (e.g. the function name and parameters) so it is protected
- * in preference of the Lock() and Unlock() methods which are user-
- * accessible.
- *
- * @param enable True to enable the mutex (enter it) and false to
- * disable the mutex (leave it).
- */
- virtual void Enable(bool enable) = 0;
- public:
-
- /** Constructor.
- */
- Mutex();
-
- /** Enter/enable the mutex lock.
- */
- void Lock() { Enable(true); }
-
- /** Leave/disable the mutex lock.
- */
- void Unlock() { Enable(false); }
-
- /** Destructor
- */
- ~Mutex() { }
-};
-
-class CoreExport ThreadData
-{
- public:
- virtual void FreeThread(Thread* thread) { }
-};
-
/** Derive from this class to implement your own threaded sections of
* code. Be sure to keep your code thread-safe and not prone to deadlocks
* and race conditions if you MUST use threading!
}
};
-
-
#endif
#include <pthread.h>
#include "inspircd_config.h"
#include "base.h"
-#include "threadengine.h"
class InspIRCd;
+class Thread;
-class CoreExport PThreadEngine : public ThreadEngine
+/** The ThreadEngine class has the responsibility of initialising
+ * Thread derived classes. It does this by creating operating system
+ * level threads which are then associated with the class transparently.
+ * This allows Thread classes to be derived without needing to know how
+ * the OS implements threads. You should ensure that any sections of code
+ * that use threads are threadsafe and do not interact with any other
+ * parts of the code which are NOT known threadsafe! If you really MUST
+ * access non-threadsafe code from a Thread, use the Mutex class to wrap
+ * access to the code carefully.
+ */
+class CoreExport ThreadEngine : public Extensible
{
public:
- PThreadEngine(InspIRCd* Instance);
+ /** Constructor.
+ * @param Instance Creator object
+ */
+ ThreadEngine(InspIRCd* Instance);
- virtual ~PThreadEngine();
+ /** Destructor
+ */
+ virtual ~ThreadEngine();
+ /** Create a new thread. This takes an already allocated
+ * Thread* pointer and initializes it to use this threading
+ * engine. On failure, this function may throw a CoreException.
+ * @param thread_to_init Pointer to a newly allocated Thread
+ * derived object.
+ */
void Start(Thread* thread_to_init);
- void FreeThread(Thread* thread);
-
+ /** Returns the thread engine's name for display purposes
+ * @return The thread engine name
+ */
const std::string GetName()
{
return "posix-thread";
}
};
-class CoreExport ThreadEngineFactory : public classbase
-{
- public:
- ThreadEngine* Create(InspIRCd* ServerInstance)
- {
- return new PThreadEngine(ServerInstance);
- }
-};
-
-class CoreExport PThreadData : public ThreadData
+class CoreExport ThreadData
{
public:
pthread_t pthread_id;
void FreeThread(Thread* toFree);
};
-class CoreExport PosixMutex : public Mutex
+/** The Mutex class represents a mutex, which can be used to keep threads
+ * properly synchronised. Use mutexes sparingly, as they are a good source
+ * of thread deadlocks etc, and should be avoided except where absolutely
+ * neccessary. Note that the internal behaviour of the mutex varies from OS
+ * to OS depending on the thread engine, for example in windows a Mutex
+ * in InspIRCd uses critical sections, as they are faster and simpler to
+ * manage.
+ */
+class CoreExport Mutex
{
private:
pthread_mutex_t putex;
public:
- PosixMutex();
- virtual void Enable(bool enable);
- ~PosixMutex();
-};
-
-class CoreExport MutexFactory : public Extensible
-{
- protected:
- InspIRCd* ServerInstance;
- public:
- MutexFactory(InspIRCd* Instance);
- Mutex* CreateMutex();
+ /** Constructor.
+ */
+ Mutex()
+ {
+ pthread_mutex_init(&putex, NULL);
+ }
+ /** Enter/enable the mutex lock.
+ */
+ void Lock()
+ {
+ pthread_mutex_lock(&putex);
+ }
+ /** Leave/disable the mutex lock.
+ */
+ void Unlock()
+ {
+ pthread_mutex_unlock(&putex);
+ }
+ /** Destructor
+ */
+ ~Mutex()
+ {
+ pthread_mutex_destroy(&putex);
+ }
};
#endif
#include "inspircd_config.h"
#include "base.h"
-#include "threadengine.h"
class InspIRCd;
+class Thread;
-class CoreExport Win32ThreadEngine : public ThreadEngine
+/** The ThreadEngine class has the responsibility of initialising
+ * Thread derived classes. It does this by creating operating system
+ * level threads which are then associated with the class transparently.
+ * This allows Thread classes to be derived without needing to know how
+ * the OS implements threads. You should ensure that any sections of code
+ * that use threads are threadsafe and do not interact with any other
+ * parts of the code which are NOT known threadsafe! If you really MUST
+ * access non-threadsafe code from a Thread, use the Mutex class to wrap
+ * access to the code carefully.
+ */
+class CoreExport ThreadEngine : public Extensible
{
public:
- Win32ThreadEngine(InspIRCd* Instance);
+ ThreadEngine(InspIRCd* Instance);
- virtual ~Win32ThreadEngine();
+ virtual ~ThreadEngine();
static DWORD WINAPI Entry(void* parameter);
+ /** Create a new thread. This takes an already allocated
+ * Thread* pointer and initializes it to use this threading
+ * engine. On failure, this function may throw a CoreException.
+ * @param thread_to_init Pointer to a newly allocated Thread
+ * derived object.
+ */
void Start(Thread* thread_to_init);
+ /** Returns the thread engine's name for display purposes
+ * @return The thread engine name
+ */
const std::string GetName()
{
return "windows-thread";
}
};
-class CoreExport ThreadEngineFactory : public classbase
-{
- public:
- ThreadEngine* Create(InspIRCd* ServerInstance)
- {
- return new Win32ThreadEngine(ServerInstance);
- }
-};
-
-class CoreExport Win32ThreadData : public ThreadData
+class CoreExport ThreadData
{
public:
HANDLE handle;
void FreeThread(Thread* toFree);
};
-class CoreExport Win32Mutex : public Mutex
+/** The Mutex class represents a mutex, which can be used to keep threads
+ * properly synchronised. Use mutexes sparingly, as they are a good source
+ * of thread deadlocks etc, and should be avoided except where absolutely
+ * neccessary. Note that the internal behaviour of the mutex varies from OS
+ * to OS depending on the thread engine, for example in windows a Mutex
+ * in InspIRCd uses critical sections, as they are faster and simpler to
+ * manage.
+ */
+class CoreExport Mutex
{
private:
CRITICAL_SECTION wutex;
public:
- Win32Mutex();
- virtual void Enable(bool enable);
- ~Win32Mutex();
-};
-
-class CoreExport MutexFactory : public Extensible
-{
- protected:
- InspIRCd* ServerInstance;
- public:
- MutexFactory(InspIRCd* Instance);
- virtual Mutex* CreateMutex();
+ Win32Mutex()
+ {
+ InitializeCriticalSection(&wutex);
+ }
+ void Lock()
+ {
+ EnterCriticalSection(&wutex);
+ }
+ void Unlock()
+ {
+ LeaveCriticalSection(&wutex);
+ }
+ ~Win32Mutex()
+ {
+ DeleteCriticalSection(&wutex);
+ }
};
#endif
/* Close logging */
this->Logs->CloseLogs();
DeleteZero(this->Logs);
-
- delete RehashFinishMutex;
}
void InspIRCd::Restart(const std::string &reason)
SE = SEF->Create(this);
delete SEF;
- ThreadEngineFactory* tef = new ThreadEngineFactory();
- this->Threads = tef->Create(this);
- delete tef;
- this->Mutexes = new MutexFactory(this);
+ this->Threads = new ThreadEngine(this);
/* Default implementation does nothing */
this->PI = new ProtocolInterface(this);
Exit(0);
}
- RehashFinishMutex = Mutexes->CreateMutex();
-
while (true)
{
#ifndef WIN32
#endif
/* Check if there is a config thread which has finished executing but has not yet been freed */
- RehashFinishMutex->Lock();
+ RehashFinishMutex.Lock();
if (this->ConfigThread && this->ConfigThread->GetExitFlag())
{
/* Rehash has completed */
delete ConfigThread;
ConfigThread = NULL;
}
- RehashFinishMutex->Unlock();
+ RehashFinishMutex.Unlock();
/* time() seems to be a pretty expensive syscall, so avoid calling it too much.
* Once per loop iteration is pleanty.
ModuleMsSQL(InspIRCd* Me)
: Module(Me), currid(0)
{
- LoggingMutex = ServerInstance->Mutexes->CreateMutex();
- ResultsMutex = ServerInstance->Mutexes->CreateMutex();
- QueueMutex = ServerInstance->Mutexes->CreateMutex();
+ LoggingMutex = new Mutex();
+ ResultsMutex = new Mutex();
+ QueueMutex = new Mutex();
ServerInstance->Modules->UseInterface("SQLutils");
int currid;
bool rehashing;
DispatcherThread* Dispatcher;
- Mutex* QueueMutex;
- Mutex* ResultsMutex;
- Mutex* LoggingMutex;
- Mutex* ConnMutex;
+ Mutex QueueMutex;
+ Mutex ResultsMutex;
+ Mutex LoggingMutex;
+ Mutex ConnMutex;
ModuleSQL(InspIRCd* Me);
~ModuleSQL();
*queryend = 0;
- Parent->QueueMutex->Lock();
+ Parent->QueueMutex.Lock();
req.query.q = query;
- Parent->QueueMutex->Unlock();
+ Parent->QueueMutex.Unlock();
if (!mysql_real_query(connection, req.query.q.data(), req.query.q.length()))
{
/* Put this new result onto the results queue.
* XXX: Remember to mutex the queue!
*/
- Parent->ResultsMutex->Lock();
+ Parent->ResultsMutex.Lock();
rq.push_back(r);
- Parent->ResultsMutex->Unlock();
+ Parent->ResultsMutex.Unlock();
}
else
{
r->dbid = this->GetID();
r->query = req.query.q;
- Parent->ResultsMutex->Lock();
+ Parent->ResultsMutex.Lock();
rq.push_back(r);
- Parent->ResultsMutex->Unlock();
+ Parent->ResultsMutex.Unlock();
}
/* Now signal the main thread that we've got a result to process.
if (!i->second->Connect())
{
/* XXX: MUTEX */
- Parent->LoggingMutex->Lock();
+ Parent->LoggingMutex.Lock();
ServerInstance->Logs->Log("m_mysql",DEFAULT,"SQL: Failed to connect database "+i->second->GetHost()+": Error: "+i->second->GetError());
i->second->SetEnable(false);
- Parent->LoggingMutex->Unlock();
+ Parent->LoggingMutex.Unlock();
}
}
}
void LoadDatabases(ConfigReader* conf, InspIRCd* ServerInstance, ModuleSQL* Parent)
{
- Parent->ConnMutex->Lock();
+ Parent->ConnMutex.Lock();
ClearOldConnections(conf);
for (int j =0; j < conf->Enumerate("database"); j++)
{
}
}
ConnectDatabases(ServerInstance, Parent);
- Parent->ConnMutex->Unlock();
+ Parent->ConnMutex.Unlock();
}
char FindCharId(const std::string &id)
if (ServerInstance->SE->Recv(this, &data, 1, 0) > 0)
{
- Parent->ConnMutex->Lock();
+ Parent->ConnMutex.Lock();
ConnMap::iterator iter = GetCharId(data);
- Parent->ConnMutex->Unlock();
+ Parent->ConnMutex.Unlock();
if (iter != Connections.end())
{
- Parent->ResultsMutex->Lock();
+ Parent->ResultsMutex.Lock();
ResultQueue::iterator n = iter->second->rq.begin();
- Parent->ResultsMutex->Unlock();
+ Parent->ResultsMutex.Unlock();
(*n)->Send();
delete (*n);
- Parent->ResultsMutex->Lock();
+ Parent->ResultsMutex.Lock();
iter->second->rq.pop_front();
- Parent->ResultsMutex->Unlock();
+ Parent->ResultsMutex.Unlock();
return true;
}
MessagePipe = new MySQLListener(this, ServerInstance, 0, "127.0.0.1");
#endif
- LoggingMutex = ServerInstance->Mutexes->CreateMutex();
- ConnMutex = ServerInstance->Mutexes->CreateMutex();
-
if (MessagePipe->GetFd() == -1)
{
- delete ConnMutex;
ServerInstance->Modules->DoneWithInterface("SQLutils");
throw ModuleException("m_mysql: unable to create ITC pipe");
}
else
{
- LoggingMutex->Lock();
+ LoggingMutex.Lock();
ServerInstance->Logs->Log("m_mysql", DEBUG, "MySQL: Interthread comms port is %d", MessagePipe->GetPort());
- LoggingMutex->Unlock();
+ LoggingMutex.Unlock();
}
Dispatcher = new DispatcherThread(ServerInstance, this);
ServerInstance->Threads->Start(Dispatcher);
- ResultsMutex = ServerInstance->Mutexes->CreateMutex();
- QueueMutex = ServerInstance->Mutexes->CreateMutex();
-
if (!ServerInstance->Modules->PublishFeature("SQL", this))
{
/* Tell worker thread to exit NOW,
* Automatically joins */
delete Dispatcher;
- delete LoggingMutex;
- delete ResultsMutex;
- delete QueueMutex;
- delete ConnMutex;
ServerInstance->Modules->DoneWithInterface("SQLutils");
throw ModuleException("m_mysql: Unable to publish feature 'SQL'");
}
ServerInstance->Modules->UnpublishInterface("SQL", this);
ServerInstance->Modules->UnpublishFeature("SQL");
ServerInstance->Modules->DoneWithInterface("SQLutils");
- delete LoggingMutex;
- delete ResultsMutex;
- delete QueueMutex;
- delete ConnMutex;
}
unsigned long ModuleSQL::NewID()
SQLrequest* req = (SQLrequest*)request;
/* XXX: Lock */
- QueueMutex->Lock();
+ QueueMutex.Lock();
ConnMap::iterator iter;
const char* returnval = NULL;
- ConnMutex->Lock();
+ ConnMutex.Lock();
if((iter = Connections.find(req->dbid)) != Connections.end())
{
req->id = NewID();
req->error.Id(SQL_BAD_DBID);
}
- ConnMutex->Unlock();
- QueueMutex->Unlock();
+ ConnMutex.Unlock();
+ QueueMutex.Unlock();
return returnval;
}
if (Parent->rehashing)
{
/* XXX: Lock */
- Parent->QueueMutex->Lock();
+ Parent->QueueMutex.Lock();
Parent->rehashing = false;
LoadDatabases(Parent->Conf, Parent->PublicServerInstance, Parent);
- Parent->QueueMutex->Unlock();
+ Parent->QueueMutex.Unlock();
/* XXX: Unlock */
}
SQLConnection* conn = NULL;
/* XXX: Lock here for safety */
- Parent->QueueMutex->Lock();
- Parent->ConnMutex->Lock();
+ Parent->QueueMutex.Lock();
+ Parent->ConnMutex.Lock();
for (ConnMap::iterator i = Connections.begin(); i != Connections.end(); i++)
{
if (i->second->queue.totalsize())
break;
}
}
- Parent->ConnMutex->Unlock();
- Parent->QueueMutex->Unlock();
+ Parent->ConnMutex.Unlock();
+ Parent->QueueMutex.Unlock();
/* XXX: Unlock */
/* Theres an item! */
conn->DoLeadingQuery();
/* XXX: Lock */
- Parent->QueueMutex->Lock();
+ Parent->QueueMutex.Lock();
conn->queue.pop();
- Parent->QueueMutex->Unlock();
+ Parent->QueueMutex.Unlock();
/* XXX: Unlock */
}
void RehashHandler::Call(const std::string &reason)
{
- Server->RehashFinishMutex->Lock();
+ Server->RehashFinishMutex.Lock();
Server->SNO->WriteToSnoMask('A', "Rehashing config file %s %s",ServerConfig::CleanFilename(Server->ConfigFileName), reason.c_str());
Server->RehashUsersAndChans();
FOREACH_MOD_I(Server, I_OnGarbageCollect, OnGarbageCollect());
Server->ConfigThread = new ConfigReaderThread(Server, false, "");
Server->Threads->Start(Server->ConfigThread);
}
- Server->RehashFinishMutex->Unlock();
+ Server->RehashFinishMutex.Unlock();
}
void InspIRCd::RehashServer()
cout << "Creating new ThreadEngine class...\n";
try
{
- ThreadEngineFactory* tef = new ThreadEngineFactory();
- te = tef->Create(ServerInstance);
- delete tef;
+ te = new ThreadEngine(ServerInstance);
}
catch (...)
{
#include "inspircd.h"
#include "threadengine.h"
-ThreadEngine::ThreadEngine(InspIRCd* Instance) : ServerInstance(Instance)
-{
-}
-ThreadEngine::~ThreadEngine()
-{
-}
-
-Mutex::Mutex()
-{
-}
#include <pthread.h>
#include <signal.h>
-PThreadEngine::PThreadEngine(InspIRCd* Instance) : ThreadEngine(Instance)
+ThreadEngine::ThreadEngine(InspIRCd* Instance)
{
}
}
-void PThreadEngine::Start(Thread* thread)
+void ThreadEngine::Start(Thread* thread)
{
- PThreadData* data = new PThreadData;
+ ThreadData* data = new ThreadData;
thread->state = data;
if (pthread_create(&data->pthread_id, NULL, entry_point, thread) != 0)
{
thread->state = NULL;
delete data;
- throw CoreException("Unable to create new PThreadEngine: " + std::string(strerror(errno)));
+ throw CoreException("Unable to create new thread: " + std::string(strerror(errno)));
}
}
-PThreadEngine::~PThreadEngine()
+ThreadEngine::~ThreadEngine()
{
}
-void PThreadData::FreeThread(Thread* thread)
+void ThreadData::FreeThread(Thread* thread)
{
thread->SetExitFlag(true);
pthread_join(pthread_id, NULL);
}
-
-MutexFactory::MutexFactory(InspIRCd* Instance) : ServerInstance(Instance)
-{
-}
-
-Mutex* MutexFactory::CreateMutex()
-{
- return new PosixMutex();
-}
-
-PosixMutex::PosixMutex() : Mutex()
-{
- pthread_mutex_init(&putex, NULL);
-}
-
-PosixMutex::~PosixMutex()
-{
- pthread_mutex_destroy(&putex);
-}
-
-void PosixMutex::Enable(bool enable)
-{
- if (enable)
- pthread_mutex_lock(&putex);
- else
- pthread_mutex_unlock(&putex);
-}
#include "inspircd.h"
#include "threadengines/threadengine_win32.h"
-Win32ThreadEngine::Win32ThreadEngine(InspIRCd* Instance) : ThreadEngine(Instance)
+ThreadEngine::ThreadEngine(InspIRCd* Instance)
{
}
-void Win32ThreadEngine::Create(Thread* thread)
+void ThreadEngine::Create(Thread* thread)
{
- Win32ThreadData* data = new Win32ThreadData;
+ ThreadData* data = new ThreadData;
thread->state = data;
DWORD ThreadId = 0;
- data->handle = CreateThread(NULL,0,Win32ThreadEngine::Entry,thread,0,&ThreadId);
+ data->handle = CreateThread(NULL,0,ThreadEngine::Entry,thread,0,&ThreadId);
if (data->handle == NULL)
{
thread->state = NULL;
delete data;
- throw CoreException(std::string("Unable to create new Win32ThreadEngine: ") + dlerror());
+ throw CoreException(std::string("Unable to create new thread: ") + dlerror());
}
}
-Win32ThreadEngine::~Win32ThreadEngine()
+ThreadEngine::~ThreadEngine()
{
}
-DWORD WINAPI Win32ThreadEngine::Entry(void* parameter)
+DWORD WINAPI ThreadEngine::Entry(void* parameter)
{
Thread* pt = reinterpret_cast<Thread*>(parameter);
pt->Run();
return 0;
}
-void Win32ThreadData::FreeThread(Thread* thread)
+void ThreadData::FreeThread(Thread* thread)
{
thread->SetExitFlag();
WaitForSingleObject(handle,INFINITE);
}
-
-MutexFactory::MutexFactory(InspIRCd* Instance) : ServerInstance(Instance)
-{
-}
-
-Mutex* MutexFactory::CreateMutex()
-{
- return new Win32Mutex();
-}
-
-Win32Mutex::Win32Mutex() : Mutex()
-{
- InitializeCriticalSection(&wutex);
-}
-
-Win32Mutex::~Win32Mutex()
-{
- DeleteCriticalSection(&wutex);
-}
-
-void Win32Mutex::Enable(bool enable)
-{
- if (enable)
- EnterCriticalSection(&wutex);
- else
- LeaveCriticalSection(&wutex);
-}
projects / user / henk / code / inspircd.git / commitdiff