src/socketengines/socketengine_ports.cpp

   1 /*       +------------------------------------+
   2  *       | Inspire Internet Relay Chat Daemon |
   3  *       +------------------------------------+
   4  *
   5  *  InspIRCd: (C) 2002-2010 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 <port.h>
  17
  18 #ifndef __SOCKETENGINE_PORTS__
  19 #define __SOCKETENGINE_PORTS__
  20
  21 #ifndef __sun
  22 # error You need Solaris 10 or later to make use of this code.
  23 #endif
  24
  25 #include <vector>
  26 #include <string>
  27 #include <map>
  28 #include "inspircd_config.h"
  29 #include "inspircd.h"
  30 #include "socketengine.h"
  31 #include <port.h>
  32
  33 /** A specialisation of the SocketEngine class, designed to use solaris 10 I/O completion ports
  34  */
  35 class PortsEngine : public SocketEngine
  36 {
  37 private:
  38         /** These are used by epoll() to hold socket events
  39          */
  40         port_event_t* events;
  41 public:
  42         /** Create a new PortsEngine
  43          * @param Instance The creator of this object
  44          */
  45         PortsEngine();
  46         /** Delete a PortsEngine
  47          */
  48         virtual ~PortsEngine();
  49         virtual bool AddFd(EventHandler* eh, int event_mask);
  50         void OnSetEvent(EventHandler* eh, int old_event, int new_event);
  51         virtual void DelFd(EventHandler* eh);
  52         virtual int DispatchEvents();
  53         virtual std::string GetName();
  54         virtual void WantWrite(EventHandler* eh);
  55 };
  56
  57 #endif
  58
  59
  60 #include <ulimit.h>
  61
  62 PortsEngine::PortsEngine()
  63 {
  64         int max = ulimit(4, 0);
  65         if (max > 0)
  66         {
  67                 MAX_DESCRIPTORS = max;
  68         }
  69         else
  70         {
  71                 ServerInstance->Logs->Log("SOCKET", DEFAULT, "ERROR: Can't determine maximum number of open sockets!");
  72                 printf("ERROR: Can't determine maximum number of open sockets!\n");
  73                 ServerInstance->Exit(EXIT_STATUS_SOCKETENGINE);
  74         }
  75         EngineHandle = port_create();
  76
  77         if (EngineHandle == -1)
  78         {
  79                 ServerInstance->Logs->Log("SOCKET",SPARSE,"ERROR: Could not initialize socket engine: %s", strerror(errno));
  80                 ServerInstance->Logs->Log("SOCKET",SPARSE,"ERROR: This is a fatal error, exiting now.");
  81                 printf("ERROR: Could not initialize socket engine: %s\n", strerror(errno));
  82                 printf("ERROR: This is a fatal error, exiting now.\n");
  83                 ServerInstance->Exit(EXIT_STATUS_SOCKETENGINE);
  84         }
  85         CurrentSetSize = 0;
  86
  87         ref = new EventHandler* [GetMaxFds()];
  88         events = new port_event_t[GetMaxFds()];
  89         memset(ref, 0, GetMaxFds() * sizeof(EventHandler*));
  90 }
  91
  92 PortsEngine::~PortsEngine()
  93 {
  94         this->Close(EngineHandle);
  95         delete[] ref;
  96         delete[] events;
  97 }
  98
  99 static int mask_to_events(int event_mask)
 100 {
 101         int rv = 0;
 102         if (event_mask & (FD_WANT_POLL_READ | FD_WANT_FAST_READ))
 103                 rv |= POLLRDNORM;
 104         if (event_mask & (FD_WANT_POLL_WRITE | FD_WANT_FAST_WRITE | FD_WANT_SINGLE_WRITE))
 105                 rv |= POLLWRNORM;
 106         return rv;
 107 }
 108
 109 bool PortsEngine::AddFd(EventHandler* eh, int event_mask)
 110 {
 111         int fd = eh->GetFd();
 112         if ((fd < 0) || (fd > GetMaxFds() - 1))
 113                 return false;
 114
 115         if (ref[fd])
 116                 return false;
 117
 118         ref[fd] = eh;
 119         SocketEngine::SetEventMask(eh, event_mask);
 120         port_associate(EngineHandle, PORT_SOURCE_FD, fd, mask_to_events(event_mask), eh);
 121
 122         ServerInstance->Logs->Log("SOCKET",DEBUG,"New file descriptor: %d", fd);
 123         CurrentSetSize++;
 124         return true;
 125 }
 126
 127 void PortsEngine::WantWrite(EventHandler* eh, int old_mask, int new_mask)
 128 {
 129         if (mask_to_events(new_mask) != mask_to_events(old_mask))
 130                 port_associate(EngineHandle, PORT_SOURCE_FD, eh->GetFd(), mask_to_events(new_mask), eh);
 131 }
 132
 133 void PortsEngine::DelFd(EventHandler* eh)
 134 {
 135         int fd = eh->GetFd();
 136         if ((fd < 0) || (fd > GetMaxFds() - 1))
 137                 return;
 138
 139         port_dissociate(EngineHandle, PORT_SOURCE_FD, fd);
 140
 141         CurrentSetSize--;
 142         ref[fd] = NULL;
 143
 144         ServerInstance->Logs->Log("SOCKET",DEBUG,"Remove file descriptor: %d", fd);
 145         return true;
 146 }
 147
 148 int PortsEngine::DispatchEvents()
 149 {
 150         struct timespec poll_time;
 151
 152         poll_time.tv_sec = 1;
 153         poll_time.tv_nsec = 0;
 154
 155         unsigned int nget = 1; // used to denote a retrieve request.
 156         int i = port_getn(EngineHandle, this->events, GetMaxFds() - 1, &nget, &poll_time);
 157         ServerInstance->UpdateTime();
 158
 159         // first handle an error condition
 160         if (i == -1)
 161                 return i;
 162
 163         TotalEvents += nget;
 164
 165         for (i = 0; i < nget; i++)
 166         {
 167                 switch (this->events[i].portev_source)
 168                 {
 169                         case PORT_SOURCE_FD:
 170                         {
 171                                 int fd = this->events[i].portev_object;
 172                                 EventHandler* eh = ref[fd];
 173                                 if (eh)
 174                                 {
 175                                         int mask = eh->GetEventMask();
 176                                         if (events[i].portev_events & POLLWRNORM)
 177                                                 mask &= ~(FD_WRITE_WILL_BLOCK | FD_WANT_FAST_WRITE | FD_WANT_SINGLE_WRITE);
 178                                         if (events[i].portev_events & POLLRDNORM)
 179                                                 mask &= ~FD_READ_WILL_BLOCK;
 180                                         // reinsert port for next time around, pretending to be one-shot for writes
 181                                         SetEventMask(ev, mask);
 182                                         port_associate(EngineHandle, PORT_SOURCE_FD, fd, mask_to_events(mask), eh);
 183                                         if (events[i].portev_events & POLLRDNORM)
 184                                         {
 185                                                 ReadEvents++;
 186                                                 eh->HandleEvent(EVENT_READ);
 187                                                 if (eh != ref[fd])
 188                                                         continue;
 189                                         }
 190                                         if (events[i].portev_events & POLLWRNORM)
 191                                         {
 192                                                 WriteEvents++;
 193                                                 eh->HandleEvent(EVENT_WRITE);
 194                                         }
 195                                 }
 196                         }
 197                         default:
 198                         break;
 199                 }
 200         }
 201
 202         return i;
 203 }
 204
 205 std::string PortsEngine::GetName()
 206 {
 207         return "ports";
 208 }
 209
 210 SocketEngine* CreateSocketEngine()
 211 {
 212         return new PortsEngine;
 213 }