jabberd2  2.2.16
mio/mio_epoll.h
Go to the documentation of this file.
00001 /*
00002  * jabberd - Jabber Open Source Server
00003  * Copyright (c) 2002 Jeremie Miller, Thomas Muldowney,
00004  *                    Ryan Eatmon, Robert Norris, Christof Meerwald
00005  *
00006  * This program is free software; you can redistribute it and/or modify
00007  * it under the terms of the GNU General Public License as published by
00008  * the Free Software Foundation; either version 2 of the License, or
00009  * (at your option) any later version.
00010  *
00011  * This program is distributed in the hope that it will be useful,
00012  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00013  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
00014  * GNU General Public License for more details.
00015  *
00016  * You should have received a copy of the GNU General Public License
00017  * along with this program; if not, write to the Free Software
00018  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA02111-1307USA
00019  */
00020 
00021 /* MIO backend for epoll() */
00022 
00023 #include <sys/epoll.h>
00024 
00025 #define MIO_FUNCS \
00026     static int _mio_poll(mio_t m, int t)                                \
00027     {                                                                   \
00028         return epoll_wait(MIO(m)->epoll_fd,                             \
00029                           MIO(m)->res_event, 32, t*1000);               \
00030     }                                                                   \
00031                                                                         \
00032     static mio_fd_t _mio_alloc_fd(mio_t m, int fd)                      \
00033     {                                                                   \
00034         struct epoll_event event;                                       \
00035         mio_priv_fd_t priv_fd = malloc(sizeof (struct mio_priv_fd_st)); \
00036         memset(priv_fd, 0, sizeof (struct mio_priv_fd_st));             \
00037                                                                         \
00038         priv_fd->mio_fd.fd = fd;                                        \
00039         priv_fd->events = 0;                                            \
00040                                                                         \
00041         event.events = priv_fd->events;                                 \
00042         event.data.u64 = 0;                                             \
00043         event.data.ptr = priv_fd;                              \
00044         epoll_ctl(MIO(m)->epoll_fd, EPOLL_CTL_ADD, fd, &event);         \
00045                                                                         \
00046         return (mio_fd_t)priv_fd;                                        \
00047     }
00048 
00049 
00050 #define MIO_FD_VARS \
00051     uint32_t events;
00052 
00053 #define MIO_VARS \
00054     int defer_free;                                                     \
00055     int epoll_fd;                                                       \
00056     struct epoll_event res_event[32];
00057 
00058 #define MIO_INIT_VARS(m) \
00059     do {                                                                \
00060         MIO(m)->defer_free = 0;                                         \
00061         if ((MIO(m)->epoll_fd = epoll_create(maxfd)) < 0)               \
00062         {                                                               \
00063             mio_debug(ZONE,"unable to initialize epoll mio");           \
00064             free(m);                                                    \
00065             return NULL;                                                \
00066         }                                                               \
00067     } while(0)
00068 #define MIO_FREE_VARS(m) \
00069     do {                                                                \
00070         close(MIO(m)->epoll_fd);                                        \
00071     } while(0)
00072 
00073 
00074 #define MIO_ALLOC_FD(m, rfd)    _mio_alloc_fd(m, rfd)
00075 #define MIO_FREE_FD(m, mfd)     if(mfd)free(mfd)
00076 
00077 #define MIO_REMOVE_FD(m, mfd) \
00078     do {                                                                \
00079         struct epoll_event event;                                       \
00080         event.events = 0;                                               \
00081         event.data.u64 = 0;                                             \
00082         event.data.ptr = mfd;                                           \
00083         epoll_ctl(MIO(m)->epoll_fd, EPOLL_CTL_DEL,                      \
00084                   mfd->mio_fd.fd, &event);                              \
00085     } while (0)
00086 
00087 #define MIO_CHECK(m, t)         _mio_poll(m, t)
00088 
00089 #define MIO_SET_READ(m, mfd) \
00090     do {                                                                \
00091         struct epoll_event event;                                       \
00092         mfd->events |= EPOLLIN;                                         \
00093         event.events = mfd->events;                                     \
00094         event.data.u64 = 0;                                             \
00095         event.data.ptr = mfd;                                           \
00096         epoll_ctl(MIO(m)->epoll_fd, EPOLL_CTL_MOD,                      \
00097                   mfd->mio_fd.fd, &event);                              \
00098     } while (0)
00099 
00100 #define MIO_SET_WRITE(m, mfd) \
00101     do {                                                                \
00102         struct epoll_event event;                                       \
00103         mfd->events |= EPOLLOUT;                                        \
00104         event.events = mfd->events;                                     \
00105         event.data.u64 = 0;                                             \
00106         event.data.ptr = mfd;                                           \
00107         epoll_ctl(MIO(m)->epoll_fd, EPOLL_CTL_MOD,                      \
00108                   mfd->mio_fd.fd, &event);                              \
00109     } while (0)
00110 
00111 #define MIO_UNSET_READ(m, mfd) \
00112     do {                                                                \
00113         struct epoll_event event;                                       \
00114         mfd->events &= ~EPOLLIN;                                        \
00115         event.events = mfd->events;                                     \
00116         event.data.u64 = 0;                                             \
00117         event.data.ptr = mfd;                                           \
00118         epoll_ctl(MIO(m)->epoll_fd, EPOLL_CTL_MOD,                      \
00119                   mfd->mio_fd.fd, &event);                              \
00120     } while (0)
00121 #define MIO_UNSET_WRITE(m, mfd) \
00122     do {                                                                \
00123         struct epoll_event event;                                       \
00124         mfd->events &= ~(EPOLLOUT);                                     \
00125         event.events = mfd->events;                                     \
00126         event.data.u64 = 0;                                             \
00127         event.data.ptr = mfd;                                           \
00128         epoll_ctl(MIO(m)->epoll_fd, EPOLL_CTL_MOD,                      \
00129                   mfd->mio_fd.fd, &event);                              \
00130     } while (0)
00131 
00132 
00133 #define MIO_CAN_READ(m,iter) \
00134     (MIO(m)->res_event[iter].events & (EPOLLIN|EPOLLERR|EPOLLHUP))
00135 
00136 #define MIO_CAN_WRITE(m,iter) \
00137     (MIO(m)->res_event[iter].events & EPOLLOUT)
00138 
00139 #define MIO_CAN_FREE(m)         (!MIO(m)->defer_free)
00140 
00141 #define MIO_INIT_ITERATOR(iter) \
00142     int iter
00143 
00144 #define MIO_ITERATE_RESULTS(m, retval, iter) \
00145     for(MIO(m)->defer_free = 1, iter = 0; (iter < retval) || ((MIO(m)->defer_free = 0)); iter++)
00146 
00147 #define MIO_ITERATOR_FD(m, iter) \
00148     (MIO(m)->res_event[iter].data.ptr)