X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fthreadengines%2Fthreadengine_pthread.cpp;h=40205da3118533479382f8f7f8dba2b5e182ffe1;hb=09186df9f8c0d4f699b5abb4325d7dd583a8a0b1;hp=626cd4d55528b6670e8f0d136e96300723205f55;hpb=edd35ae3af70075e0d59b6409f6d206c6c08d85b;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/threadengines/threadengine_pthread.cpp b/src/threadengines/threadengine_pthread.cpp index 626cd4d55..40205da31 100644 --- a/src/threadengines/threadengine_pthread.cpp +++ b/src/threadengines/threadengine_pthread.cpp @@ -1,133 +1,180 @@ -/* +------------------------------------+ - * | Inspire Internet Relay Chat Daemon | - * +------------------------------------+ +/* + * InspIRCd -- Internet Relay Chat Daemon * - * InspIRCd: (C) 2002-2008 InspIRCd Development Team - * See: http://www.inspircd.org/wiki/index.php/Credits + * Copyright (C) 2009-2010 Daniel De Graaf + * Copyright (C) 2008 Craig Edwards * - * This program is free but copyrighted software; see - * the file COPYING for details. + * This file is part of InspIRCd. InspIRCd is free software: you can + * redistribute it and/or modify it under the terms of the GNU General Public + * License as published by the Free Software Foundation, version 2. * - * --------------------------------------------------- + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more + * details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . */ + #include "inspircd.h" #include "threadengines/threadengine_pthread.h" #include +#include +#include -pthread_mutex_t MyMutex = PTHREAD_MUTEX_INITIALIZER; - -PThreadEngine::PThreadEngine(InspIRCd* Instance) : ThreadEngine(Instance) +ThreadEngine::ThreadEngine() { } -void PThreadEngine::Create(Thread* thread_to_init) +static void* entry_point(void* parameter) { - pthread_attr_t attribs; - pthread_attr_init(&attribs); - pthread_attr_setdetachstate(&attribs, PTHREAD_CREATE_JOINABLE); - pthread_t* MyPThread = new pthread_t; - - /* Create a thread in a mutex. This prevents whacking the member value NewThread, - * and also prevents recursive creation of threads by mistake (instead, the thread - * will just deadlock itself) - */ - Mutex(true); - - if (pthread_create(MyPThread, &attribs, PThreadEngine::Entry, (void*)this) != 0) - { - delete MyPThread; - Mutex(false); - throw CoreException("Unable to create new PThreadEngine: " + std::string(strerror(errno))); - } + /* Recommended by nenolod, signal safety on a per-thread basis */ + sigset_t set; + sigemptyset(&set); + sigaddset(&set, SIGPIPE); + pthread_sigmask(SIG_BLOCK, &set, NULL); - pthread_attr_destroy(&attribs); + Thread* pt = static_cast(parameter); + pt->Run(); + return parameter; +} - NewThread = thread_to_init; - NewThread->Creator = this; - NewThread->Extend("pthread", MyPThread); - /* Always unset a mutex if you set it */ - Mutex(false); +void ThreadEngine::Start(Thread* thread) +{ + ThreadData* data = new ThreadData; + thread->state = data; - /* Wait for the PThreadEngine::Run method to take a copy of the - * pointer and clear this member value - */ - while (NewThread) - usleep(1000); + if (pthread_create(&data->pthread_id, NULL, entry_point, thread) != 0) + { + thread->state = NULL; + delete data; + throw CoreException("Unable to create new thread: " + std::string(strerror(errno))); + } } -PThreadEngine::~PThreadEngine() +ThreadEngine::~ThreadEngine() { } -void PThreadEngine::Run() +void ThreadData::FreeThread(Thread* thread) { - /* Take a copy of the member value, then clear it. Do this - * in a mutex so that we can be sure nothing else is looking - * at it. - */ - Mutex(true); - Thread* nt = NewThread; - NewThread = NULL; - Mutex(false); - /* Now we have our own safe copy, call the object on it */ - nt->Run(); + thread->SetExitFlag(); + pthread_join(pthread_id, NULL); } -bool PThreadEngine::Mutex(bool enable) +#ifdef HAS_EVENTFD +#include + +class ThreadSignalSocket : public EventHandler { - if (enable) - pthread_mutex_lock(&MyMutex); - else - pthread_mutex_unlock(&MyMutex); + SocketThread* parent; + public: + ThreadSignalSocket(SocketThread* p, int newfd) : parent(p) + { + SetFd(newfd); + ServerInstance->SE->AddFd(this, FD_WANT_FAST_READ | FD_WANT_NO_WRITE); + } - return false; -} + ~ThreadSignalSocket() + { + ServerInstance->SE->DelFd(this); + ServerInstance->SE->Close(GetFd()); + } -void* PThreadEngine::Entry(void* parameter) -{ - ThreadEngine * pt = (ThreadEngine*)parameter; - pt->Run(); - return NULL; -} + void Notify() + { + eventfd_write(fd, 1); + } -void PThreadEngine::FreeThread(Thread* thread) -{ - pthread_t* pthread = NULL; - if (thread->GetExt("pthread", pthread)) + void HandleEvent(EventType et, int errornum) { - thread->SetExitFlag(); - int rc; - void* status; - rc = pthread_join(*pthread, &status); - delete pthread; + if (et == EVENT_READ) + { + eventfd_t dummy; + eventfd_read(fd, &dummy); + parent->OnNotify(); + } + else + { + ServerInstance->GlobalCulls.AddItem(this); + } } -} +}; -MutexEngine::MutexEngine(InspIRCd* Instance) : ServerInstance(Instance) +SocketThread::SocketThread() { + signal.sock = NULL; + int fd = eventfd(0, EFD_NONBLOCK); + if (fd < 0) + throw CoreException("Could not create pipe " + std::string(strerror(errno))); + signal.sock = new ThreadSignalSocket(this, fd); } +#else -Mutex* MutexEngine::CreateMutex() +class ThreadSignalSocket : public EventHandler { - return new PosixMutex(this->ServerInstance); -} + SocketThread* parent; + int send_fd; + public: + ThreadSignalSocket(SocketThread* p, int recvfd, int sendfd) : + parent(p), send_fd(sendfd) + { + SetFd(recvfd); + ServerInstance->SE->NonBlocking(fd); + ServerInstance->SE->AddFd(this, FD_WANT_FAST_READ | FD_WANT_NO_WRITE); + } + + ~ThreadSignalSocket() + { + close(send_fd); + ServerInstance->SE->DelFd(this); + ServerInstance->SE->Close(GetFd()); + } -PosixMutex::PosixMutex(InspIRCd* Instance) : Mutex(Instance) + void Notify() + { + static const char dummy = '*'; + write(send_fd, &dummy, 1); + } + + void HandleEvent(EventType et, int errornum) + { + if (et == EVENT_READ) + { + char dummy[128]; + read(fd, dummy, 128); + parent->OnNotify(); + } + else + { + ServerInstance->GlobalCulls.AddItem(this); + } + } +}; + +SocketThread::SocketThread() { - InitializeCriticalSection(&putex); + signal.sock = NULL; + int fds[2]; + if (pipe(fds)) + throw CoreException("Could not create pipe " + std::string(strerror(errno))); + signal.sock = new ThreadSignalSocket(this, fds[0], fds[1]); } +#endif -PosixMutex::~PosixMutex() +void SocketThread::NotifyParent() { - DeleteCriticalSection(&putex); + signal.sock->Notify(); } -void PosixMutex::Enable(bool enable) +SocketThread::~SocketThread() { - if (enable) - pthread_mutex_lock(&putex); - else - pthread_mutex_unlock(&putex); + if (signal.sock) + { + signal.sock->cull(); + delete signal.sock; + } }