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) 2001-2010, Eduardo Silva P. <edsiper@gmail.com>
   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 mk_epoll_handlers *mk_epoll_set_handlers(void (*read) (int),
  43                                          void (*write) (int),
  44                                          void (*error) (int),
  45                                          void (*close) (int),
  46                                          void (*timeout) (int))
  47 {
  48     mk_epoll_handlers *handler;
  49
  50     handler = malloc(sizeof(mk_epoll_handlers));
  51     handler->read = (void *) read;
  52     handler->write = (void *) write;
  53     handler->error = (void *) error;
  54     handler->close = (void *) close;
  55     handler->timeout = (void *) timeout;
  56
  57     return handler;
  58 }
  59
  60 int mk_epoll_create(int max_events)
  61 {
  62     int efd;
  63
  64     efd = epoll_create(max_events);
  65     if (efd == -1) {
  66         perror("epoll_create");
  67     }
  68
  69     return efd;
  70 }
  71
  72 void *mk_epoll_init(int efd, mk_epoll_handlers * handler, int max_events)
  73 {
  74     int i, fd, ret = -1;
  75     int num_fds;
  76     int fds_timeout;
  77
  78     struct epoll_event *events;
  79     struct sched_list_node *sched;
  80
  81     /* Get thread conf */
  82     sched = mk_sched_get_thread_conf();
  83
  84     pthread_mutex_lock(&mutex_wait_register);
  85     pthread_mutex_unlock(&mutex_wait_register);
  86
  87     fds_timeout = log_current_utime + config->timeout;
  88     events = mk_mem_malloc_z(max_events*sizeof(struct epoll_event));
  89
  90     while (1) {
  91         ret = -1;
  92         num_fds = epoll_wait(efd, events, max_events, MK_EPOLL_WAIT_TIMEOUT);
  93
  94         for (i = 0; i < num_fds; i++) {
  95             fd = events[i].data.fd;
  96
  97             if (events[i].events & EPOLLIN) {
  98 #ifdef TRACE
  99                 MK_TRACE("[FD %i] EPoll Event READ", fd);
 100 #endif
 101                 ret = (*handler->read) (fd);
 102             }
 103             else if (events[i].events & EPOLLOUT) {
 104 #ifdef TRACE
 105                 MK_TRACE("[FD %i] EPoll Event WRITE", fd);
 106 #endif
 107                 ret = (*handler->write) (fd);
 108             }
 109
 110             else if (events[i].events & (EPOLLHUP | EPOLLERR | EPOLLRDHUP)) {
 111 #ifdef TRACE
 112                 MK_TRACE("[FD %i] EPoll Event EPOLLHUP/EPOLLER", fd);
 113 #endif
 114                 ret = (*handler->error) (fd);
 115             }
 116
 117             if (ret < 0) {
 118 #ifdef TRACE
 119                 MK_TRACE("[FD %i] Epoll Event FORCE CLOSE | ret = %i", fd, ret);
 120 #endif
 121                 (*handler->close) (fd);
 122             }
 123         }
 124
 125         /* Check timeouts and update next one */
 126         if (log_current_utime >= fds_timeout) {
 127             mk_sched_check_timeouts(sched);
 128             fds_timeout = log_current_utime + config->timeout;
 129         }
 130     }
 131 }
 132
 133 int mk_epoll_add(int efd, int fd, int init_mode, int behavior)
 134 {
 135     int ret;
 136     struct epoll_event event;
 137
 138     event.data.fd = fd;
 139     event.events = EPOLLERR | EPOLLHUP | EPOLLRDHUP;
 140
 141     if (behavior == MK_EPOLL_BEHAVIOR_TRIGGERED) {
 142         event.events |= EPOLLET;
 143     }
 144
 145     switch (init_mode) {
 146     case MK_EPOLL_READ:
 147         event.events |= EPOLLIN;
 148         break;
 149     case MK_EPOLL_WRITE:
 150         event.events |= EPOLLOUT;
 151         break;
 152     case MK_EPOLL_RW:
 153         event.events |= EPOLLIN | EPOLLOUT;
 154         break;
 155     }
 156
 157     ret = epoll_ctl(efd, EPOLL_CTL_ADD, fd, &event);
 158     if (ret < 0) {
 159         perror("epoll_ctl");
 160     }
 161     return ret;
 162 }
 163
 164 int mk_epoll_del(int efd, int fd)
 165 {
 166     int ret;
 167
 168     ret = epoll_ctl(efd, EPOLL_CTL_DEL, fd, NULL);
 169
 170 #ifdef TRACE
 171     MK_TRACE("Epoll, removing fd %i from efd %i", fd, efd);
 172 #endif
 173
 174     if (ret < 0) {
 175         perror("\nepoll_ctl");
 176     }
 177     return ret;
 178 }
 179
 180 int mk_epoll_change_mode(int efd, int fd, int mode)
 181 {
 182     int ret;
 183     struct epoll_event event;
 184
 185     event.events = EPOLLET | EPOLLERR | EPOLLHUP;
 186     event.data.fd = fd;
 187
 188     switch (mode) {
 189     case MK_EPOLL_READ:
 190 #ifdef TRACE
 191         MK_TRACE("[FD %i] EPoll changing mode to READ", fd);
 192 #endif
 193         event.events |= EPOLLIN;
 194         break;
 195     case MK_EPOLL_WRITE:
 196 #ifdef TRACE
 197         MK_TRACE("[FD %i] EPoll changing mode to WRITE", fd);
 198 #endif
 199         event.events |= EPOLLOUT;
 200         break;
 201     case MK_EPOLL_RW:
 202 #ifdef TRACE
 203         MK_TRACE("[FD %i] Epoll changing mode to READ/WRITE", fd);
 204 #endif
 205         event.events |= EPOLLIN | EPOLLOUT;
 206         break;
 207     }
 208
 209     ret = epoll_ctl(efd, EPOLL_CTL_MOD, fd, &event);
 210     if (ret < 0) {
 211         perror("\nepoll_ctl");
 212     }
 213     return ret;
 214 }