ircd/engine_devpoll.c

   1 /*
   2  * IRC - Internet Relay Chat, ircd/engine_devpoll.c
   3  * Copyright (C) 2001 Kevin L. Mitchell <klmitch@mit.edu>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 1, or (at your option)
   8  * any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  *
  19  * $Id$
  20  */
  21 #include "config.h"
  22
  23 #include "ircd_events.h"
  24
  25 #include "ircd.h"
  26 #include "ircd_alloc.h"
  27 #include "ircd_log.h"
  28 #include "s_debug.h"
  29
  30 #include <assert.h>
  31 #include <errno.h>
  32 #include <fcntl.h>
  33 #include <sys/devpoll.h>
  34 #include <sys/poll.h>
  35 #include <sys/socket.h>
  36 #include <sys/stat.h>
  37 #include <sys/types.h>
  38 #include <unistd.h>
  39
  40 #define DEVPOLL_ERROR_THRESHOLD 20      /* after 20 devpoll errors, restart */
  41 #define ERROR_EXPIRE_TIME       3600    /* expire errors after an hour */
  42
  43 #define POLLS_PER_DEVPOLL       20      /* get 20 pollfd's per turn */
  44
  45 /* Figure out what bits to set for read */
  46 #if defined(POLLMSG) && defined(POLLIN) && defined(POLLRDNORM)
  47 #  define POLLREADFLAGS (POLLMSG|POLLIN|POLLRDNORM)
  48 #elif defined(POLLIN) && defined(POLLRDNORM)
  49 #  define POLLREADFLAGS (POLLIN|POLLRDNORM)
  50 #elif defined(POLLIN)
  51 #  define POLLREADFLAGS POLLIN
  52 #elif defined(POLLRDNORM)
  53 #  define POLLREADFLAGS POLLRDNORM
  54 #endif
  55
  56 /* Figure out what bits to set for write */
  57 #if defined(POLLOUT) && defined(POLLWRNORM)
  58 #  define POLLWRITEFLAGS (POLLOUT|POLLWRNORM)
  59 #elif defined(POLLOUT)
  60 #  define POLLWRITEFLAGS POLLOUT
  61 #elif defined(POLLWRNORM)
  62 #  define POLLWRITEFLAGS POLLWRNORM
  63 #endif
  64
  65 static struct Socket** sockList;
  66 static int devpoll_max;
  67 static int devpoll_fd;
  68
  69 static int errors = 0;
  70 static struct Timer clear_error;
  71
  72 /* decrements the error count once per hour */
  73 static void
  74 error_clear(struct Event* ev)
  75 {
  76   if (!--errors) /* remove timer when error count reaches 0 */
  77     timer_del(ev_timer(ev));
  78 }
  79
  80 /* initialize the devpoll engine */
  81 static int
  82 engine_init(int max_sockets)
  83 {
  84   int i;
  85
  86   if ((devpoll_fd = open("/dev/poll", O_RDWR)) < 0) {
  87     log_write(LS_SYSTEM, L_WARNING, 0,
  88               "/dev/poll engine cannot open device: %m");
  89     return 0; /* engine cannot be initialized; defer */
  90   }
  91
  92   /* allocate necessary memory */
  93   sockList = (struct Socket**) MyMalloc(sizeof(struct Socket*) * max_sockets);
  94
  95   /* initialize the data */
  96   for (i = 0; i < max_sockets; i++)
  97     sockList[i] = 0;
  98
  99   devpoll_max = max_sockets; /* number of sockets allocated */
 100
 101   return 1;
 102 }
 103
 104 /* Figure out what events go with a given state */
 105 static unsigned int
 106 state_to_events(enum SocketState state, unsigned int events)
 107 {
 108   switch (state) {
 109   case SS_CONNECTING: /* connecting socket */
 110     return SOCK_EVENT_WRITABLE;
 111     break;
 112
 113   case SS_LISTENING: /* listening socket */
 114   case SS_NOTSOCK: /* our signal socket */
 115     return SOCK_EVENT_READABLE;
 116     break;
 117
 118   case SS_CONNECTED: case SS_DATAGRAM: case SS_CONNECTDG:
 119     return events; /* ordinary socket */
 120     break;
 121   }
 122
 123   /*NOTREACHED*/
 124   return 0;
 125 }
 126
 127 /* Reset the desired events */
 128 static void
 129 set_events(struct Socket* sock, unsigned int events)
 130 {
 131   struct pollfd pfd;
 132
 133   pfd.fd = s_fd(sock);
 134
 135   if (s_ed_int(sock)) { /* is one in /dev/poll already? */
 136     pfd.events = POLLREMOVE; /* First, remove old pollfd */
 137
 138     Debug((DEBUG_ENGINE, "devpoll: Removing old entry for socket %d [%p]",
 139            s_fd(sock), sock));
 140
 141     if (write(devpoll_fd, &pfd, sizeof(pfd)) != sizeof(pfd)) {
 142       event_generate(ET_ERROR, sock, errno); /* report error */
 143       return;
 144     }
 145
 146     s_ed_int(sock) = 0; /* mark that it's gone */
 147   }
 148
 149   if (!(events & SOCK_EVENT_MASK)) /* no events, so stop here */
 150     return;
 151
 152   pfd.events = 0; /* Now, set up new pollfd... */
 153   if (events & SOCK_EVENT_READABLE)
 154     pfd.events |= POLLREADFLAGS; /* look for readable conditions */
 155   if (events & SOCK_EVENT_WRITABLE)
 156     pfd.events |= POLLWRITEFLAGS; /* look for writable conditions */
 157
 158   Debug((DEBUG_ENGINE, "devpoll: Registering interest on %d [%p] (state %s, "
 159          "mask [%s])", s_fd(sock), sock, state_to_name(s_state(sock)),
 160          sock_flags(s_events(sock))));
 161
 162   if (write(devpoll_fd, &pfd, sizeof(pfd)) != sizeof(pfd)) {
 163     event_generate(ET_ERROR, sock, errno); /* report error */
 164     return;
 165   }
 166
 167   s_ed_int(sock) = 1; /* mark that we've added a pollfd */
 168 }
 169
 170 /* add a socket to be listened on */
 171 static int
 172 engine_add(struct Socket* sock)
 173 {
 174   assert(0 != sock);
 175   assert(0 == sockList[s_fd(sock)]);
 176
 177   /* bounds-check... */
 178   if (s_fd(sock) >= devpoll_max) {
 179     log_write(LS_SYSTEM, L_ERROR, 0,
 180               "Attempt to add socket %d (> %d) to event engine", s_fd(sock),
 181               devpoll_max);
 182     return 0;
 183   }
 184
 185   sockList[s_fd(sock)] = sock; /* add to list */
 186
 187   Debug((DEBUG_ENGINE, "devpoll: Adding socket %d [%p], state %s, to engine",
 188          s_fd(sock), sock, state_to_name(s_state(sock))));
 189
 190   /* set the correct events */
 191   set_events(sock, state_to_events(s_state(sock), s_events(sock)));
 192
 193   return 1; /* success */
 194 }
 195
 196 /* socket switching to new state */
 197 static void
 198 engine_state(struct Socket* sock, enum SocketState new_state)
 199 {
 200   assert(0 != sock);
 201   assert(sock == sockList[s_fd(sock)]);
 202
 203   Debug((DEBUG_ENGINE, "devpoll: Changing state for socket %p to %s", sock,
 204          state_to_name(new_state)));
 205
 206   /* set the correct events */
 207   set_events(sock, state_to_events(new_state, s_events(sock)));
 208 }
 209
 210 /* socket events changing */
 211 static void
 212 engine_events(struct Socket* sock, unsigned int new_events)
 213 {
 214   assert(0 != sock);
 215   assert(sock == sockList[s_fd(sock)]);
 216
 217   Debug((DEBUG_ENGINE, "devpoll: Changing event mask for socket %p to [%s]",
 218          sock, sock_flags(new_events)));
 219
 220   /* set the correct events */
 221   set_events(sock, state_to_events(s_state(sock), new_events));
 222 }
 223
 224 /* socket going away */
 225 static void
 226 engine_delete(struct Socket* sock)
 227 {
 228   assert(0 != sock);
 229   assert(sock == sockList[s_fd(sock)]);
 230
 231   Debug((DEBUG_ENGINE, "devpoll: Deleting socket %d [%p], state %s",
 232          s_fd(sock), sock, state_to_name(s_state(sock))));
 233
 234   set_events(sock, 0); /* get rid of the socket */
 235
 236   sockList[s_fd(sock)] = 0; /* zero the socket list entry */
 237 }
 238
 239 /* engine event loop */
 240 static void
 241 engine_loop(struct Generators* gen)
 242 {
 243   struct dvpoll dopoll;
 244   struct pollfd polls[POLLS_PER_DEVPOLL];
 245   struct Socket* sock;
 246   int nfds;
 247   int i;
 248   int errcode;
 249   size_t codesize;
 250
 251   while (running) {
 252     dopoll.dp_fds = polls; /* set up the struct dvpoll */
 253     dopoll.dp_nfds = POLLS_PER_DEVPOLL;
 254
 255     /* calculate the proper timeout */
 256     dopoll.dp_timeout = timer_next(gen) ?
 257       (timer_next(gen) - CurrentTime) * 1000 : -1;
 258
 259     Debug((DEBUG_INFO, "devpoll: delay: %Tu (%Tu) %d", timer_next(gen),
 260            CurrentTime, dopoll.dp_timeout));
 261
 262     /* check for active files */
 263     nfds = ioctl(devpoll_fd, DP_POLL, &dopoll);
 264
 265     CurrentTime = time(0); /* set current time... */
 266
 267     if (nfds < 0) {
 268       if (errno != EINTR) { /* ignore interrupts */
 269         /* Log the poll error */
 270         log_write(LS_SOCKET, L_ERROR, 0, "ioctl(DP_POLL) error: %m");
 271         if (!errors++)
 272           timer_add(&clear_error, error_clear, 0, TT_PERIODIC,
 273                     ERROR_EXPIRE_TIME);
 274         else if (errors > DEVPOLL_ERROR_THRESHOLD) /* too many errors... */
 275           server_restart("too many /dev/poll errors");
 276       }
 277       /* old code did a sleep(1) here; with usage these days,
 278        * that may be too expensive
 279        */
 280       continue;
 281     }
 282
 283     for (i = 0; i < nfds; i++) {
 284       assert(-1 < polls[i].fd);
 285       assert(0 != sockList[polls[i].fd]);
 286       assert(s_fd(sockList[polls[i].fd]) == polls[i].fd);
 287
 288       sock = sockList[polls[i].fd];
 289       if (!sock) /* slots may become empty while processing events */
 290         continue;
 291
 292       gen_ref_inc(sock); /* can't have it going away on us */
 293
 294       Debug((DEBUG_ENGINE, "devpoll: Checking socket %p (fd %d) state %s, "
 295              "events %s", sock, s_fd(sock), state_to_name(s_state(sock)),
 296              sock_flags(s_events(sock))));
 297
 298       if (s_state(sock) != SS_NOTSOCK) {
 299         errcode = 0; /* check for errors on socket */
 300         codesize = sizeof(errcode);
 301         if (getsockopt(s_fd(sock), SOL_SOCKET, SO_ERROR, &errcode,
 302                        &codesize) < 0)
 303           errcode = errno; /* work around Solaris implementation */
 304
 305         if (errcode) { /* an error occurred; generate an event */
 306           Debug((DEBUG_ENGINE, "devpoll: Error %d on fd %d, socket %p",
 307                  errcode, s_fd(sock), sock));
 308           event_generate(ET_ERROR, sock, errcode);
 309           gen_ref_dec(sock); /* careful not to leak reference counts */
 310           continue;
 311         }
 312       }
 313
 314       assert(!(polls[i].revents & POLLERR));
 315
 316 #ifdef POLLHUP
 317       if (polls[i].revents & POLLHUP) { /* hang-up on socket */
 318         Debug((DEBUG_ENGINE, "devpoll: EOF from client (POLLHUP)"));
 319         event_generate(ET_EOF, sock, 0);
 320         nfds--;
 321         continue;
 322       }
 323 #endif /* POLLHUP */
 324
 325       switch (s_state(sock)) {
 326       case SS_CONNECTING:
 327         if (polls[i].revents & POLLWRITEFLAGS) { /* connection completed */
 328           Debug((DEBUG_ENGINE, "devpoll: Connection completed"));
 329           event_generate(ET_CONNECT, sock, 0);
 330         }
 331         break;
 332
 333       case SS_LISTENING:
 334         if (polls[i].revents & POLLREADFLAGS) { /* connect. to be accept. */
 335           Debug((DEBUG_ENGINE, "devpoll: Ready for accept"));
 336           event_generate(ET_ACCEPT, sock, 0);
 337         }
 338         break;
 339
 340       case SS_NOTSOCK:
 341         if (polls[i].revents & POLLREADFLAGS) { /* data on socket */
 342           /* can't peek; it's not a socket */
 343           Debug((DEBUG_ENGINE, "devpoll: non-socket readable"));
 344           event_generate(ET_READ, sock, 0);
 345         }
 346         break;
 347
 348       case SS_CONNECTED:
 349         if (polls[i].revents & POLLREADFLAGS) { /* data on socket */
 350           char c;
 351
 352           switch (recv(s_fd(sock), &c, 1, MSG_PEEK)) { /* check EOF */
 353           case -1: /* error occurred?!? */
 354             if (errno == EAGAIN) {
 355               Debug((DEBUG_ENGINE, "devpoll: Resource temporarily "
 356                      "unavailable?"));
 357               continue;
 358             }
 359             Debug((DEBUG_ENGINE, "devpoll: Uncaught error!"));
 360             event_generate(ET_ERROR, sock, errno);
 361             break;
 362
 363           case 0: /* EOF from client */
 364             Debug((DEBUG_ENGINE, "devpoll: EOF from client"));
 365             event_generate(ET_EOF, sock, 0);
 366             break;
 367
 368           default: /* some data can be read */
 369             Debug((DEBUG_ENGINE, "devpoll: Data to be read"));
 370             event_generate(ET_READ, sock, 0);
 371             break;
 372           }
 373         }
 374         if (polls[i].revents & POLLWRITEFLAGS) { /* socket writable */
 375           Debug((DEBUG_ENGINE, "devpoll: Data can be written"));
 376           event_generate(ET_WRITE, sock, 0);
 377         }
 378         break;
 379
 380       case SS_DATAGRAM: case SS_CONNECTDG:
 381         if (polls[i].revents & POLLREADFLAGS) { /* socket readable */
 382           Debug((DEBUG_ENGINE, "devpoll: Datagram to be read"));
 383           event_generate(ET_READ, sock, 0);
 384         }
 385         if (polls[i].revents & POLLWRITEFLAGS) { /* socket writable */
 386           Debug((DEBUG_ENGINE, "devpoll: Datagram can be written"));
 387           event_generate(ET_WRITE, sock, 0);
 388         }
 389         break;
 390       }
 391
 392       assert(s_fd(sock) == polls[i].fd);
 393
 394       gen_ref_dec(sock); /* we're done with it */
 395     }
 396
 397     timer_run(); /* execute any pending timers */
 398   }
 399 }
 400
 401 struct Engine engine_devpoll = {
 402   "/dev/poll",          /* Engine name */
 403   engine_init,          /* Engine initialization function */
 404   0,                    /* Engine signal registration function */
 405   engine_add,           /* Engine socket registration function */
 406   engine_state,         /* Engine socket state change function */
 407   engine_events,        /* Engine socket events mask function */
 408   engine_delete,        /* Engine socket deletion function */
 409   engine_loop           /* Core engine event loop */
 410 };