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 /* Figure out what bits indicate errors */
  66 #ifdef POLLHUP
  67 #  define POLLERRORS (POLLHUP|POLLERR)
  68 #else
  69 #  define POLLERRORS POLLERR
  70 #endif
  71
  72 static struct Socket** sockList;
  73 static int devpoll_max;
  74 static int devpoll_fd;
  75
  76 static int errors = 0;
  77 static struct Timer clear_error;
  78
  79 /* decrements the error count once per hour */
  80 static void
  81 error_clear(struct Event* ev)
  82 {
  83   if (!--errors) /* remove timer when error count reaches 0 */
  84     timer_del(ev_timer(ev));
  85 }
  86
  87 /* initialize the devpoll engine */
  88 static int
  89 engine_init(int max_sockets)
  90 {
  91   int i;
  92
  93   if ((devpoll_fd = open("/dev/poll", O_RDWR)) < 0) {
  94     log_write(LS_SYSTEM, L_WARNING, 0,
  95               "/dev/poll engine cannot open device: %m");
  96     return 0; /* engine cannot be initialized; defer */
  97   }
  98
  99   /* allocate necessary memory */
 100   sockList = (struct Socket**) MyMalloc(sizeof(struct Socket*) * max_sockets);
 101
 102   /* initialize the data */
 103   for (i = 0; i < max_sockets; i++)
 104     sockList[i] = 0;
 105
 106   devpoll_max = max_sockets; /* number of sockets allocated */
 107
 108   return 1;
 109 }
 110
 111 /* Figure out what events go with a given state */
 112 static unsigned int
 113 state_to_events(enum SocketState state, unsigned int events)
 114 {
 115   switch (state) {
 116   case SS_CONNECTING: /* connecting socket */
 117     return SOCK_EVENT_WRITABLE;
 118     break;
 119
 120   case SS_LISTENING: /* listening socket */
 121   case SS_NOTSOCK: /* our signal socket */
 122     return SOCK_EVENT_READABLE;
 123     break;
 124
 125   case SS_CONNECTED: case SS_DATAGRAM: case SS_CONNECTDG:
 126     return events; /* ordinary socket */
 127     break;
 128   }
 129
 130   /*NOTREACHED*/
 131   return 0;
 132 }
 133
 134 /* Reset the desired events */
 135 static void
 136 set_events(struct Socket* sock, unsigned int events)
 137 {
 138   struct pollfd pfd;
 139
 140   pfd.fd = s_fd(sock);
 141
 142   if (s_ed_int(sock)) { /* is one in /dev/poll already? */
 143     pfd.events = POLLREMOVE; /* First, remove old pollfd */
 144
 145     Debug((DEBUG_ENGINE, "devpoll: Removing old entry for socket %d [%p]",
 146            s_fd(sock), sock));
 147
 148     if (write(devpoll_fd, &pfd, sizeof(pfd)) != sizeof(pfd)) {
 149       event_generate(ET_ERROR, sock, errno); /* report error */
 150       return;
 151     }
 152
 153     s_ed_int(sock) = 0; /* mark that it's gone */
 154   }
 155
 156   if (!(events & SOCK_EVENT_MASK)) /* no events, so stop here */
 157     return;
 158
 159   pfd.events = 0; /* Now, set up new pollfd... */
 160   if (events & SOCK_EVENT_READABLE)
 161     pfd.events |= POLLREADFLAGS; /* look for readable conditions */
 162   if (events & SOCK_EVENT_WRITABLE)
 163     pfd.events |= POLLWRITEFLAGS; /* look for writable conditions */
 164
 165   Debug((DEBUG_ENGINE, "devpoll: Registering interest on %d [%p] (state %s, "
 166          "mask [%s])", s_fd(sock), sock, state_to_name(s_state(sock)),
 167          sock_flags(s_events(sock))));
 168
 169   if (write(devpoll_fd, &pfd, sizeof(pfd)) != sizeof(pfd)) {
 170     event_generate(ET_ERROR, sock, errno); /* report error */
 171     return;
 172   }
 173
 174   s_ed_int(sock) = 1; /* mark that we've added a pollfd */
 175 }
 176
 177 /* add a socket to be listened on */
 178 static int
 179 engine_add(struct Socket* sock)
 180 {
 181   assert(0 != sock);
 182   assert(0 == sockList[s_fd(sock)]);
 183
 184   /* bounds-check... */
 185   if (s_fd(sock) >= devpoll_max) {
 186     log_write(LS_SYSTEM, L_ERROR, 0,
 187               "Attempt to add socket %d (> %d) to event engine", s_fd(sock),
 188               devpoll_max);
 189     return 0;
 190   }
 191
 192   sockList[s_fd(sock)] = sock; /* add to list */
 193
 194   Debug((DEBUG_ENGINE, "devpoll: Adding socket %d [%p], state %s, to engine",
 195          s_fd(sock), sock, state_to_name(s_state(sock))));
 196
 197   /* set the correct events */
 198   set_events(sock, state_to_events(s_state(sock), s_events(sock)));
 199
 200   return 1; /* success */
 201 }
 202
 203 /* socket switching to new state */
 204 static void
 205 engine_state(struct Socket* sock, enum SocketState new_state)
 206 {
 207   assert(0 != sock);
 208   assert(sock == sockList[s_fd(sock)]);
 209
 210   Debug((DEBUG_ENGINE, "devpoll: Changing state for socket %p to %s", sock,
 211          state_to_name(new_state)));
 212
 213   /* set the correct events */
 214   set_events(sock, state_to_events(new_state, s_events(sock)));
 215 }
 216
 217 /* socket events changing */
 218 static void
 219 engine_events(struct Socket* sock, unsigned int new_events)
 220 {
 221   assert(0 != sock);
 222   assert(sock == sockList[s_fd(sock)]);
 223
 224   Debug((DEBUG_ENGINE, "devpoll: Changing event mask for socket %p to [%s]",
 225          sock, sock_flags(new_events)));
 226
 227   /* set the correct events */
 228   set_events(sock, state_to_events(s_state(sock), new_events));
 229 }
 230
 231 /* socket going away */
 232 static void
 233 engine_delete(struct Socket* sock)
 234 {
 235   assert(0 != sock);
 236   assert(sock == sockList[s_fd(sock)]);
 237
 238   Debug((DEBUG_ENGINE, "devpoll: Deleting socket %d [%p], state %s",
 239          s_fd(sock), sock, state_to_name(s_state(sock))));
 240
 241   set_events(sock, 0); /* get rid of the socket */
 242
 243   sockList[s_fd(sock)] = 0; /* zero the socket list entry */
 244 }
 245
 246 /* engine event loop */
 247 static void
 248 engine_loop(struct Generators* gen)
 249 {
 250   struct dvpoll dopoll;
 251   struct pollfd polls[POLLS_PER_DEVPOLL];
 252   struct Socket* sock;
 253   int nfds;
 254   int i;
 255   int errcode;
 256   size_t codesize;
 257
 258   while (running) {
 259     dopoll.dp_fds = polls; /* set up the struct dvpoll */
 260     dopoll.dp_nfds = POLLS_PER_DEVPOLL;
 261
 262     /* calculate the proper timeout */
 263     dopoll.dp_timeout = timer_next(gen) ?
 264       (timer_next(gen) - CurrentTime) * 1000 : -1;
 265
 266     Debug((DEBUG_INFO, "devpoll: delay: %Tu (%Tu) %d", timer_next(gen),
 267            CurrentTime, dopoll.dp_timeout));
 268
 269     /* check for active files */
 270     nfds = ioctl(devpoll_fd, DP_POLL, &dopoll);
 271
 272     CurrentTime = time(0); /* set current time... */
 273
 274     if (nfds < 0) {
 275       if (errno != EINTR) { /* ignore interrupts */
 276         /* Log the poll error */
 277         log_write(LS_SOCKET, L_ERROR, 0, "ioctl(DP_POLL) error: %m");
 278         if (!errors++)
 279           timer_add(&clear_error, error_clear, 0, TT_PERIODIC,
 280                     ERROR_EXPIRE_TIME);
 281         else if (errors > DEVPOLL_ERROR_THRESHOLD) /* too many errors... */
 282           server_restart("too many /dev/poll errors");
 283       }
 284       /* old code did a sleep(1) here; with usage these days,
 285        * that may be too expensive
 286        */
 287       continue;
 288     }
 289
 290     for (i = 0; i < nfds; i++) {
 291       assert(-1 < polls[i].fd);
 292       assert(0 != sockList[polls[i].fd]);
 293       assert(s_fd(sockList[polls[i].fd]) == polls[i].fd);
 294
 295       sock = sockList[polls[i].fd];
 296       if (!sock) /* slots may become empty while processing events */
 297         continue;
 298
 299       gen_ref_inc(sock); /* can't have it going away on us */
 300
 301       Debug((DEBUG_ENGINE, "devpoll: Checking socket %p (fd %d) state %s, "
 302              "events %s", sock, s_fd(sock), state_to_name(s_state(sock)),
 303              sock_flags(s_events(sock))));
 304
 305       if (s_state(sock) != SS_NOTSOCK) {
 306         errcode = 0; /* check for errors on socket */
 307         codesize = sizeof(errcode);
 308         if (getsockopt(s_fd(sock), SOL_SOCKET, SO_ERROR, &errcode,
 309                        &codesize) < 0)
 310           errcode = errno; /* work around Solaris implementation */
 311
 312         if (errcode) { /* an error occurred; generate an event */
 313           Debug((DEBUG_ENGINE, "devpoll: Error %d on fd %d, socket %p",
 314                  errcode, s_fd(sock), sock));
 315           event_generate(ET_ERROR, sock, errcode);
 316           gen_ref_dec(sock); /* careful not to leak reference counts */
 317           continue;
 318         }
 319       }
 320
 321       switch (s_state(sock)) {
 322       case SS_CONNECTING:
 323         if (polls[i].revents & POLLWRITEFLAGS) { /* connection completed */
 324           Debug((DEBUG_ENGINE, "devpoll: Connection completed"));
 325           event_generate(ET_CONNECT, sock, 0);
 326         }
 327         break;
 328
 329       case SS_LISTENING:
 330         if (polls[i].revents & POLLREADFLAGS) { /* connect. to be accept. */
 331           Debug((DEBUG_ENGINE, "devpoll: Ready for accept"));
 332           event_generate(ET_ACCEPT, sock, 0);
 333         }
 334         break;
 335
 336       case SS_NOTSOCK:
 337         if (polls[i].revents & POLLREADFLAGS) { /* data on socket */
 338           /* can't peek; it's not a socket */
 339           Debug((DEBUG_ENGINE, "devpoll: non-socket readable"));
 340           event_generate(ET_READ, sock, 0);
 341         }
 342         break;
 343
 344       case SS_CONNECTED:
 345         if (polls[i].revents & POLLREADFLAGS) { /* data on socket */
 346           char c;
 347
 348           switch (recv(s_fd(sock), &c, 1, MSG_PEEK)) { /* check EOF */
 349           case -1: /* error occurred?!? */
 350             if (errno == EAGAIN) {
 351               Debug((DEBUG_ENGINE, "devpoll: Resource temporarily "
 352                      "unavailable?"));
 353               continue;
 354             }
 355             Debug((DEBUG_ENGINE, "devpoll: Uncaught error!"));
 356             event_generate(ET_ERROR, sock, errno);
 357             break;
 358
 359           case 0: /* EOF from client */
 360             Debug((DEBUG_ENGINE, "devpoll: EOF from client"));
 361             event_generate(ET_EOF, sock, 0);
 362             break;
 363
 364           default: /* some data can be read */
 365             Debug((DEBUG_ENGINE, "devpoll: Data to be read"));
 366             event_generate(ET_READ, sock, 0);
 367             break;
 368           }
 369         }
 370         if (polls[i].revents & POLLWRITEFLAGS) { /* socket writable */
 371           Debug((DEBUG_ENGINE, "devpoll: Data can be written"));
 372           event_generate(ET_WRITE, sock, 0);
 373         }
 374         break;
 375
 376       case SS_DATAGRAM: case SS_CONNECTDG:
 377         if (polls[i].revents & POLLREADFLAGS) { /* socket readable */
 378           Debug((DEBUG_ENGINE, "devpoll: Datagram to be read"));
 379           event_generate(ET_READ, sock, 0);
 380         }
 381         if (polls[i].revents & POLLWRITEFLAGS) { /* socket writable */
 382           Debug((DEBUG_ENGINE, "devpoll: Datagram can be written"));
 383           event_generate(ET_WRITE, sock, 0);
 384         }
 385         break;
 386       }
 387
 388       assert(s_fd(sock) == polls[i].fd);
 389
 390       gen_ref_dec(sock); /* we're done with it */
 391     }
 392
 393     timer_run(); /* execute any pending timers */
 394   }
 395 }
 396
 397 struct Engine engine_devpoll = {
 398   "/dev/poll",          /* Engine name */
 399   engine_init,          /* Engine initialization function */
 400   0,                    /* Engine signal registration function */
 401   engine_add,           /* Engine socket registration function */
 402   engine_state,         /* Engine socket state change function */
 403   engine_events,        /* Engine socket events mask function */
 404   engine_delete,        /* Engine socket deletion function */
 405   engine_loop           /* Core engine event loop */
 406 };