src/socketengines/socketengine_epoll.cpp

   1 /*       +------------------------------------+
   2  *       | Inspire Internet Relay Chat Daemon |
   3  *       +------------------------------------+
   4  *
   5  *  InspIRCd: (C) 2002-2008 InspIRCd Development Team
   6  * See: http://www.inspircd.org/wiki/index.php/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/epoll.h>
  17 #include "socketengines/socketengine_epoll.h"
  18 #include <ulimit.h>
  19
  20 EPollEngine::EPollEngine(InspIRCd* Instance) : SocketEngine(Instance)
  21 {
  22         MAX_DESCRIPTORS = 0;
  23         EngineHandle = epoll_create(GetMaxFds());
  24
  25         if (EngineHandle == -1)
  26         {
  27                 ServerInstance->Logs->Log("SOCKET",DEFAULT, "ERROR: Could not initialize socket engine: %s", strerror(errno));
  28                 ServerInstance->Logs->Log("SOCKET",DEFAULT, "ERROR: Your kernel probably does not have the proper features. This is a fatal error, exiting now.");
  29                 printf("ERROR: Could not initialize socket engine: %s\n", strerror(errno));
  30                 printf("ERROR: Your kernel probably does not have the proper features. This is a fatal error, exiting now.\n");
  31                 ServerInstance->Exit(EXIT_STATUS_SOCKETENGINE);
  32         }
  33         CurrentSetSize = 0;
  34
  35         ref = new EventHandler* [GetMaxFds()];
  36         events = new struct epoll_event[GetMaxFds()];
  37
  38         memset(ref, 0, GetMaxFds() * sizeof(EventHandler*));
  39 }
  40
  41 EPollEngine::~EPollEngine()
  42 {
  43         this->Close(EngineHandle);
  44         delete[] ref;
  45         delete[] events;
  46 }
  47
  48 bool EPollEngine::AddFd(EventHandler* eh)
  49 {
  50         int fd = eh->GetFd();
  51         if ((fd < 0) || (fd > GetMaxFds() - 1))
  52         {
  53                 ServerInstance->Logs->Log("SOCKET",DEBUG,"Out of range FD: (fd: %d, max: %d)", fd, GetMaxFds());
  54                 return false;
  55         }
  56
  57         if (GetRemainingFds() <= 1)
  58                 return false;
  59
  60         if (ref[fd])
  61                 return false;
  62
  63         struct epoll_event ev;
  64         memset(&ev,0,sizeof(struct epoll_event));
  65         eh->Readable() ? ev.events = EPOLLIN : ev.events = EPOLLOUT;
  66         ev.data.fd = fd;
  67         int i = epoll_ctl(EngineHandle, EPOLL_CTL_ADD, fd, &ev);
  68         if (i < 0)
  69         {
  70                 return false;
  71         }
  72
  73         ServerInstance->Logs->Log("SOCKET",DEBUG,"New file descriptor: %d", fd);
  74
  75         ref[fd] = eh;
  76         CurrentSetSize++;
  77         return true;
  78 }
  79
  80 void EPollEngine::WantWrite(EventHandler* eh)
  81 {
  82         /** Use oneshot so that the system removes the writeable
  83          * status for us and saves us a call.
  84          */
  85         struct epoll_event ev;
  86         memset(&ev,0,sizeof(struct epoll_event));
  87         ev.events = EPOLLOUT;
  88         ev.data.fd = eh->GetFd();
  89         epoll_ctl(EngineHandle, EPOLL_CTL_MOD, eh->GetFd(), &ev);
  90 }
  91
  92 bool EPollEngine::DelFd(EventHandler* eh, bool force)
  93 {
  94         int fd = eh->GetFd();
  95         if ((fd < 0) || (fd > GetMaxFds() - 1))
  96                 return false;
  97
  98         struct epoll_event ev;
  99         memset(&ev,0,sizeof(struct epoll_event));
 100         eh->Readable() ? ev.events = EPOLLIN : ev.events = EPOLLOUT;
 101         ev.data.fd = fd;
 102         int i = epoll_ctl(EngineHandle, EPOLL_CTL_DEL, fd, &ev);
 103
 104         if (i < 0 && !force)
 105         {
 106                 ServerInstance->Logs->Log("SOCKET",DEBUG,"Cant remove socket: %s", strerror(errno));
 107                 return false;
 108         }
 109
 110         ref[fd] = NULL;
 111         CurrentSetSize--;
 112
 113         ServerInstance->Logs->Log("SOCKET",DEBUG,"Remove file descriptor: %d", fd);
 114         return true;
 115 }
 116
 117 int EPollEngine::GetMaxFds()
 118 {
 119         if (MAX_DESCRIPTORS)
 120                 return MAX_DESCRIPTORS;
 121
 122         int max = ulimit(4, 0);
 123         if (max > 0)
 124         {
 125                 MAX_DESCRIPTORS = max;
 126                 return max;
 127         }
 128         else
 129         {
 130                 ServerInstance->Logs->Log("SOCKET", DEFAULT, "ERROR: Can't determine maximum number of open sockets!");
 131                 printf("ERROR: Can't determine maximum number of open sockets!\n");
 132                 ServerInstance->Exit(EXIT_STATUS_SOCKETENGINE);
 133         }
 134         return 0;
 135 }
 136
 137 int EPollEngine::GetRemainingFds()
 138 {
 139         return GetMaxFds() - CurrentSetSize;
 140 }
 141
 142 int EPollEngine::DispatchEvents()
 143 {
 144         socklen_t codesize;
 145         int errcode;
 146         int i = epoll_wait(EngineHandle, events, GetMaxFds() - 1, 1000);
 147
 148         TotalEvents += i;
 149
 150         for (int j = 0; j < i; j++)
 151         {
 152                 if (events[j].events & EPOLLHUP)
 153                 {
 154                         ErrorEvents++;
 155                         if (ref[events[j].data.fd])
 156                                 ref[events[j].data.fd]->HandleEvent(EVENT_ERROR, 0);
 157                         continue;
 158                 }
 159                 if (events[j].events & EPOLLERR)
 160                 {
 161                         ErrorEvents++;
 162                         /* Get error number */
 163                         if (getsockopt(events[j].data.fd, SOL_SOCKET, SO_ERROR, &errcode, &codesize) < 0)
 164                                 errcode = errno;
 165                         if (ref[events[j].data.fd])
 166                                 ref[events[j].data.fd]->HandleEvent(EVENT_ERROR, errcode);
 167                         continue;
 168                 }
 169                 if (events[j].events & EPOLLOUT)
 170                 {
 171                         WriteEvents++;
 172                         struct epoll_event ev;
 173                         memset(&ev,0,sizeof(struct epoll_event));
 174                         ev.events = EPOLLIN;
 175                         ev.data.fd = events[j].data.fd;
 176                         epoll_ctl(EngineHandle, EPOLL_CTL_MOD, events[j].data.fd, &ev);
 177                         if (ref[events[j].data.fd])
 178                                 ref[events[j].data.fd]->HandleEvent(EVENT_WRITE);
 179                 }
 180                 else
 181                 {
 182                         ReadEvents++;
 183                         if (ref[events[j].data.fd])
 184                                 ref[events[j].data.fd]->HandleEvent(EVENT_READ);
 185                 }
 186         }
 187
 188         return i;
 189 }
 190
 191 std::string EPollEngine::GetName()
 192 {
 193         return "epoll";
 194 }
 195