src/ae_epoll.c

   1 /* Linux epoll(2) based ae.c module
   2  *
   3  * Copyright (c) 2009-2012, Salvatore Sanfilippo <antirez at gmail dot com>
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions are met:
   8  *
   9  *   * Redistributions of source code must retain the above copyright notice,
  10  *     this list of conditions and the following disclaimer.
  11  *   * Redistributions in binary form must reproduce the above copyright
  12  *     notice, this list of conditions and the following disclaimer in the
  13  *     documentation and/or other materials provided with the distribution.
  14  *   * Neither the name of Redis nor the names of its contributors may be used
  15  *     to endorse or promote products derived from this software without
  16  *     specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  19  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  22  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  23  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  24  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  25  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  26  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  27  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  28  * POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31
  32 #include <sys/epoll.h>
  33
  34 typedef struct aeApiState {
  35     int epfd;
  36     struct epoll_event *events;
  37 } aeApiState;
  38
  39 static int aeApiCreate(aeEventLoop *eventLoop) {
  40     aeApiState *state = zmalloc(sizeof(aeApiState));
  41
  42     if (!state) return -1;
  43     state->events = zmalloc(sizeof(struct epoll_event)*eventLoop->setsize);
  44     if (!state->events) {
  45         zfree(state);
  46         return -1;
  47     }
  48     state->epfd = epoll_create(1024); /* 1024 is just an hint for the kernel */
  49     if (state->epfd == -1) {
  50         zfree(state->events);
  51         zfree(state);
  52         return -1;
  53     }
  54     eventLoop->apidata = state;
  55     return 0;
  56 }
  57
  58 static void aeApiFree(aeEventLoop *eventLoop) {
  59     aeApiState *state = eventLoop->apidata;
  60
  61     close(state->epfd);
  62     zfree(state->events);
  63     zfree(state);
  64 }
  65
  66 static int aeApiAddEvent(aeEventLoop *eventLoop, int fd, int mask) {
  67     aeApiState *state = eventLoop->apidata;
  68     struct epoll_event ee;
  69     /* If the fd was already monitored for some event, we need a MOD
  70      * operation. Otherwise we need an ADD operation. */
  71     int op = eventLoop->events[fd].mask == AE_NONE ?
  72             EPOLL_CTL_ADD : EPOLL_CTL_MOD;
  73
  74     ee.events = 0;
  75     mask |= eventLoop->events[fd].mask; /* Merge old events */
  76     if (mask & AE_READABLE) ee.events |= EPOLLIN;
  77     if (mask & AE_WRITABLE) ee.events |= EPOLLOUT;
  78     ee.data.u64 = 0; /* avoid valgrind warning */
  79     ee.data.fd = fd;
  80     if (epoll_ctl(state->epfd,op,fd,&ee) == -1) return -1;
  81     return 0;
  82 }
  83
  84 static void aeApiDelEvent(aeEventLoop *eventLoop, int fd, int delmask) {
  85     aeApiState *state = eventLoop->apidata;
  86     struct epoll_event ee;
  87     int mask = eventLoop->events[fd].mask & (~delmask);
  88
  89     ee.events = 0;
  90     if (mask & AE_READABLE) ee.events |= EPOLLIN;
  91     if (mask & AE_WRITABLE) ee.events |= EPOLLOUT;
  92     ee.data.u64 = 0; /* avoid valgrind warning */
  93     ee.data.fd = fd;
  94     if (mask != AE_NONE) {
  95         epoll_ctl(state->epfd,EPOLL_CTL_MOD,fd,&ee);
  96     } else {
  97         /* Note, Kernel < 2.6.9 requires a non null event pointer even for
  98          * EPOLL_CTL_DEL. */
  99         epoll_ctl(state->epfd,EPOLL_CTL_DEL,fd,&ee);
 100     }
 101 }
 102
 103 static int aeApiPoll(aeEventLoop *eventLoop, struct timeval *tvp) {
 104     aeApiState *state = eventLoop->apidata;
 105     int retval, numevents = 0;
 106
 107     retval = epoll_wait(state->epfd,state->events,eventLoop->setsize,
 108             tvp ? (tvp->tv_sec*1000 + tvp->tv_usec/1000) : -1);
 109     if (retval > 0) {
 110         int j;
 111
 112         numevents = retval;
 113         for (j = 0; j < numevents; j++) {
 114             int mask = 0;
 115             struct epoll_event *e = state->events+j;
 116
 117             if (e->events & EPOLLIN) mask |= AE_READABLE;
 118             if (e->events & EPOLLOUT) mask |= AE_WRITABLE;
 119             if (e->events & EPOLLERR) mask |= AE_WRITABLE;
 120             if (e->events & EPOLLHUP) mask |= AE_WRITABLE;
 121             eventLoop->fired[j].fd = e->data.fd;
 122             eventLoop->fired[j].mask = mask;
 123         }
 124     }
 125     return numevents;
 126 }
 127
 128 static char *aeApiName(void) {
 129     return "epoll";
 130 }