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                 return max;
  69         }
  70         else
  71         {
  72                 ServerInstance->Logs->Log("SOCKET", DEFAULT, "ERROR: Can't determine maximum number of open sockets!");
  73                 printf("ERROR: Can't determine maximum number of open sockets!\n");
  74                 ServerInstance->Exit(EXIT_STATUS_SOCKETENGINE);
  75         }
  76         EngineHandle = port_create();
  77
  78         if (EngineHandle == -1)
  79         {
  80                 ServerInstance->Logs->Log("SOCKET",SPARSE,"ERROR: Could not initialize socket engine: %s", strerror(errno));
  81                 ServerInstance->Logs->Log("SOCKET",SPARSE,"ERROR: This is a fatal error, exiting now.");
  82                 printf("ERROR: Could not initialize socket engine: %s\n", strerror(errno));
  83                 printf("ERROR: This is a fatal error, exiting now.\n");
  84                 ServerInstance->Exit(EXIT_STATUS_SOCKETENGINE);
  85         }
  86         CurrentSetSize = 0;
  87
  88         ref = new EventHandler* [GetMaxFds()];
  89         events = new port_event_t[GetMaxFds()];
  90         memset(ref, 0, GetMaxFds() * sizeof(EventHandler*));
  91 }
  92
  93 PortsEngine::~PortsEngine()
  94 {
  95         this->Close(EngineHandle);
  96         delete[] ref;
  97         delete[] events;
  98 }
  99
 100 static int mask_to_events(int event_mask)
 101 {
 102         int rv = 0;
 103         if (event_mask & (FD_WANT_POLL_READ | FD_WANT_FAST_READ))
 104                 rv |= POLLRDNORM;
 105         if (event_mask & (FD_WANT_POLL_WRITE | FD_WANT_FAST_WRITE | FD_WANT_SINGLE_WRITE))
 106                 rv |= POLLWRNORM;
 107         return rv;
 108 }
 109
 110 bool PortsEngine::AddFd(EventHandler* eh, int event_mask)
 111 {
 112         int fd = eh->GetFd();
 113         if ((fd < 0) || (fd > GetMaxFds() - 1))
 114                 return false;
 115
 116         if (ref[fd])
 117                 return false;
 118
 119         ref[fd] = eh;
 120         SocketEngine::SetEventMask(eh, event_mask);
 121         port_associate(EngineHandle, PORT_SOURCE_FD, fd, mask_to_events(event_mask), eh);
 122
 123         ServerInstance->Logs->Log("SOCKET",DEBUG,"New file descriptor: %d", fd);
 124         CurrentSetSize++;
 125         return true;
 126 }
 127
 128 void PortsEngine::WantWrite(EventHandler* eh, int old_mask, int new_mask)
 129 {
 130         if (mask_to_events(new_mask) != mask_to_events(old_mask))
 131                 port_associate(EngineHandle, PORT_SOURCE_FD, eh->GetFd(), mask_to_events(new_mask), eh);
 132 }
 133
 134 void PortsEngine::DelFd(EventHandler* eh)
 135 {
 136         int fd = eh->GetFd();
 137         if ((fd < 0) || (fd > GetMaxFds() - 1))
 138                 return;
 139
 140         port_dissociate(EngineHandle, PORT_SOURCE_FD, fd);
 141
 142         CurrentSetSize--;
 143         ref[fd] = NULL;
 144
 145         ServerInstance->Logs->Log("SOCKET",DEBUG,"Remove file descriptor: %d", fd);
 146         return true;
 147 }
 148
 149 int PortsEngine::DispatchEvents()
 150 {
 151         struct timespec poll_time;
 152
 153         poll_time.tv_sec = 1;
 154         poll_time.tv_nsec = 0;
 155
 156         unsigned int nget = 1; // used to denote a retrieve request.
 157         int i = port_getn(EngineHandle, this->events, GetMaxFds() - 1, &nget, &poll_time);
 158         ServerInstance->UpdateTime();
 159
 160         // first handle an error condition
 161         if (i == -1)
 162                 return i;
 163
 164         TotalEvents += nget;
 165
 166         for (i = 0; i < nget; i++)
 167         {
 168                 switch (this->events[i].portev_source)
 169                 {
 170                         case PORT_SOURCE_FD:
 171                         {
 172                                 int fd = this->events[i].portev_object;
 173                                 EventHandler* eh = ref[fd];
 174                                 if (eh)
 175                                 {
 176                                         int mask = eh->GetEventMask();
 177                                         if (events[i].portev_events & POLLWRNORM)
 178                                                 mask &= ~(FD_WRITE_WILL_BLOCK | FD_WANT_FAST_WRITE | FD_WANT_SINGLE_WRITE);
 179                                         if (events[i].portev_events & POLLRDNORM)
 180                                                 mask &= ~FD_READ_WILL_BLOCK;
 181                                         // reinsert port for next time around, pretending to be one-shot for writes
 182                                         SetEventMask(ev, mask);
 183                                         port_associate(EngineHandle, PORT_SOURCE_FD, fd, mask_to_events(mask), eh);
 184                                         if (events[i].portev_events & POLLRDNORM)
 185                                         {
 186                                                 ReadEvents++;
 187                                                 eh->HandleEvent(EVENT_READ);
 188                                                 if (eh != ref[fd])
 189                                                         continue;
 190                                         }
 191                                         if (events[i].portev_events & POLLWRNORM)
 192                                         {
 193                                                 WriteEvents++;
 194                                                 eh->HandleEvent(EVENT_WRITE);
 195                                         }
 196                                 }
 197                         }
 198                         default:
 199                         break;
 200                 }
 201         }
 202
 203         return i;
 204 }
 205
 206 std::string PortsEngine::GetName()
 207 {
 208         return "ports";
 209 }
 210
 211 SocketEngine* CreateSocketEngine()
 212 {
 213         return new PortsEngine;
 214 }