X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fsocketengines%2Fsocketengine_kqueue.cpp;h=e7d7e4283c46b0e807c6aa6470a4c551d4ad6113;hb=7e46119759b7099c38f543bd38d0186b9806542f;hp=63a1844cb5af4cfb02631f93412d2b1b4c7a32cf;hpb=2db77cda56947d4ee0f913c8082f6607855ca713;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/socketengines/socketengine_kqueue.cpp b/src/socketengines/socketengine_kqueue.cpp index 63a1844cb..e7d7e4283 100644 --- a/src/socketengines/socketengine_kqueue.cpp +++ b/src/socketengines/socketengine_kqueue.cpp @@ -2,8 +2,8 @@ * | Inspire Internet Relay Chat Daemon | * +------------------------------------+ * - * InspIRCd: (C) 2002-2008 InspIRCd Development Team - * See: http://www.inspircd.org/wiki/index.php/Credits + * InspIRCd: (C) 2002-2010 InspIRCd Development Team + * See: http://wiki.inspircd.org/Credits * * This program is free but copyrighted software; see * the file COPYING for details. @@ -16,14 +16,70 @@ #include #include #include -#include "socketengines/socketengine_kqueue.h" -#include +/* +------------------------------------+ + * | Inspire Internet Relay Chat Daemon | + * +------------------------------------+ + * + * InspIRCd: (C) 2002-2010 InspIRCd Development Team + * See: http://wiki.inspircd.org/Credits + * + * This program is free but copyrighted software; see + * the file COPYING for details. + * + * --------------------------------------------------- + */ + +#ifndef __SOCKETENGINE_KQUEUE__ +#define __SOCKETENGINE_KQUEUE__ + +#include +#include +#include +#include "inspircd_config.h" +#include "inspircd.h" +#include +#include +#include +#include "socketengine.h" -KQueueEngine::KQueueEngine(InspIRCd* Instance) : SocketEngine(Instance) +/** A specialisation of the SocketEngine class, designed to use FreeBSD kqueue(). + */ +class KQueueEngine : public SocketEngine { +private: + int EngineHandle; + /** These are used by kqueue() to hold socket events + */ + struct kevent* ke_list; + /** This is a specialised time value used by kqueue() + */ + struct timespec ts; +public: + /** Create a new KQueueEngine + */ + KQueueEngine(); + /** Delete a KQueueEngine + */ + virtual ~KQueueEngine(); + bool AddFd(EventHandler* eh, int event_mask); + void OnSetEvent(EventHandler* eh, int old_mask, int new_mask); + virtual bool DelFd(EventHandler* eh, bool force = false); + virtual int DispatchEvents(); + virtual std::string GetName(); + virtual void RecoverFromFork(); +}; + +#endif + +#include + +KQueueEngine::KQueueEngine() +{ + MAX_DESCRIPTORS = 0; this->RecoverFromFork(); - ref = new EventHandler* [GetMaxFds()]; ke_list = new struct kevent[GetMaxFds()]; + ref = new EventHandler* [GetMaxFds()]; + memset(ref, 0, GetMaxFds() * sizeof(EventHandler*)); } void KQueueEngine::RecoverFromFork() @@ -31,7 +87,7 @@ void KQueueEngine::RecoverFromFork() /* * The only bad thing about kqueue is that its fd cant survive a fork and is not inherited. * BUM HATS. - * + * */ EngineHandle = kqueue(); if (EngineHandle == -1) @@ -43,7 +99,6 @@ void KQueueEngine::RecoverFromFork() ServerInstance->Exit(EXIT_STATUS_SOCKETENGINE); } CurrentSetSize = 0; - memset(ref, 0, GetMaxFds() * sizeof(EventHandler*)); } KQueueEngine::~KQueueEngine() @@ -53,29 +108,31 @@ KQueueEngine::~KQueueEngine() delete[] ke_list; } -bool KQueueEngine::AddFd(EventHandler* eh) +bool KQueueEngine::AddFd(EventHandler* eh, int event_mask) { int fd = eh->GetFd(); if ((fd < 0) || (fd > GetMaxFds() - 1)) return false; - if (GetRemainingFds() <= 1) - return false; - if (ref[fd]) return false; + // We always want to read from the socket... struct kevent ke; - EV_SET(&ke, fd, eh->Readable() ? EVFILT_READ : EVFILT_WRITE, EV_ADD, 0, 0, NULL); + EV_SET(&ke, fd, EVFILT_READ, EV_ADD, 0, 0, NULL); int i = kevent(EngineHandle, &ke, 1, 0, 0, NULL); if (i == -1) { + ServerInstance->Logs->Log("SOCKET",DEFAULT,"Failed to add fd: %d %s", + fd, strerror(errno)); return false; } ref[fd] = eh; + SocketEngine::SetEventMask(eh, event_mask); + OnSetEvent(eh, 0, event_mask); CurrentSetSize++; ServerInstance->Logs->Log("SOCKET",DEBUG,"New file descriptor: %d", fd); @@ -87,19 +144,28 @@ bool KQueueEngine::DelFd(EventHandler* eh, bool force) int fd = eh->GetFd(); if ((fd < 0) || (fd > GetMaxFds() - 1)) + { + ServerInstance->Logs->Log("SOCKET",DEFAULT,"DelFd() on invalid fd: %d", fd); return false; + } struct kevent ke; - EV_SET(&ke, eh->GetFd(), EVFILT_READ, EV_DELETE, 0, 0, NULL); - - int i = kevent(EngineHandle, &ke, 1, 0, 0, NULL); + // First remove the write filter ignoring errors, since we can't be + // sure if there are actually any write filters registered. EV_SET(&ke, eh->GetFd(), EVFILT_WRITE, EV_DELETE, 0, 0, NULL); + kevent(EngineHandle, &ke, 1, 0, 0, NULL); + // Then remove the read filter. + EV_SET(&ke, eh->GetFd(), EVFILT_READ, EV_DELETE, 0, 0, NULL); int j = kevent(EngineHandle, &ke, 1, 0, 0, NULL); - if ((j < 0) && (i < 0) && !force) + if ((j < 0) && !force) + { + ServerInstance->Logs->Log("SOCKET",DEFAULT,"Failed to remove fd: %d %s", + fd, strerror(errno)); return false; + } CurrentSetSize--; ref[fd] = NULL; @@ -108,40 +174,41 @@ bool KQueueEngine::DelFd(EventHandler* eh, bool force) return true; } -void KQueueEngine::WantWrite(EventHandler* eh) +void KQueueEngine::OnSetEvent(EventHandler* eh, int old_mask, int new_mask) { - /** When changing an item in a kqueue, there is no 'modify' call - * as in epoll. Instead, we add the item again, and this overwrites - * the original setting rather than adding it twice. See man kqueue. - */ - struct kevent ke; - EV_SET(&ke, eh->GetFd(), EVFILT_WRITE, EV_ADD | EV_ONESHOT, 0, 0, NULL); - kevent(EngineHandle, &ke, 1, 0, 0, NULL); -} - -int KQueueEngine::GetMaxFds() -{ - if (MAX_DESCRIPTORS) - return MAX_DESCRIPTORS; - - int max = ulimit(4, 0); - if (max > 0) + if ((new_mask & FD_WANT_POLL_WRITE) && !(old_mask & FD_WANT_POLL_WRITE)) { - MAX_DESCRIPTORS = max; - return max; + // new poll-style write + struct kevent ke; + EV_SET(&ke, eh->GetFd(), EVFILT_WRITE, EV_ADD, 0, 0, NULL); + int i = kevent(EngineHandle, &ke, 1, 0, 0, NULL); + if (i < 0) { + ServerInstance->Logs->Log("SOCKET",DEFAULT,"Failed to mark for writing: %d %s", + eh->GetFd(), strerror(errno)); + } } - else + else if ((old_mask & FD_WANT_POLL_WRITE) && !(new_mask & FD_WANT_POLL_WRITE)) { - ServerInstance->Logs->Log("SOCKET", DEFAULT, "ERROR: Can't determine maximum number of open sockets!"); - printf("ERROR: Can't determine maximum number of open sockets!\n"); - ServerInstance->Exit(EXIT_STATUS_SOCKETENGINE); + // removing poll-style write + struct kevent ke; + EV_SET(&ke, eh->GetFd(), EVFILT_WRITE, EV_DELETE, 0, 0, NULL); + int i = kevent(EngineHandle, &ke, 1, 0, 0, NULL); + if (i < 0) { + ServerInstance->Logs->Log("SOCKET",DEFAULT,"Failed to mark for writing: %d %s", + eh->GetFd(), strerror(errno)); + } + } + if ((new_mask & (FD_WANT_FAST_WRITE | FD_WANT_SINGLE_WRITE)) && !(old_mask & (FD_WANT_FAST_WRITE | FD_WANT_SINGLE_WRITE))) + { + // new one-shot write + struct kevent ke; + EV_SET(&ke, eh->GetFd(), EVFILT_WRITE, EV_ADD | EV_ONESHOT, 0, 0, NULL); + int i = kevent(EngineHandle, &ke, 1, 0, 0, NULL); + if (i < 0) { + ServerInstance->Logs->Log("SOCKET",DEFAULT,"Failed to mark for writing: %d %s", + eh->GetFd(), strerror(errno)); + } } - return 0; -} - -int KQueueEngine::GetRemainingFds() -{ - return GetMaxFds() - CurrentSetSize; } int KQueueEngine::DispatchEvents() @@ -150,40 +217,37 @@ int KQueueEngine::DispatchEvents() ts.tv_sec = 1; int i = kevent(EngineHandle, NULL, 0, &ke_list[0], GetMaxFds(), &ts); + ServerInstance->UpdateTime(); TotalEvents += i; for (int j = 0; j < i; j++) { + EventHandler* eh = ref[ke_list[j].ident]; + if (!eh) + continue; if (ke_list[j].flags & EV_EOF) { - /* We love you kqueue, oh yes we do *sings*! - * kqueue gives us the error number directly in the EOF state! - * Unlike smelly epoll and select, where we have to getsockopt - * to get the error, this saves us time and cpu cycles. Go BSD! - */ ErrorEvents++; - if (ref[ke_list[j].ident]) - ref[ke_list[j].ident]->HandleEvent(EVENT_ERROR, ke_list[j].fflags); + eh->HandleEvent(EVENT_ERROR, ke_list[j].fflags); continue; } - if (ke_list[j].flags & EVFILT_WRITE) + if (ke_list[j].filter == EVFILT_WRITE) { - /* This looks wrong but its right. As above, theres no modify - * call in kqueue. See the manpage. - */ - struct kevent ke; - EV_SET(&ke, ke_list[j].ident, EVFILT_READ, EV_ADD, 0, 0, NULL); - kevent(EngineHandle, &ke, 1, 0, 0, NULL); WriteEvents++; - if (ref[ke_list[j].ident]) - ref[ke_list[j].ident]->HandleEvent(EVENT_WRITE); + /* When mask is FD_WANT_FAST_WRITE or FD_WANT_SINGLE_WRITE, + * we set a one-shot write, so we need to clear that bit + * to detect when it set again. + */ + const int bits_to_clr = FD_WANT_SINGLE_WRITE | FD_WANT_FAST_WRITE | FD_WRITE_WILL_BLOCK; + SetEventMask(eh, eh->GetEventMask() & ~bits_to_clr); + eh->HandleEvent(EVENT_WRITE); } - else + if (ke_list[j].filter == EVFILT_READ) { ReadEvents++; - if (ref[ke_list[j].ident]) - ref[ke_list[j].ident]->HandleEvent(EVENT_READ); + SetEventMask(eh, eh->GetEventMask() & ~FD_READ_WILL_BLOCK); + eh->HandleEvent(EVENT_READ); } } @@ -194,3 +258,8 @@ std::string KQueueEngine::GetName() { return "kqueue"; } + +SocketEngine* CreateSocketEngine() +{ + return new KQueueEngine; +}