src/socketengines/socketengine_kqueue.cpp

   1 /*       +------------------------------------+
   2  *       | Inspire Internet Relay Chat Daemon |
   3  *       +------------------------------------+
   4  *
   5  *  InspIRCd: (C) 2002-2009 InspIRCd Development Team
   6  * See: http://wiki.inspircd.org/Credits
   7  *
   8  * This program is free but copyrighted software; see
   9  *          the file COPYING for details.
  10  *
  11  * ---------------------------------------------------
  12  */
  13
  14 #include "inspircd.h"
  15 #include "exitcodes.h"
  16 #include <sys/types.h>
  17 #include <sys/event.h>
  18 #include <sys/time.h>
  19 #include "socketengines/socketengine_kqueue.h"
  20 #include <sys/sysctl.h>
  21
  22 KQueueEngine::KQueueEngine()
  23 {
  24         MAX_DESCRIPTORS = 0;
  25         this->RecoverFromFork();
  26         ke_list = new struct kevent[GetMaxFds()];
  27         ref = new EventHandler* [GetMaxFds()];
  28         memset(ref, 0, GetMaxFds() * sizeof(EventHandler*));
  29 }
  30
  31 void KQueueEngine::RecoverFromFork()
  32 {
  33         /*
  34          * The only bad thing about kqueue is that its fd cant survive a fork and is not inherited.
  35          * BUM HATS.
  36          *
  37          */
  38         EngineHandle = kqueue();
  39         if (EngineHandle == -1)
  40         {
  41                 ServerInstance->Logs->Log("SOCKET",DEFAULT, "ERROR: Could not initialize socket engine. Your kernel probably does not have the proper features.");
  42                 ServerInstance->Logs->Log("SOCKET",DEFAULT, "ERROR: this is a fatal error, exiting now.");
  43                 printf("ERROR: Could not initialize socket engine. Your kernel probably does not have the proper features.\n");
  44                 printf("ERROR: this is a fatal error, exiting now.\n");
  45                 ServerInstance->Exit(EXIT_STATUS_SOCKETENGINE);
  46         }
  47         CurrentSetSize = 0;
  48 }
  49
  50 KQueueEngine::~KQueueEngine()
  51 {
  52         this->Close(EngineHandle);
  53         delete[] ref;
  54         delete[] ke_list;
  55 }
  56
  57 bool KQueueEngine::AddFd(EventHandler* eh, int event_mask)
  58 {
  59         int fd = eh->GetFd();
  60
  61         if ((fd < 0) || (fd > GetMaxFds() - 1))
  62                 return false;
  63
  64         if (ref[fd])
  65                 return false;
  66
  67         // We always want to read from the socket...
  68         struct kevent ke;
  69         EV_SET(&ke, fd, EVFILT_READ, EV_ADD, 0, 0, NULL);
  70
  71         int i = kevent(EngineHandle, &ke, 1, 0, 0, NULL);
  72         if (i == -1)
  73         {
  74                 ServerInstance->Logs->Log("SOCKET",DEFAULT,"Failed to add fd: %d %s",
  75                                           fd, strerror(errno));
  76                 return false;
  77         }
  78
  79         ref[fd] = eh;
  80         SocketEngine::SetEventMask(eh, event_mask);
  81         OnSetEvent(eh, 0, event_mask);
  82         CurrentSetSize++;
  83
  84         ServerInstance->Logs->Log("SOCKET",DEBUG,"New file descriptor: %d", fd);
  85         return true;
  86 }
  87
  88 bool KQueueEngine::DelFd(EventHandler* eh, bool force)
  89 {
  90         int fd = eh->GetFd();
  91
  92         if ((fd < 0) || (fd > GetMaxFds() - 1))
  93         {
  94                 ServerInstance->Logs->Log("SOCKET",DEFAULT,"DelFd() on invalid fd: %d", fd);
  95                 return false;
  96         }
  97
  98         struct kevent ke;
  99
 100         // First remove the write filter ignoring errors, since we can't be
 101         // sure if there are actually any write filters registered.
 102         EV_SET(&ke, eh->GetFd(), EVFILT_WRITE, EV_DELETE, 0, 0, NULL);
 103         kevent(EngineHandle, &ke, 1, 0, 0, NULL);
 104
 105         // Then remove the read filter.
 106         EV_SET(&ke, eh->GetFd(), EVFILT_READ, EV_DELETE, 0, 0, NULL);
 107         int j = kevent(EngineHandle, &ke, 1, 0, 0, NULL);
 108
 109         if ((j < 0) && !force)
 110         {
 111                 ServerInstance->Logs->Log("SOCKET",DEFAULT,"Failed to remove fd: %d %s",
 112                                           fd, strerror(errno));
 113                 return false;
 114         }
 115
 116         CurrentSetSize--;
 117         ref[fd] = NULL;
 118
 119         ServerInstance->Logs->Log("SOCKET",DEBUG,"Remove file descriptor: %d", fd);
 120         return true;
 121 }
 122
 123 void KQueueEngine::OnSetEvent(EventHandler* eh, int old_mask, int new_mask)
 124 {
 125         if ((new_mask & FD_WANT_POLL_WRITE) && !(old_mask & FD_WANT_POLL_WRITE))
 126         {
 127                 // new poll-style write
 128                 struct kevent ke;
 129                 EV_SET(&ke, eh->GetFd(), EVFILT_WRITE, EV_ADD, 0, 0, NULL);
 130                 int i = kevent(EngineHandle, &ke, 1, 0, 0, NULL);
 131                 if (i < 0) {
 132                         ServerInstance->Logs->Log("SOCKET",DEFAULT,"Failed to mark for writing: %d %s",
 133                                                   eh->GetFd(), strerror(errno));
 134                 }
 135         }
 136         else if ((old_mask & FD_WANT_POLL_WRITE) && !(new_mask & FD_WANT_POLL_WRITE))
 137         {
 138                 // removing poll-style write
 139                 struct kevent ke;
 140                 EV_SET(&ke, eh->GetFd(), EVFILT_WRITE, EV_DELETE, 0, 0, NULL);
 141                 int i = kevent(EngineHandle, &ke, 1, 0, 0, NULL);
 142                 if (i < 0) {
 143                         ServerInstance->Logs->Log("SOCKET",DEFAULT,"Failed to mark for writing: %d %s",
 144                                                   eh->GetFd(), strerror(errno));
 145                 }
 146         }
 147         if ((new_mask & (FD_WANT_FAST_WRITE | FD_WANT_SINGLE_WRITE)) && !(old_mask & (FD_WANT_FAST_WRITE | FD_WANT_SINGLE_WRITE)))
 148         {
 149                 // new one-shot write
 150                 struct kevent ke;
 151                 EV_SET(&ke, eh->GetFd(), EVFILT_WRITE, EV_ADD | EV_ONESHOT, 0, 0, NULL);
 152                 int i = kevent(EngineHandle, &ke, 1, 0, 0, NULL);
 153                 if (i < 0) {
 154                         ServerInstance->Logs->Log("SOCKET",DEFAULT,"Failed to mark for writing: %d %s",
 155                                                   eh->GetFd(), strerror(errno));
 156                 }
 157         }
 158 }
 159
 160 int KQueueEngine::DispatchEvents()
 161 {
 162         ts.tv_nsec = 0;
 163         ts.tv_sec = 1;
 164
 165         int i = kevent(EngineHandle, NULL, 0, &ke_list[0], GetMaxFds(), &ts);
 166
 167         TotalEvents += i;
 168
 169         for (int j = 0; j < i; j++)
 170         {
 171                 EventHandler* eh = ref[ke_list[j].ident];
 172                 if (!eh)
 173                         continue;
 174                 if (ke_list[j].flags & EV_EOF)
 175                 {
 176                         ErrorEvents++;
 177                         eh->HandleEvent(EVENT_ERROR, ke_list[j].fflags);
 178                         continue;
 179                 }
 180                 if (ke_list[j].filter == EVFILT_WRITE)
 181                 {
 182                         WriteEvents++;
 183                         /* When mask is FD_WANT_FAST_WRITE or FD_WANT_SINGLE_WRITE,
 184                          * we set a one-shot write, so we need to clear that bit
 185                          * to detect when it set again.
 186                          */
 187                         const int bits_to_clr = FD_WANT_SINGLE_WRITE | FD_WANT_FAST_WRITE | FD_WRITE_WILL_BLOCK;
 188                         SetEventMask(eh, eh->GetEventMask() & ~bits_to_clr);
 189                         eh->HandleEvent(EVENT_WRITE);
 190                 }
 191                 if (ke_list[j].filter == EVFILT_READ)
 192                 {
 193                         ReadEvents++;
 194                         SetEventMask(eh, eh->GetEventMask() & ~FD_READ_WILL_BLOCK);
 195                         eh->HandleEvent(EVENT_READ);
 196                 }
 197         }
 198
 199         return i;
 200 }
 201
 202 std::string KQueueEngine::GetName()
 203 {
 204         return "kqueue";
 205 }