src/socketengines/socketengine_epoll.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 "socketengines/socketengine_epoll.h"
  17 #include <ulimit.h>
  18
  19 EPollEngine::EPollEngine()
  20 {
  21         int max = ulimit(4, 0);
  22         if (max > 0)
  23         {
  24                 MAX_DESCRIPTORS = max;
  25         }
  26         else
  27         {
  28                 ServerInstance->Logs->Log("SOCKET", DEFAULT, "ERROR: Can't determine maximum number of open sockets!");
  29                 printf("ERROR: Can't determine maximum number of open sockets!\n");
  30                 ServerInstance->Exit(EXIT_STATUS_SOCKETENGINE);
  31         }
  32
  33         // This is not a maximum, just a hint at the eventual number of sockets that may be polled.
  34         EngineHandle = epoll_create(GetMaxFds() / 4);
  35
  36         if (EngineHandle == -1)
  37         {
  38                 ServerInstance->Logs->Log("SOCKET",DEFAULT, "ERROR: Could not initialize socket engine: %s", strerror(errno));
  39                 ServerInstance->Logs->Log("SOCKET",DEFAULT, "ERROR: Your kernel probably does not have the proper features. This is a fatal error, exiting now.");
  40                 printf("ERROR: Could not initialize epoll socket engine: %s\n", strerror(errno));
  41                 printf("ERROR: Your kernel probably does not have the proper features. This is a fatal error, exiting now.\n");
  42                 ServerInstance->Exit(EXIT_STATUS_SOCKETENGINE);
  43         }
  44
  45         ref = new EventHandler* [GetMaxFds()];
  46         events = new struct epoll_event[GetMaxFds()];
  47
  48         memset(ref, 0, GetMaxFds() * sizeof(EventHandler*));
  49 }
  50
  51 EPollEngine::~EPollEngine()
  52 {
  53         this->Close(EngineHandle);
  54         delete[] ref;
  55         delete[] events;
  56 }
  57
  58 static int mask_to_epoll(int event_mask)
  59 {
  60         int rv = 0;
  61         if (event_mask & (FD_WANT_POLL_READ | FD_WANT_POLL_WRITE | FD_WANT_SINGLE_WRITE))
  62         {
  63                 // we need to use standard polling on this FD
  64                 if (event_mask & (FD_WANT_POLL_READ | FD_WANT_FAST_READ))
  65                         rv |= EPOLLIN;
  66                 if (event_mask & (FD_WANT_POLL_WRITE | FD_WANT_FAST_WRITE | FD_WANT_SINGLE_WRITE))
  67                         rv |= EPOLLOUT;
  68         }
  69         else
  70         {
  71                 // we can use edge-triggered polling on this FD
  72                 rv = EPOLLET;
  73                 if (event_mask & (FD_WANT_FAST_READ | FD_WANT_EDGE_READ))
  74                         rv |= EPOLLIN;
  75                 if (event_mask & (FD_WANT_FAST_WRITE | FD_WANT_EDGE_WRITE))
  76                         rv |= EPOLLOUT;
  77         }
  78         return rv;
  79 }
  80
  81 bool EPollEngine::AddFd(EventHandler* eh, int event_mask)
  82 {
  83         int fd = eh->GetFd();
  84         if ((fd < 0) || (fd > GetMaxFds() - 1))
  85         {
  86                 ServerInstance->Logs->Log("SOCKET",DEBUG,"AddFd out of range: (fd: %d, max: %d)", fd, GetMaxFds());
  87                 return false;
  88         }
  89
  90         if (ref[fd])
  91         {
  92                 ServerInstance->Logs->Log("SOCKET",DEBUG,"Attempt to add duplicate fd: %d", fd);
  93                 return false;
  94         }
  95
  96         struct epoll_event ev;
  97         memset(&ev,0,sizeof(ev));
  98         ev.events = mask_to_epoll(event_mask);
  99         ev.data.fd = fd;
 100         int i = epoll_ctl(EngineHandle, EPOLL_CTL_ADD, fd, &ev);
 101         if (i < 0)
 102         {
 103                 ServerInstance->Logs->Log("SOCKET",DEBUG,"Error adding fd: %d to socketengine: %s", fd, strerror(errno));
 104                 return false;
 105         }
 106
 107         ServerInstance->Logs->Log("SOCKET",DEBUG,"New file descriptor: %d", fd);
 108
 109         ref[fd] = eh;
 110         SocketEngine::SetEventMask(eh, event_mask);
 111         CurrentSetSize++;
 112         return true;
 113 }
 114
 115 void EPollEngine::OnSetEvent(EventHandler* eh, int old_mask, int new_mask)
 116 {
 117         int old_events = mask_to_epoll(old_mask);
 118         int new_events = mask_to_epoll(new_mask);
 119         if (old_events != new_events)
 120         {
 121                 // ok, we actually have something to tell the kernel about
 122                 struct epoll_event ev;
 123                 memset(&ev,0,sizeof(ev));
 124                 ev.events = new_events;
 125                 ev.data.fd = eh->GetFd();
 126                 epoll_ctl(EngineHandle, EPOLL_CTL_MOD, eh->GetFd(), &ev);
 127         }
 128 }
 129
 130 bool EPollEngine::DelFd(EventHandler* eh, bool force)
 131 {
 132         int fd = eh->GetFd();
 133         if ((fd < 0) || (fd > GetMaxFds() - 1))
 134         {
 135                 ServerInstance->Logs->Log("SOCKET",DEBUG,"DelFd out of range: (fd: %d, max: %d)", fd, GetMaxFds());
 136                 return false;
 137         }
 138
 139         struct epoll_event ev;
 140         memset(&ev,0,sizeof(ev));
 141         ev.data.fd = fd;
 142         int i = epoll_ctl(EngineHandle, EPOLL_CTL_DEL, fd, &ev);
 143
 144         if (i < 0 && !force)
 145         {
 146                 ServerInstance->Logs->Log("SOCKET",DEBUG,"Cant remove socket: %s", strerror(errno));
 147                 return false;
 148         }
 149
 150         ref[fd] = NULL;
 151
 152         ServerInstance->Logs->Log("SOCKET",DEBUG,"Remove file descriptor: %d", fd);
 153         CurrentSetSize--;
 154         return true;
 155 }
 156
 157 int EPollEngine::DispatchEvents()
 158 {
 159         socklen_t codesize = sizeof(int);
 160         int errcode;
 161         int i = epoll_wait(EngineHandle, events, GetMaxFds() - 1, 1000);
 162
 163         TotalEvents += i;
 164
 165         for (int j = 0; j < i; j++)
 166         {
 167                 EventHandler* eh = ref[events[j].data.fd];
 168                 if (!eh)
 169                         continue;
 170                 if (events[j].events & EPOLLHUP)
 171                 {
 172                         ErrorEvents++;
 173                         eh->HandleEvent(EVENT_ERROR, 0);
 174                         continue;
 175                 }
 176                 if (events[j].events & EPOLLERR)
 177                 {
 178                         ErrorEvents++;
 179                         /* Get error number */
 180                         if (getsockopt(events[j].data.fd, SOL_SOCKET, SO_ERROR, &errcode, &codesize) < 0)
 181                                 errcode = errno;
 182                         eh->HandleEvent(EVENT_ERROR, errcode);
 183                         continue;
 184                 }
 185                 int mask = eh->GetEventMask();
 186                 if (events[j].events & EPOLLIN)
 187                         mask &= ~FD_READ_WILL_BLOCK;
 188                 if (events[j].events & EPOLLOUT)
 189                 {
 190                         mask &= ~FD_WRITE_WILL_BLOCK;
 191                         if (mask & FD_WANT_SINGLE_WRITE)
 192                         {
 193                                 int nm = mask & ~FD_WANT_SINGLE_WRITE;
 194                                 OnSetEvent(eh, mask, nm);
 195                                 mask = nm;
 196                         }
 197                 }
 198                 SetEventMask(eh, mask);
 199                 if (events[j].events & EPOLLIN)
 200                 {
 201                         ReadEvents++;
 202                         eh->HandleEvent(EVENT_READ);
 203                 }
 204                 if (events[j].events & EPOLLOUT)
 205                 {
 206                         WriteEvents++;
 207                         eh->HandleEvent(EVENT_WRITE);
 208                 }
 209         }
 210
 211         return i;
 212 }
 213
 214 std::string EPollEngine::GetName()
 215 {
 216         return "epoll";
 217 }
 218