src/epoll.c

   1 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2
   3 /*  Monkey HTTP Daemon
   4  *  ------------------
   5  *  Copyright (C) 2008, Eduardo Silva P.
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU Library General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  20  */
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <assert.h>
  25 #include <errno.h>
  26 #include <unistd.h>
  27 #include <fcntl.h>
  28
  29 #include <sys/types.h>
  30 #include <sys/socket.h>
  31 #include <sys/epoll.h>
  32
  33 #include "monkey.h"
  34 #include "socket.h"
  35 #include "clock.h"
  36 #include "request.h"
  37 #include "config.h"
  38 #include "scheduler.h"
  39 #include "epoll.h"
  40 #include "utils.h"
  41
  42 #define MAX_EVENTS 5000
  43
  44 mk_epoll_handlers *mk_epoll_set_handlers(void (*read) (int),
  45                                          void (*write) (int),
  46                                          void (*error) (int),
  47                                          void (*close) (int),
  48                                          void (*timeout) (int))
  49 {
  50     mk_epoll_handlers *handler;
  51
  52     handler = malloc(sizeof(mk_epoll_handlers));
  53     handler->read = (void *) read;
  54     handler->write = (void *) write;
  55     handler->error = (void *) error;
  56     handler->close = (void *) close;
  57     handler->timeout = (void *) timeout;
  58
  59     return handler;
  60 }
  61
  62 int mk_epoll_create(int max_events)
  63 {
  64     int efd;
  65
  66     efd = epoll_create(max_events);
  67     if (efd == -1) {
  68         perror("epoll_create");
  69     }
  70
  71     return efd;
  72 }
  73
  74 void *mk_epoll_init(int efd, mk_epoll_handlers * handler, int max_events)
  75 {
  76     int i, fd, ret = -1;
  77     int num_fds;
  78     int fds_timeout;
  79     struct epoll_event events[max_events];
  80     struct sched_list_node *sched;
  81
  82     /* Get thread conf */
  83     sched = mk_sched_get_thread_conf();
  84
  85     pthread_mutex_lock(&mutex_wait_register);
  86     pthread_mutex_unlock(&mutex_wait_register);
  87
  88     fds_timeout = log_current_utime + config->timeout;
  89
  90     while (1) {
  91         num_fds = epoll_wait(efd, events, max_events, MK_EPOLL_WAIT_TIMEOUT);
  92
  93         for (i = 0; i < num_fds; i++) {
  94             fd = events[i].data.fd;
  95
  96             // Case 1: Error condition
  97             if (events[i].events & (EPOLLHUP | EPOLLERR)) {
  98                 (*handler->error) (fd);
  99 #ifdef TRACE
 100                 MK_TRACE("EPoll, fd %i in EPOLLHUP or EPOLLER", fd);
 101 #endif
 102                 continue;
 103             }
 104
 105             if (events[i].events & EPOLLIN) {
 106 #ifdef TRACE
 107                 MK_TRACE("EPoll, fd %i in READ event", fd);
 108 #endif
 109                 ret = (*handler->read) (fd);
 110             }
 111             else if (events[i].events & EPOLLOUT) {
 112 #ifdef TRACE
 113                 MK_TRACE("EPoll, fd %i in WRITE event", fd);
 114 #endif
 115                 ret = (*handler->write) (fd);
 116             }
 117
 118             if (ret < 0) {
 119 #ifdef TRACE
 120                 MK_TRACE("Epoll, fd %i in force close status | ret = %i", fd, ret);
 121 #endif
 122                 (*handler->close) (fd);
 123             }
 124         }
 125
 126         /* Check timeouts and update next one */
 127         if (log_current_utime >= fds_timeout) {
 128             mk_sched_check_timeouts(sched);
 129             fds_timeout = log_current_utime + config->timeout;
 130         }
 131     }
 132 }
 133
 134 int mk_epoll_add_client(int efd, int socket, int init_mode, int behavior)
 135 {
 136     int ret;
 137     struct epoll_event event;
 138
 139
 140     event.events = EPOLLERR | EPOLLHUP;
 141     event.data.fd = socket;
 142
 143     if (behavior == MK_EPOLL_BEHAVIOR_TRIGGERED) {
 144         event.events |= EPOLLET;
 145     }
 146
 147     switch (init_mode) {
 148     case MK_EPOLL_READ:
 149         event.events |= EPOLLIN;
 150         break;
 151     case MK_EPOLL_WRITE:
 152         event.events |= EPOLLOUT;
 153         break;
 154     case MK_EPOLL_RW:
 155         event.events |= EPOLLIN | EPOLLOUT;
 156         break;
 157     }
 158
 159     ret = epoll_ctl(efd, EPOLL_CTL_ADD, socket, &event);
 160     if (ret < 0) {
 161         perror("epoll_ctl");
 162     }
 163     return ret;
 164 }
 165
 166 int mk_epoll_socket_change_mode(int efd, int socket, int mode)
 167 {
 168     int ret;
 169     struct epoll_event event;
 170
 171     event.events = EPOLLET | EPOLLERR | EPOLLHUP;
 172     event.data.fd = socket;
 173
 174 #ifdef TRACE
 175     MK_TRACE("EPoll, changing FD %i mode", socket);
 176 #endif
 177
 178     switch (mode) {
 179     case MK_EPOLL_READ:
 180 #ifdef TRACE
 181         MK_TRACE("EPoll, changing mode to READ");
 182 #endif
 183         event.events |= EPOLLIN;
 184         break;
 185     case MK_EPOLL_WRITE:
 186 #ifdef TRACE
 187         MK_TRACE("EPoll, changing mode to WRITE");
 188 #endif
 189         event.events |= EPOLLOUT;
 190         break;
 191     case MK_EPOLL_RW:
 192 #ifdef TRACE
 193         MK_TRACE("Epoll, changing mode to READ/WRITE");
 194 #endif
 195         event.events |= EPOLLIN | EPOLLOUT;
 196         break;
 197     }
 198
 199     ret = epoll_ctl(efd, EPOLL_CTL_MOD, socket, &event);
 200     if (ret < 0) {
 201         perror("\nepoll_ctl");
 202     }
 203     return ret;
 204 }