X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fsocketengines%2Fsocketengine_kqueue.cpp;h=e0a0535f4e8859da6de71de5ffa9cea42027a4c0;hb=e2b0f3dc9ef4d56c71d7abda13e6139ca092e387;hp=a2bbd5afe442e18445056abec795019f648a454a;hpb=ab4dee91de96555db158db91240ff91520318068;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/socketengines/socketengine_kqueue.cpp b/src/socketengines/socketengine_kqueue.cpp index a2bbd5afe..e0a0535f4 100644 --- a/src/socketengines/socketengine_kqueue.cpp +++ b/src/socketengines/socketengine_kqueue.cpp @@ -1,176 +1,219 @@ -/* +------------------------------------+ - * | 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) 2014-2015 Attila Molnar + * Copyright (C) 2014 Adam + * Copyright (C) 2012-2013, 2017, 2019 Sadie Powell + * Copyright (C) 2012 Robby + * Copyright (C) 2009-2010 Daniel De Graaf + * Copyright (C) 2009 Uli Schlachter + * Copyright (C) 2008 Thomas Stagner + * Copyright (C) 2007 Dennis Friis + * Copyright (C) 2006-2008, 2010 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 "exitcodes.h" + #include #include #include -#include "socketengines/socketengine_kqueue.h" +#include + +/** A specialisation of the SocketEngine class, designed to use BSD kqueue(). + */ +namespace +{ + int EngineHandle; + unsigned int ChangePos = 0; + /** These are used by kqueue() to hold socket events + */ + std::vector ke_list(16); + /** Pending changes + */ + std::vector changelist(8); + +#if defined __NetBSD__ && __NetBSD_Version__ <= 999001400 + inline intptr_t udata_cast(EventHandler* eh) + { + // On NetBSD <10 the last parameter of EV_SET is intptr_t. + return reinterpret_cast(eh); + } +#else + inline void* udata_cast(EventHandler* eh) + { + // On other platforms the last parameter of EV_SET is void*. + return static_cast(eh); + } +#endif +} -KQueueEngine::KQueueEngine(InspIRCd* Instance) : SocketEngine(Instance) +/** Initialize the kqueue engine + */ +void SocketEngine::Init() { - this->RecoverFromFork(); + LookupMaxFds(); + RecoverFromFork(); } -void KQueueEngine::RecoverFromFork() +void SocketEngine::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) - { - ServerInstance->Log(DEFAULT, "ERROR: Could not initialize socket engine. Your kernel probably does not have the proper features."); - ServerInstance->Log(DEFAULT, "ERROR: this is a fatal error, exiting now."); - printf("ERROR: Could not initialize socket engine. Your kernel probably does not have the proper features.\n"); - printf("ERROR: this is a fatal error, exiting now.\n"); - ServerInstance->Exit(EXIT_STATUS_SOCKETENGINE); - } - CurrentSetSize = 0; + InitError(); } -KQueueEngine::~KQueueEngine() +/** Shutdown the kqueue engine + */ +void SocketEngine::Deinit() { - this->Close(EngineHandle); + Close(EngineHandle); } -bool KQueueEngine::AddFd(EventHandler* eh) +static struct kevent* GetChangeKE() { - int fd = eh->GetFd(); + if (ChangePos >= changelist.size()) + changelist.resize(changelist.size() * 2); + return &changelist[ChangePos++]; +} - if ((fd < 0) || (fd > MAX_DESCRIPTORS)) - return false; +bool SocketEngine::AddFd(EventHandler* eh, int event_mask) +{ + int fd = eh->GetFd(); - if (GetRemainingFds() <= 1) + if (fd < 0) return false; - if (ref[fd]) + if (!SocketEngine::AddFdRef(eh)) return false; - struct kevent ke; - EV_SET(&ke, fd, eh->Readable() ? EVFILT_READ : EVFILT_WRITE, EV_ADD, 0, 0, NULL); + // We always want to read from the socket... + struct kevent* ke = GetChangeKE(); + EV_SET(ke, fd, EVFILT_READ, EV_ADD, 0, 0, udata_cast(eh)); - int i = kevent(EngineHandle, &ke, 1, 0, 0, NULL); - if (i == -1) - { - return false; - } + ServerInstance->Logs->Log("SOCKET", LOG_DEBUG, "New file descriptor: %d", fd); - ref[fd] = eh; - CurrentSetSize++; + eh->SetEventMask(event_mask); + OnSetEvent(eh, 0, event_mask); + ResizeDouble(ke_list); - ServerInstance->Log(DEBUG,"New file descriptor: %d", fd); return true; } -bool KQueueEngine::DelFd(EventHandler* eh, bool force) +void SocketEngine::DelFd(EventHandler* eh) { int fd = eh->GetFd(); - if ((fd < 0) || (fd > MAX_DESCRIPTORS)) - 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); - - EV_SET(&ke, eh->GetFd(), EVFILT_WRITE, EV_DELETE, 0, 0, NULL); - - int j = kevent(EngineHandle, &ke, 1, 0, 0, NULL); - - if ((j < 0) && (i < 0) && !force) - return false; + if (fd < 0) + { + ServerInstance->Logs->Log("SOCKET", LOG_DEFAULT, "DelFd() on invalid fd: %d", fd); + return; + } - CurrentSetSize--; - ref[fd] = NULL; + // First remove the write filter ignoring errors, since we can't be + // sure if there are actually any write filters registered. + struct kevent* ke = GetChangeKE(); + EV_SET(ke, eh->GetFd(), EVFILT_WRITE, EV_DELETE, 0, 0, NULL); - ServerInstance->Log(DEBUG,"Remove file descriptor: %d", fd); - return true; -} + // Then remove the read filter. + ke = GetChangeKE(); + EV_SET(ke, eh->GetFd(), EVFILT_READ, EV_DELETE, 0, 0, NULL); -void KQueueEngine::WantWrite(EventHandler* eh) -{ - /** 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); -} + SocketEngine::DelFdRef(eh); -int KQueueEngine::GetMaxFds() -{ - return MAX_DESCRIPTORS; + ServerInstance->Logs->Log("SOCKET", LOG_DEBUG, "Remove file descriptor: %d", fd); } -int KQueueEngine::GetRemainingFds() +void SocketEngine::OnSetEvent(EventHandler* eh, int old_mask, int new_mask) { - return MAX_DESCRIPTORS - CurrentSetSize; + if ((new_mask & FD_WANT_POLL_WRITE) && !(old_mask & FD_WANT_POLL_WRITE)) + { + // new poll-style write + struct kevent* ke = GetChangeKE(); + EV_SET(ke, eh->GetFd(), EVFILT_WRITE, EV_ADD, 0, 0, udata_cast(eh)); + } + else if ((old_mask & FD_WANT_POLL_WRITE) && !(new_mask & FD_WANT_POLL_WRITE)) + { + // removing poll-style write + struct kevent* ke = GetChangeKE(); + EV_SET(ke, eh->GetFd(), EVFILT_WRITE, EV_DELETE, 0, 0, NULL); + } + if ((new_mask & (FD_WANT_FAST_WRITE | FD_WANT_SINGLE_WRITE)) && !(old_mask & (FD_WANT_FAST_WRITE | FD_WANT_SINGLE_WRITE))) + { + struct kevent* ke = GetChangeKE(); + EV_SET(ke, eh->GetFd(), EVFILT_WRITE, EV_ADD | EV_ONESHOT, 0, 0, udata_cast(eh)); + } } -int KQueueEngine::DispatchEvents() +int SocketEngine::DispatchEvents() { + struct timespec ts; ts.tv_nsec = 0; ts.tv_sec = 1; - int i = kevent(EngineHandle, NULL, 0, &ke_list[0], MAX_DESCRIPTORS, &ts); + int i = kevent(EngineHandle, &changelist.front(), ChangePos, &ke_list.front(), ke_list.size(), &ts); + ChangePos = 0; + ServerInstance->UpdateTime(); + + if (i < 0) + return i; - TotalEvents += i; + stats.TotalEvents += i; for (int j = 0; j < i; j++) { - if (ke_list[j].flags & EV_EOF) + // This can't be a static_cast because udata is intptr_t on NetBSD. + struct kevent& kev = ke_list[j]; + EventHandler* eh = reinterpret_cast(kev.udata); + if (!eh) + continue; + + // Copy these in case the vector gets resized and kev invalidated + const int fd = eh->GetFd(); + const short filter = kev.filter; + if (fd < 0) + continue; + + if (kev.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); + stats.ErrorEvents++; + eh->OnEventHandlerError(kev.fflags); continue; } - if (ke_list[j].flags & EVFILT_WRITE) + if (filter == EVFILT_WRITE) { - /* This looks wrong but its right. As above, theres no modify - * call in kqueue. See the manpage. + /* 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. */ - 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); + const int bits_to_clr = FD_WANT_SINGLE_WRITE | FD_WANT_FAST_WRITE | FD_WRITE_WILL_BLOCK; + eh->SetEventMask(eh->GetEventMask() & ~bits_to_clr); + eh->OnEventHandlerWrite(); } - else + else if (filter == EVFILT_READ) { - ReadEvents++; - if (ref[ke_list[j].ident]) - ref[ke_list[j].ident]->HandleEvent(EVENT_READ); + eh->SetEventMask(eh->GetEventMask() & ~FD_READ_WILL_BLOCK); + eh->OnEventHandlerRead(); } } return i; } - -std::string KQueueEngine::GetName() -{ - return "kqueue"; -}